Registro en Rust: mejores bibliotecas

Registro para Rust: mejores soluciones

El registro es un componente crítico de cualquier aplicación seria en Rust. Ayuda a rastrear la ejecución del código, detectar errores, monitorear el rendimiento y analizar el comportamiento del sistema en producción. En este artículo, revisaremos las principales bibliotecas para registro en el ecosistema de Rust, sus características, ventajas y ejemplos de uso.

¿Por qué es importante el registro en Rust?

Rust, al ser un lenguaje de sistemas, exige altos estándares de confiabilidad y previsibilidad. El registro permite:

Rastrear el flujo de ejecución en aplicaciones multiproceso.
Registrar estados inesperados y pánicos.
Realizar auditorías de seguridad.
Recopilar métricas para optimizar el rendimiento.

Bibliotecas principales para registro

1. `log` — Fachada para registro

log es la fachada estándar (capa abstracta) para registro en Rust. Define las macros info!, warn!, error!, debug!, trace! y el trait Log. Por sí mismo no genera registros — para eso se necesita un backend (por ejemplo, env_logger o slog).

// Cargo.toml[dependencies]log = "0.4"

// main.rsuse log::{info, warn, error};

fn main() {    // La inicialización del backend es obligatoria    env_logger::init();    info!("Aplicación iniciada");    warn!("Bajo nivel de memoria: {}%", 15);    error!("Error crítico: {}", "fallo de conexión");}

2. `env_logger` — Backend simple y rápido

env_logger es el backend más popular para log. Se configura mediante la variable de entorno RUST_LOG. Soporta filtrado por módulos y niveles.

// Instalación// cargo add env_logger

// Ejemplo de configuraciónuse log::LevelFilter;

fn main() {    env_logger::Builder::from_env(        env_logger::Env::default().default_filter_or("info")    ).init();

    log::info!("Iniciando con nivel INFO");    log::debug!("Este mensaje no se mostrará");}

// Ejecutar con variable:// RUST_LOG=debug cargo run

3. `slog` — Registro estructurado

slog es una potente biblioteca para registro estructurado. Soporta clave-valor, cadenas de registradores, escritura asíncrona y controladores personalizados. Ideal para sistemas complejos donde el contexto es importante.

// Cargo.toml[dependencies]slog = "2.7"slog-term = "2.9"slog-json = "2.6"

// main.rsuse slog::{o, Drain, Logger, info};

fn main() {    let decorator = slog_term::TermDecorator::new().build();    let drain = slog_term::FullFormat::new(decorator).build().fuse();    let drain = slog_async::Async::new(drain).build().fuse();

    let logger = Logger::root(drain, o!("version" => "1.0"));

    info!(logger, "Servidor iniciado"; "port" => 8080, "env" => "production");}

4. `tracing` — Instrumentación y trazado

tracing es una biblioteca moderna del equipo de Tokio, diseñada para registro estructurado y trazado. Permite crear spans — intervalos temporales con contexto, esenciales para aplicaciones asíncronas y multiproceso.

// Cargo.toml[dependencies]tracing = "0.1"tracing-subscriber = "0.3"

// main.rsuse tracing::{info, span, Level};use tracing_subscriber::fmt;

fn main() {    // Inicialización del suscriptor    fmt::init();

    let span = span!(Level::INFO, "main", "app" = "my_service");    let _guard = span.enter();

    info!("Procesando solicitud");    // Los registros dentro del span contienen contexto automáticamente}