Crate context_logger

Overview

A lightweight, ergonomic library for adding structured context to your logs.

context-logger enhances the standard Rust log crate ecosystem by allowing you to attach rich contextual information to your log messages without changing your existing logging patterns.

Modern applications often need rich, structured context in logs to provide insight into runtime behavior. This library simplifies the process by:

• Adding structured context to logs without modifying the existing logging statements.
• Propagating log context across async boundaries.
• Allowing dynamic context updates.
• Supporting nested contexts to build hierarchical relationships.

This library provides a wrapper around other existing logger implementations, acting as a middleware layer that enriches log records with additional context before passing them to the underlying logger. It works with any logger that implements the standard Log trait, making it compatible with popular logging frameworks like env_logger, log4rs and others.

Basic example

use context_logger::{ContextLogger, LogContext};
use log::info;

fn main() {
    // Create a logger.
    let env_logger = env_logger::builder().build();
    let max_level = env_logger.filter();
    // Wrap it with ContextLogger to enable context propagation.
    let context_logger = ContextLogger::new(env_logger);
    // Initialize the resulting logger.
    context_logger.init(max_level);   

    // Create a context
    let ctx = LogContext::new()
        .record("request_id", "req-123")
        .record("user_id", 42);
    
    // Use the context
    let _guard = ctx.enter();
    
    // Log with context automatically attached
    info!("Processing request"); // Will include request_id=req-123 and user_id=42
}

Async Context Propagation

Context logger supports async functions and can propagate log context across .await points.

use context_logger::{ContextLogger, LogContext, FutureExt};
use log::info;

async fn process_user_data(user_id: &str) {
    let context = LogContext::new().record("user_id", user_id);
    
    async {
        info!("Processing user data"); // Includes user_id
        
        // Context automatically propagates through .await points
        fetch_user_preferences().await;
        
        info!("User data processed"); // Still includes user_id
    }
    .in_log_context(context)
    .await;
}

async fn fetch_user_preferences() {
    // Add additional context for this specific operation
    LogContext::add_record("operation", "fetch_preferences");
    info!("Fetching preferences"); // Includes both user_id and operation
}

Re-exports

pub use self::future::FutureExt;

Modules

future

Future types.

guard

A current logging context guard.

Structs

ContextLogger

A logger wrapper that enhances log records with contextual properties.

ContextValue

Represents a type of value that can be stored in the log context.

LogContext

A contextual properties that can be attached to log records.