Journalisation en Rust : meilleures bibliothèques |…

Journalisation pour Rust : meilleures solutions

La journalisation est un composant essentiel de toute application sérieuse en Rust. Elle permet de suivre l'exécution du code, d'identifier les erreurs, de surveiller les performances et d'analyser le comportement du système en production. Dans cet article, nous examinerons les principales bibliothèques de journalisation dans l'écosystème Rust, leurs caractéristiques, avantages et exemples d'utilisation.

Pourquoi la journalisation est-elle importante en Rust ?

Rust, en tant que langage système, impose des exigences élevées en matière de fiabilité et de prévisibilité. La journalisation permet de :

Suivre le flux d'exécution dans les applications multithread.
Enregistrer les états inattendus et les paniques.
Effectuer des audits de sécurité.
Collecter des métriques pour optimiser les performances.

Principales bibliothèques de journalisation

1. `log` — façade de journalisation

log est la façade standard (couche abstraite) pour la journalisation en Rust. Elle définit les macros info!, warn!, error!, debug!, trace! et le trait Log. En elle-même, elle n'affiche pas les journaux — un backend est nécessaire (par exemple, env_logger ou slog).

// Cargo.toml[dependencies]log = "0.4"

// main.rsuse log::{info, warn, error};

fn main() {    // L'initialisation du backend est obligatoire    env_logger::init();    info!("Application démarrée");    warn!("Niveau de mémoire bas : {}%", 15);    error!("Erreur critique : {}", "échec de connexion");}

2. `env_logger` — backend simple et rapide

env_logger est le backend le plus populaire pour log. Il se configure via la variable d'environnement RUST_LOG. Il prend en charge le filtrage par modules et par niveaux.

// Installation// cargo add env_logger

// Exemple de configurationuse log::LevelFilter;

fn main() {    env_logger::Builder::from_env(        env_logger::Env::default().default_filter_or("info")    ).init();

    log::info!("Lancement avec le niveau INFO");    log::debug!("Ce message ne sera pas affiché");}

// Lancement avec la variable :// RUST_LOG=debug cargo run

3. `slog` — journalisation structurée

slog est une bibliothèque puissante pour la journalisation structurée. Elle prend en charge les paires clé-valeur, les chaînes de journalisation, l'écriture asynchrone et les pilotes personnalisés. Idéale pour les systèmes complexes où le contexte est important.

// Cargo.toml[dependencies]slog = "2.7"slog-term = "2.9"slog-json = "2.6"

// main.rsuse slog::{o, Drain, Logger, info};

fn main() {    let decorator = slog_term::TermDecorator::new().build();    let drain = slog_term::FullFormat::new(decorator).build().fuse();    let drain = slog_async::Async::new(drain).build().fuse();

    let logger = Logger::root(drain, o!("version" => "1.0"));

    info!(logger, "Serveur démarré"; "port" => 8080, "env" => "production");}

4. `tracing` — instrumentation et traçage

tracing est une bibliothèque moderne de l'équipe Tokio, conçue pour la journalisation structurée et le traçage. Elle permet de créer des spans (intervalles temporels avec contexte), ce qui est indispensable pour les applications asynchrones et multithread.

// Cargo.toml[dependencies]tracing = "0.1"tracing-subscriber = "0.3"

// main.rsuse tracing::{info, span, Level};use tracing_subscriber::fmt;

fn main() {    // Initialisation du subscriber    fmt::init();

    let span = span!(Level::INFO, "main", "app" = "my_service");    let _guard = span.enter();

    info!("Traitement de la requête");    // Les logs à l'intérieur du span contiennent automatiquement le contexte}