Structured Tracing

RuniqueApp::builder(config)
    .with_log(|l| l.dev())   // everything at DEBUG if DEBUG=true
    // ...

.dev() is a no-op if DEBUG is not true — safe to use unconditionally.

.with_log(|l| l
    .forms(|f| f
        .validate(Level::DEBUG)
        .finalize(Level::DEBUG)
    )
    .admin(|a| a
        .crud(Level::INFO)
        .auth(Level::WARN)
    )
    .auth(|a| a
        .login(Level::INFO)
        .reset(Level::WARN)
    )
    .mailer(|m| m.send(Level::INFO))
    .builder(|b| b
        .templates(Level::INFO)
        .middleware(Level::DEBUG)
        .routes(Level::INFO)
        .statics(Level::INFO)
    )
    .rate_limit(Level::WARN)
)

forms — Form pipeline

admin — Admin panel

auth — Authentication

mailer

builder — Startup (one-time)

errors — HTTP error pages

.with_log(|l| l.errors(|e| e.http(Level::INFO).render(Level::WARN)))

Flat fields on RuniqueLog

By default Runique installs a console subscriber (Stdout, colors). Configure one or more cumulative outputs via .output():

use runique::prelude::{LogOutput, LogRotation};

.with_log(|l| l
    .output(LogOutput::stdout())                 // colored console
    .output(LogOutput::file("logs/app.json"))    // JSON (inferred from the .json extension)
    .output(LogOutput::file("logs/app.log")      // plain text
        .rotation(LogRotation::Daily)))

• The format is inferred from the extension: .json → structured JSON (one event per line), otherwise plain text.
• File writing is non-blocking; logs are flushed cleanly on shutdown.
• Rotation: Daily (default), Hourly, Never.
• RUNIQUE_LOG_FILE=/path/app.json adds a file output at runtime, without recompiling.

To route logs to an arbitrary destination (database, HTTP collector, message queue), implement LogSink — no tracing type is exposed:

use runique::prelude::{LogOutput, LogRecord, LogSink};

struct MySink;

impl LogSink for MySink {
    fn log(&self, record: &LogRecord) {
        // record.level / target / message / file / line / fields
        // Must not block: for async, enqueue into your own channel.
    }
}

.with_log(|l| l.output(LogOutput::sink(MySink)))

The sink receives all events in the process (Runique and your application); tell them apart via record.target (Runique events have a target starting with runique). Runique deliberately ships no database sink (it would overload the DB) — LogSink is the hook to wire one yourself.

If your application owns its own tracing subscriber (custom layer stack, OpenTelemetry…), declare .external(): Runique installs nothing and leaves you the single global slot, while still emitting its events to the tracing facade (your subscriber receives them).

Minimal:

.with_log(|l| l.external())

Full:

use runique::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // You install YOUR subscriber, before build()
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .init();

    RuniqueApp::builder(RuniqueConfig::from_env())
        .with_database().await
        .routes(url::urlpatterns())
        .with_log(|l| l.external())   // Runique does not install its subscriber
        .build().await?
        .run().await
}

To ignore Runique's internal logs, filter their target in your EnvFilter:

tracing_subscriber::fmt()
    .with_env_filter("info,runique=off")   // keep your logs, mute Runique's
    .init();

In .external() mode, .output() destinations are ignored (your subscriber decides where logs go).