Struct Logger

pub struct Logger { /* private fields */ }

Implementations

impl Logger

pub fn set_format(&self, template: &str) -> &Self

Examples found in repository

examples/custom_format.rs (line 21)

fn main() {
    // Try different built-in formats
    logger().use_simple_format();
    info!("Simple format");
    warn!("Just symbol and message");

    // Detailed format with timestamp
    logger().use_detailed_format();
    info!("Detailed format");
    error!("With timestamp");

    // Debug format with file location
    logger().use_debug_format();
    info!("Debug format");
    warn!("With file location");

    // Custom format
    logger().set_format("{datetime} | {pid}:{thread_id} | {level} | {message}");
    info!("Custom format");

    // Format with context
    let _ctx = logger().add_context("user", "admin");
    logger().set_format("[{level}] {context}{message} ({file}:{line})");
    info!("Message with context");

    // Complex format showing all options
    logger().set_format(concat!(
        "Time: {time} | ",
        "Date: {date} | ",
        "Thread: {thread} | ",
        "PID: {pid} | ",
        "Level: {level} ({symbol}) | ",
        "{context}",
        "Message: {message}"
    ));

    thread::spawn(|| {
        info!("Shows all available placeholders");
    })
    .join()
    .unwrap();
}

pub fn use_simple_format(&self) -> &Self

Examples found in repository

examples/custom_format.rs (line 6)

fn main() {
    // Try different built-in formats
    logger().use_simple_format();
    info!("Simple format");
    warn!("Just symbol and message");

    // Detailed format with timestamp
    logger().use_detailed_format();
    info!("Detailed format");
    error!("With timestamp");

    // Debug format with file location
    logger().use_debug_format();
    info!("Debug format");
    warn!("With file location");

    // Custom format
    logger().set_format("{datetime} | {pid}:{thread_id} | {level} | {message}");
    info!("Custom format");

    // Format with context
    let _ctx = logger().add_context("user", "admin");
    logger().set_format("[{level}] {context}{message} ({file}:{line})");
    info!("Message with context");

    // Complex format showing all options
    logger().set_format(concat!(
        "Time: {time} | ",
        "Date: {date} | ",
        "Thread: {thread} | ",
        "PID: {pid} | ",
        "Level: {level} ({symbol}) | ",
        "{context}",
        "Message: {message}"
    ));

    thread::spawn(|| {
        info!("Shows all available placeholders");
    })
    .join()
    .unwrap();
}

pub fn use_detailed_format(&self) -> &Self

Examples found in repository

examples/custom_format.rs (line 11)

fn main() {
    // Try different built-in formats
    logger().use_simple_format();
    info!("Simple format");
    warn!("Just symbol and message");

    // Detailed format with timestamp
    logger().use_detailed_format();
    info!("Detailed format");
    error!("With timestamp");

    // Debug format with file location
    logger().use_debug_format();
    info!("Debug format");
    warn!("With file location");

    // Custom format
    logger().set_format("{datetime} | {pid}:{thread_id} | {level} | {message}");
    info!("Custom format");

    // Format with context
    let _ctx = logger().add_context("user", "admin");
    logger().set_format("[{level}] {context}{message} ({file}:{line})");
    info!("Message with context");

    // Complex format showing all options
    logger().set_format(concat!(
        "Time: {time} | ",
        "Date: {date} | ",
        "Thread: {thread} | ",
        "PID: {pid} | ",
        "Level: {level} ({symbol}) | ",
        "{context}",
        "Message: {message}"
    ));

    thread::spawn(|| {
        info!("Shows all available placeholders");
    })
    .join()
    .unwrap();
}

pub fn use_debug_format(&self) -> &Self

Examples found in repository

examples/custom_format.rs (line 16)

fn main() {
    // Try different built-in formats
    logger().use_simple_format();
    info!("Simple format");
    warn!("Just symbol and message");

    // Detailed format with timestamp
    logger().use_detailed_format();
    info!("Detailed format");
    error!("With timestamp");

    // Debug format with file location
    logger().use_debug_format();
    info!("Debug format");
    warn!("With file location");

    // Custom format
    logger().set_format("{datetime} | {pid}:{thread_id} | {level} | {message}");
    info!("Custom format");

    // Format with context
    let _ctx = logger().add_context("user", "admin");
    logger().set_format("[{level}] {context}{message} ({file}:{line})");
    info!("Message with context");

    // Complex format showing all options
    logger().set_format(concat!(
        "Time: {time} | ",
        "Date: {date} | ",
        "Thread: {thread} | ",
        "PID: {pid} | ",
        "Level: {level} ({symbol}) | ",
        "{context}",
        "Message: {message}"
    ));

    thread::spawn(|| {
        info!("Shows all available placeholders");
    })
    .join()
    .unwrap();
}

pub fn verbose(&self, enabled: bool) -> &Self

Examples found in repository

examples/threads.rs (line 14)

fn main() {
    // Enable verbose mode globally
    logger().verbose(true);

    info!("This is an info message from main on the main thread");

    thread::spawn(|| {
        debug!("This is a debug message from another thread");
    })
    .join()
    .unwrap();

    function_log();

    thread::spawn(|| {
        function_thread_log();
    })
    .join()
    .unwrap();
}

examples/verbose.rs (line 5)

fn main() {
    // Enable verbose mode globally
    logger().verbose(true);

    info!("This is an info message");
    let a = 1337;
    info!("This is an info message with a variable: {}", a);
    log!(
        LogLevel::INFO,
        "This is an info message with different syntactic sugar {}",
        a
    );
    debug!("This is a debug message");
    warn!("This is a warning message");
    error!("This is an error message");
    success!("This is a success message");
    failure!("This is a failure message");
}

examples/thread_safety.rs (line 7)

fn main() {
    // Enable verbose mode to see thread information
    logger().verbose(true);

    // Spawn multiple threads that log simultaneously
    let mut handles = vec![];

    for i in 0..3 {
        let handle = thread::spawn(move || {
            let _ctx = logger().add_context("thread_id", i.to_string());

            for j in 0..3 {
                info!("Message {} from thread {}", j, i);
                thread::sleep(Duration::from_millis(100));
            }
        });

        handles.push(handle);
    }

    // Wait for all threads to finish
    for handle in handles {
        handle.join().unwrap();
    }
}

pub fn min_level(&self, level: LogLevel) -> &Self

Examples found in repository

examples/filtering.rs (line 5)

fn main() {
    // Set minimum log level to WARN - this will hide DEBUG and INFO messages
    logger().min_level(LogLevel::WARN);

    debug!("This debug message won't show");
    info!("This info message won't show");
    warn!("This warning will show!");
    error!("This error will show!");

    // Change minimum level back to DEBUG to show everything
    logger().min_level(LogLevel::DEBUG);

    debug!("Now this debug message shows");
    info!("And this info message too");
}

pub fn set_writer(&self, writer: Box<dyn Write + Send>) -> Result<()>

Examples found in repository

examples/output_redirection.rs (line 10)

fn main() -> std::io::Result<()> {
    // First log to stdout
    info!("This goes to terminal");

    // Redirect to a file
    let log_file = File::create("test.log")?;
    logger().set_writer(Box::new(log_file))?;

    info!("This goes to test.log");
    warn!("This warning also goes to test.log");

    Ok(())
}

pub fn add_context<K, V>(&self, key: K, value: V) -> ContextGuard

where K: Into<String>, V: Into<String>,

Examples found in repository

examples/context.rs (line 5)

fn scan_ports(host: &str) {
    // Add context that will be included in all logs in this scope
    let _host_ctx = logger().add_context("host", host);

    info!("Starting port scan");

    // Add another context
    let _scan_ctx = logger().add_context("scan_type", "TCP");
    warn!("Found open port 80"); // Will include both host and scan_type

    // scan_ctx is dropped here, removing "scan_type" from context
}

fn main() {
    let _req_id = logger().add_context("request_id", "12345");

    info!("Starting application"); // Includes request_id

    scan_ports("example.com"); // Includes request_id and temporarily host

    info!("Finished!"); // Only includes request_id again
}

examples/thread_safety.rs (line 14)

fn main() {
    // Enable verbose mode to see thread information
    logger().verbose(true);

    // Spawn multiple threads that log simultaneously
    let mut handles = vec![];

    for i in 0..3 {
        let handle = thread::spawn(move || {
            let _ctx = logger().add_context("thread_id", i.to_string());

            for j in 0..3 {
                info!("Message {} from thread {}", j, i);
                thread::sleep(Duration::from_millis(100));
            }
        });

        handles.push(handle);
    }

    // Wait for all threads to finish
    for handle in handles {
        handle.join().unwrap();
    }
}

examples/custom_format.rs (line 25)

fn main() {
    // Try different built-in formats
    logger().use_simple_format();
    info!("Simple format");
    warn!("Just symbol and message");

    // Detailed format with timestamp
    logger().use_detailed_format();
    info!("Detailed format");
    error!("With timestamp");

    // Debug format with file location
    logger().use_debug_format();
    info!("Debug format");
    warn!("With file location");

    // Custom format
    logger().set_format("{datetime} | {pid}:{thread_id} | {level} | {message}");
    info!("Custom format");

    // Format with context
    let _ctx = logger().add_context("user", "admin");
    logger().set_format("[{level}] {context}{message} ({file}:{line})");
    info!("Message with context");

    // Complex format showing all options
    logger().set_format(concat!(
        "Time: {time} | ",
        "Date: {date} | ",
        "Thread: {thread} | ",
        "PID: {pid} | ",
        "Level: {level} ({symbol}) | ",
        "{context}",
        "Message: {message}"
    ));

    thread::spawn(|| {
        info!("Shows all available placeholders");
    })
    .join()
    .unwrap();
}

pub fn should_log(&self, level: LogLevel) -> bool

pub fn write_log( &self, level: LogLevel, message: &str, file: &str, line: u32, ) -> Result<()>

Trait Implementations

impl Default for Logger

fn default() -> Self

Returns the “default value” for a type.