Journalisation en Rust : aperçu des meilleures bibliothèques et outils

Journalisation pour Rust : les meilleures solutions

La journalisation est l'un des composants clés de toute application de production. Dans l'écosystème Rust, une pile d'outils mature s'est développée, permettant de configurer de manière flexible la collecte, le formatage et la sortie des journaux. Dans cet article, nous passerons en revue les principales bibliothèques, leurs fonctionnalités et des exemples d'utilisation.

1. La crate log — une abstraction pour la journalisation

La bibliothèque log est le fondement de tout le système de journalisation en Rust. Elle fournit une façade (facade) — un ensemble de traits et de macros qui ne dépendent pas d'un backend spécifique. Vous écrivez le code une fois, et la sortie des journaux est configurée via un logger externe.

Macros principales :

• error! — erreurs critiques
• warn! — avertissements
• info! — messages informatifs
• debug! — informations de débogage
• trace! — traçage détaillé

Exemple d'utilisation :

use log::{info, warn, error};

fn main() {    // Avant utilisation, il faut initialiser le logger    // env_logger::init(); // ou un autre backend        info!("Application démarrée");    warn!("Disque plein à 90%");    error!("Erreur de connexion à la BD : {:?}", err);}

2. env_logger — simplicité et flexibilité

Le backend le plus populaire pour log. La configuration se fait via la variable d'environnement RUST_LOG. C'est le choix idéal pour les petits projets et les utilitaires.

Installation :

[dependencies]log = "0.4"env_logger = "0.11"

Exemple avec filtrage par modules :

use log::info;

fn main() {    env_logger::init();        // Lancez : RUST_LOG=my_crate=info cargo run    info!("Ce message apparaîtra uniquement pour my_crate");        // RUST_LOG=warn — affichera uniquement warn et error    // RUST_LOG=debug — affichera tout, y compris debug}

La variable RUST_LOG prend en charge des filtres complexes :

• RUST_LOG=info — niveau info et supérieur
• RUST_LOG=my_crate=debug,other_crate=warn — différents niveaux pour différentes crates
• RUST_LOG=off — désactiver la journalisation

3. log4rs — configuration via YAML

Si vous avez besoin d'un contrôle avancé — plusieurs appenders (fichier, console, syslog), rotation des journaux, formatage — choisissez log4rs. Il s'inspire de Java Log4j.

Exemple de configuration log4rs.yaml :

refresh_rate: 30 seconds

appenders:  stdout:    kind: console    encoder:      pattern: "{d(%Y-%m-%d %H:%M:%S)} [{l}] {m}{n}"  file:    kind: file    path: "app.log"    encoder:      pattern: "{d} {l} {M} - {m}{n}"

root:  level: info  appenders:    - stdout

loggers:  app::db:    level: debug    appenders:      - file    additive: false

Initialisation dans le code :

use log4rs;

fn main() {    log4rs::init_file("log4rs.yaml", Default::default()).unwrap();        log::info!("Journalisation configurée via YAML");    log::debug!("Ce message ira uniquement dans le fichier");}

Fonctionnalités clés de log4rs :

• Rotation des journaux par taille ou par temps
• Différents appenders pour différents modules
• Rechargement automatique de la configuration
• Prise en charge du format JSON

4. tracing — une approche moderne

La bibliothèque tracing de l'équipe Tokio n'est pas seulement une journalisation, mais un système complet pour le diagnostic des applications. Elle prend en charge les événements structurés et les spans, ce qui est particulièrement utile dans les applications asynchrones.

Exemple avec des spans :

use tracing::{in