Métricas Prometheus em Rust: bibliotecas prometheus e metrics

Métricas Prometheus em Rust: monitoramento de desempenho e tolerância a falhas

No desenvolvimento moderno de aplicações backend em Rust, o monitoramento tornou-se uma parte essencial da infraestrutura de produção. O Prometheus é o padrão de facto para coleta e armazenamento de métricas, e sua integração com Rust permite rastrear desempenho, carga da CPU, número de requisições, erros e muito mais. Neste artigo, abordaremos duas bibliotecas principais: prometheus (cliente oficial) e metrics + metrics-exporter-prometheus (uma abordagem mais abstrata).

Por que métricas em Rust?

As métricas permitem:

• Monitorar o estado do serviço em tempo real
• Detectar gargalos (latência, erros)
• Criar dashboards no Grafana
• Configurar alertas (por exemplo, quando o QPS cai ou os erros aumentam)

Instalação e configuração da biblioteca prometheus

Adicione ao Cargo.toml:

[dependencies]prometheus = { version = "0.13", features = ["process"] }actix-web = "4"  # para exemplo com servidor webtokio = { version = "1", features = ["full"] }

A biblioteca prometheus fornece três tipos principais de métricas: Counter, Gauge, Histogram.

Exemplo: criação e registro de métricas

use prometheus::{Counter, Gauge, Histogram, HistogramOpts, Opts, Registry};

fn main() {    // Cria um registro de métricas    let registry = Registry::new();

    // Counter — contador de requisições    let request_counter = Counter::with_opts(        Opts::new("http_requests_total", "Total HTTP requests")            .const_label("service", "my_app")    ).unwrap();    registry.register(Box::new(request_counter.clone())).unwrap();

    // Gauge — número atual de conexões ativas    let active_connections = Gauge::with_opts(        Opts::new("active_connections", "Number of active connections")    ).unwrap();    registry.register(Box::new(active_connections.clone())).unwrap();

    // Histogram — distribuição do tempo de resposta    let request_duration = Histogram::with_opts(        HistogramOpts::new("http_request_duration_seconds", "Request duration in seconds")            .buckets(vec![0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0])    ).unwrap();    registry.register(Box::new(request_duration.clone())).unwrap();

    // Simulação de uso    request_counter.inc();    active_connections.set(42.0);    request_duration.observe(0.123);}

Exportação de métricas via HTTP (actix-web)

Para que o Prometheus possa coletar as métricas, é necessário disponibilizá-las no formato /metrics:

use actix_web::{web, App, HttpServer, HttpResponse, Responder};use prometheus::{Encoder, TextEncoder, Registry};use std::sync::Arc;

async fn metrics_handler(registry: web::Data<Arc<Registry>>) -> impl Responder {    let encoder = TextEncoder::new();    let mut buffer = Vec::new();    encoder.encode(®istry.gather(), &mut buffer).unwrap();    HttpResponse::Ok()        .content_type("text/plain; charset=utf-8")        .body(buffer)}

#[actix_web::main]async fn main() -> std::io::Result<()> {    let registry = Arc::new(Registry::new());    // ... registra as métricas como acima ...

    HttpServer::new(move || {        App::new()            .app_data(web::Data::new(registry.clone()))            .route("/metrics", web::get().to(metrics_handler))    })    .bind("127.0.0.1:9090")?    .run()    .await}

Biblioteca metrics — abordagem de alto nível

Uma alternativa é o crate metrics com o exportador metrics-exporter-prometheus. Ele fornece macros para criação rápida de métricas:

[dependencies]metrics = "0.21"metrics-exporter-prometheus = "0.