Surveillance des applications Rust : la bibliothèque tracing et les métriques

Surveillance des applications Rust : la bibliothèque tracing et la collecte de métriques

La surveillance est un élément clé des systèmes de production. Pour les applications en Rust, réputées pour leurs performances et leur fiabilité, il est important de disposer d'un outil léger et efficace pour collecter la télémétrie. La bibliothèque tracing est devenue le standard de facto pour l'observabilité dans l'écosystème Rust. Elle fournit une journalisation structurée, des spans pour le traçage des requêtes et une intégration avec les systèmes de collecte de métriques.

Qu'est-ce que tracing ?

tracing est un framework pour l'instrumentation de programmes Rust. Contrairement à la journalisation classique, il fonctionne sur la base d'événements (events) et de spans. Les spans représentent des intervalles de temps d'exécution de code (par exemple, le traitement d'une requête HTTP), tandis que les événements sont des points à l'intérieur des spans (par exemple, « la base de données a répondu en 10 ms »).

Fonctionnalités principales :

• Journalisation structurée — chaque événement contient des champs (clé-valeur), et non simplement une chaîne de caractères.
• Hiérarchie des spans — il est possible d'imbriquer les spans les uns dans les autres, en suivant le chemin d'exécution complet.
• Support asynchrone — fonctionne parfaitement avec tokio et async/await.
• Subscriber (abonné) — il est possible de connecter différents backends : stdout, OpenTelemetry, Prometheus, fichiers.

Installation et utilisation de base

Ajoutez dans Cargo.toml :

[dependencies]tracing = "0.1"tracing-subscriber = "0.3"

Exemple simple de journalisation structurée :

use tracing::{info, warn, error};use tracing_subscriber;

fn main() {    // Initialisons un subscriber pour la sortie stdout    tracing_subscriber::fmt::init();

    let user_id = 42;    let request_duration_ms = 150;

    info!(user_id, duration = request_duration_ms, "Requête traitée");

    // Journalisation avec niveau warn    warn!(user_id, "Le temps de réponse dépasse le seuil");

    // Journalisation avec erreur    error!("Impossible de se connecter à la base de données");}

La sortie contiendra les champs dans un format de type JSON, ce qui facilite l'analyse dans les systèmes de surveillance.

Spans et traçage

Les spans permettent de mesurer le temps d'exécution des opérations et de lier les événements en une chaîne :

use tracing::{span, info, Level};use tracing_subscriber;

fn process_request(user_id: u32) {    // Créons un span avec un contexte    let span = span!(Level::INFO, "process_request", user_id);    let _guard = span.enter(); // activons le span

    info!("Début du traitement");    std::thread::sleep(std::time::Duration::from_millis(50));    info!("Traitement terminé");}

fn main() {    tracing_subscriber::fmt::init();    process_request(100);}

Dans la sortie, un contexte imbriqué apparaîtra, montrant que les événements appartiennent au span process_request.

Collecte de métriques avec tracing et Prometheus

Pour la surveillance en production, il est souvent nécessaire d'exporter des métriques vers Prometheus. Utilisez la crate tracing-appender pour écrire dans un fichier ou tracing-opentelemetry pour l'intégration avec OpenTelemetry. Cependant, le moyen le plus direct est d'utiliser la bibliothèque metrics avec tracing.

Exemple d'intégration avec metrics-exporter-prometheus :

[dependencies]metrics = "0.21"metrics-exporter-prometheus = "0.12"tracing = "0.1"tokio = { version = "1", features = ["full"] }

Code pour la collecte de métriques :

use metrics::{counter, gauge, histogram};use metrics_exporter_prometheus::PrometheusBuilder;use std::net::SocketAddr;

#[tokio::main]async fn main() {    // Démarrons un serveur HTTP pour Prometheus    let addr: SocketAddr = "0.0.0.0:9090".parse().unwrap();    let builder = PrometheusBuilder::new();    builder        .wit