Structured Tracing

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

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

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

forms — Form pipeline

admin — Admin panel

auth — Authentication

mailer

builder — Startup (one-time)

templates — Template engine

migration — Migrations

errors — HTTP error pages

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

middleware — Security (.middleware(|m| m....))

session — Store (.session(|s| s....))

db — Database (.db(\|d\| d....))

These three domains have no direct method on RuniqueLog — each goes through its own closure (.middleware(|m| ...), .session(|s| ...), .db(|d| ...)), same as forms/admin/auth above.

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();

    let db = DatabaseConfig::from_env()?.build().connect().await?;

    RuniqueApp::builder(RuniqueConfig::from_env())
        .with_database(db)
        .routes(url::routes())
        .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).