Tracing structuré

RuniqueApp::builder(config)
    .with_log(|l| l.dev())   // tout à DEBUG si DEBUG=true
    // ...

.dev() est un no-op si DEBUG n'est pas true — utilisable inconditionnellement.

.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 — Pipeline formulaire

admin — Panel admin

auth — Authentification

mailer

builder — Démarrage (one-time)

errors — Pages d'erreur HTTP

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

Champs plats sur RuniqueLog

Par défaut Runique installe un subscriber console (Stdout, couleurs). On configure une ou plusieurs sorties cumulables via .output() :

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

.with_log(|l| l
    .output(LogOutput::stdout())                 // console couleurs
    .output(LogOutput::file("logs/app.json"))    // JSON (déduit de l'extension .json)
    .output(LogOutput::file("logs/app.log")      // texte brut
        .rotation(LogRotation::Daily)))

• Le format est déduit de l'extension : .json → JSON structuré (une ligne par événement), sinon texte brut.
• L'écriture fichier est non bloquante ; les logs sont vidés proprement à l'extinction.
• Rotation : Daily (défaut), Hourly, Never.
• RUNIQUE_LOG_FILE=/chemin/app.json ajoute une sortie fichier au runtime, sans recompiler.

Pour router les logs vers une destination arbitraire (base de données, collecteur HTTP, file de messages), implémente LogSink — aucun type tracing n'est exposé :

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

struct MonSink;

impl LogSink for MonSink {
    fn log(&self, record: &LogRecord) {
        // record.level / target / message / file / line / fields
        // Ne bloque pas : pour de l'async, enfile dans ton propre channel.
    }
}

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

Le sink reçoit tous les événements du process (Runique et ton application) ; distingue-les par record.target (les événements Runique ont un target commençant par runique). Runique ne fournit volontairement pas de sink base de données (cela surchargerait la DB) — LogSink est la porte pour le brancher toi-même.

Si ton application gère son propre subscriber tracing (stack de layers custom, OpenTelemetry…), déclare .external() : Runique n'installe rien et te laisse le créneau global unique, tout en continuant d'émettre ses événements vers la façade tracing (ton subscriber les reçoit).

Minimal :

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

Complet :

use runique::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Tu poses TON subscriber, avant 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 n'installe pas son subscriber
        .build().await?
        .run().await
}

Pour ignorer les logs internes de Runique, filtre leur target dans ton EnvFilter :

tracing_subscriber::fmt()
    .with_env_filter("info,runique=off")   // garde tes logs, coupe ceux de Runique
    .init();

En mode .external(), les sorties .output() sont ignorées (c'est ton subscriber qui décide où vont les logs).