Monitoramento de aplicações Rust: biblioteca tracing e métricas

Monitoramento de aplicações Rust: biblioteca tracing e coleta de métricas

Monitoramento é um elemento chave em sistemas de produção. Para aplicações em Rust, conhecidas por seu desempenho e confiabilidade, é importante ter uma ferramenta leve e eficiente para coleta de telemetria. A biblioteca tracing tornou-se o padrão de facto para observabilidade no ecossistema Rust. Ela fornece registro estruturado, spans para rastreamento de requisições e integração com sistemas de coleta de métricas.

O que é tracing?

tracing é um framework para instrumentação de programas Rust. Diferente do registro clássico, ele funciona com base em eventos (events) e spans. Spans representam intervalos de tempo de execução de código (por exemplo, processamento de uma requisição HTTP), enquanto eventos são pontos dentro dos spans (por exemplo, "banco de dados respondeu em 10 ms").

Principais funcionalidades:

• Registro estruturado — cada evento contém campos (chave-valor), não apenas uma string.
• Hierarquia de spans — é possível aninhar spans uns nos outros, rastreando o caminho completo de execução.
• Suporte assíncrono — funciona perfeitamente com tokio e async/await.
• Subscriber (assinante) — é possível conectar diferentes backends: stdout, OpenTelemetry, Prometheus, arquivos.

Instalação e uso básico

Adicione ao Cargo.toml:

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

Exemplo simples de registro estruturado:

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

fn main() {    // Inicializa o subscriber para saída em stdout    tracing_subscriber::fmt::init();

    let user_id = 42;    let request_duration_ms = 150;

    info!(user_id, duration = request_duration_ms, "Requisição processada");

    // Registro com nível warn    warn!(user_id, "Tempo de resposta excede o limite");

    // Registro com erro    error!("Falha ao conectar ao banco de dados");}

A saída conterá campos em formato de string semelhante a JSON, facilitando o parsing em sistemas de monitoramento.

Spans e rastreamento

Spans permitem medir o tempo de execução de operações e vincular eventos em uma cadeia:

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

fn process_request(user_id: u32) {    // Cria um span com contexto    let span = span!(Level::INFO, "process_request", user_id);    let _guard = span.enter(); // ativa o span

    info!("Início do processamento");    std::thread::sleep(std::time::Duration::from_millis(50));    info!("Processamento concluído");}

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

Na saída, aparecerá um contexto aninhado, mostrando que os eventos pertencem ao span process_request.

Coleta de métricas com tracing e Prometheus

Para monitoramento em produção, frequentemente é necessário exportar métricas para o Prometheus. Use a crate tracing-appender para gravação em arquivo ou tracing-opentelemetry para integração com OpenTelemetry. No entanto, o caminho mais direto é usar a biblioteca metrics junto com tracing.

Exemplo de integração com metrics-exporter-prometheus:

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

Código para coleta de métricas:

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

#[tokio::main]async fn main() {    // Inicia o servidor HTTP para o Prometheus    let addr: SocketAddr = "0.0.0.0:9090".parse().unwrap();    let builder = PrometheusBuilder::new();    builder        .wit