Métricas de Prometheus en Rust: bibliotecas prometheus y metrics

Métricas de Prometheus en Rust: monitoreo de rendimiento y tolerancia a fallos

En el desarrollo moderno de aplicaciones backend en Rust, el monitoreo se ha convertido en una parte esencial de la infraestructura de producción. Prometheus es el estándar de facto para la recopilación y almacenamiento de métricas, y su integración con Rust permite rastrear el rendimiento, la carga de CPU, el número de solicitudes, errores y mucho más. En este artículo, exploraremos dos bibliotecas principales: prometheus (el cliente oficial) y metrics + metrics-exporter-prometheus (un enfoque más abstracto).

¿Por qué son necesarias las métricas en Rust?

Las métricas permiten:

• Monitorear el estado del servicio en tiempo real
• Detectar cuellos de botella (latencia, errores)
• Crear paneles en Grafana
• Configurar alertas (por ejemplo, ante una caída de QPS o un aumento de errores)

Instalación y configuración de la biblioteca prometheus

Añada a Cargo.toml:

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

La biblioteca prometheus proporciona tres tipos principales de métricas: Counter, Gauge, Histogram.

Ejemplo: creación y registro de métricas

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

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

    // Counter — contador de solicitudes    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 actual de conexiones activas    let active_connections = Gauge::with_opts(        Opts::new("active_connections", "Number of active connections")    ).unwrap();    registry.register(Box::new(active_connections.clone())).unwrap();

    // Histogram — distribución del tiempo de respuesta    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();

    // Simulación de uso    request_counter.inc();    active_connections.set(42.0);    request_duration.observe(0.123);}

Exportación de métricas a través de HTTP (actix-web)

Para que Prometheus pueda recopilar las métricas, es necesario exponerlas en el 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());    // ... registramos las métricas como arriba ...

    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 — enfoque de alto nivel

Una alternativa es el crate metrics con el exportador metrics-exporter-prometheus. Proporciona macros para la creación rápida de métricas:

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