fake-log 0.1.0

A fake logging implementation with the same interface as log crate but with no-op implementation for embedded scenarios
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

//! Custom Logger implementation example
//!
//! This example demonstrates how to implement the Log trait using fake-log.
//! Even though the logger implementation is provided, fake-log will still
//! optimize away all logging calls.

use fake_log::{debug, error, info, trace, warn};
use fake_log::{Level, Log, Metadata, Record};

struct CustomLogger {
    name: &'static str,
}

impl CustomLogger {
    fn new(name: &'static str) -> Self {
        Self { name }
    }
}

impl Log for CustomLogger {
    fn enabled(&self, metadata: &Metadata) -> bool {
        // In fake-log, this will always be called with metadata,
        // but the actual logging will be optimized away
        println!(
            "Logger '{}': checking if level {:?} is enabled",
            self.name,
            metadata.level()
        );

        // Return false to indicate no logging should happen
        // (though fake-log will optimize it away anyway)
        false
    }

    fn log(&self, record: &Record) {
        // This method will never actually be called in fake-log
        // because the macros are optimized away, but we implement
        // it for completeness
        println!(
            "Logger '{}': [{}] {}",
            self.name,
            record.level(),
            record.args()
        );
    }

    fn flush(&self) {
        // Flush implementation - also a no-op in fake-log
        println!("Logger '{}': flushing", self.name);
    }
}

fn main() {
    println!("=== Custom Logger Example ===");
    println!("Note: Even with a custom logger, fake-log optimizes away all calls");
    println!();

    // Create a custom logger
    let logger = CustomLogger::new("MyApp");

    // Demonstrate logger methods
    let metadata = Metadata::builder()
        .level(Level::Info)
        .target("example")
        .build();

    println!("Testing logger.enabled(): {}", logger.enabled(&metadata));

    // Create a record manually (for demonstration)
    let record = Record::builder()
        .level(Level::Info)
        .target("example")
        .args(format_args!("Manual log record"))
        .build();

    logger.log(&record);
    logger.flush();

    println!();
    println!("Now using log macros (these will be optimized away):");

    // Use the logging macros - these will all be optimized away
    error!("This error will not appear");
    warn!("This warning will not appear");
    info!("This info will not appear");
    debug!("This debug will not appear");
    trace!("This trace will not appear");

    // Complex example with a simulated service
    simulate_service();

    println!();
    println!("Program completed!");
    println!("Notice: The log macros produced no output despite the custom logger");
}

fn simulate_service() {
    info!("Starting service simulation");

    for i in 1..=5 {
        debug!("Processing item {}", i);

        if i % 2 == 0 {
            warn!("Even number detected: {}", i);
        }

        if i == 3 {
            error!("Simulated error at item {}", i);
        }
    }

    info!("Service simulation completed");
}