nonblocking-logger 0.3.0

use nonblocking_logger::{LogLevel, Logger};

/// Example demonstrating lazy logging to avoid expensive computations
/// when the log level is insufficient.
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let logger = Logger::with_level(LogLevel::Info).no_time_prefix().stdout();

    println!("=== Lazy Logging Example ===");
    println!("Logger level: {:?}", logger.level());
    println!();

    let expensive_computation = || {
        println!("  🔥 Executing expensive computation...");
        std::thread::sleep(std::time::Duration::from_millis(100));
        "Result of expensive computation".to_string()
    };

    println!("1. Regular logging (expensive computation always runs):");
    logger.debug(&expensive_computation())?; // This will compute but not log
    logger.info(&expensive_computation())?; // This will compute and log

    println!("\n2. Lazy logging (expensive computation only runs when needed):");
    logger.debug_lazy(|| expensive_computation())?; // This won't compute or log
    logger.info_lazy(|| expensive_computation())?; // This will compute and log

    println!("\n3. Performance comparison:");

    let start = std::time::Instant::now();
    for _ in 0..10 {
        logger.debug(&expensive_computation())?; // Always computes
    }
    let regular_time = start.elapsed();

    let start = std::time::Instant::now();
    for _ in 0..10 {
        logger.debug_lazy(|| expensive_computation())?; // Never computes
    }
    let lazy_time = start.elapsed();

    println!("  Regular logging time: {:?}", regular_time);
    println!("  Lazy logging time: {:?}", lazy_time);
    println!(
        "  Performance improvement: {:.1}x faster",
        regular_time.as_nanos() as f64 / lazy_time.as_nanos() as f64
    );

    println!("\n4. Real-world example with complex data structures:");

    let complex_data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    logger.debug(&format!("Complex data: {:?}", complex_data))?;

    logger.debug_lazy(|| format!("Complex data: {:?}", complex_data))?;

    println!("\n5. Changing log level to see the difference:");
    let mut logger = logger;
    logger.set_level(LogLevel::Debug);

    println!("  Logger level changed to: {:?}", logger.level());
    logger.debug_lazy(|| {
        println!("  🚀 Debug logging enabled - expensive computation runs!");
        expensive_computation()
    })?;

    Ok(())
}