Struct Logger 

pub struct Logger { /* private fields */ }

A named logger with a severity threshold and a set of Handlers.

Use Logger::get to obtain a shared logger by name (created once, then reused), or Logger::root for the ancestor logger. Messages below level are dropped before reaching any handler.

The level is stored in an AtomicU8 and handlers behind an RwLock, so a &Logger can be used concurrently from multiple threads.

Implementations

impl Logger

pub fn new(name: &'static str) -> Self

Builds a logger. The root logger starts empty at Level::Info; any other logger inherits a snapshot of root’s handlers and level at creation time.

pub fn get(name: &'static str) -> Arc<Self>

Returns the shared logger registered under name, creating and registering it on first call.

Examples found in repository

examples/quickstart.rs (line 17)

fn main() {
    // Get a named logger from the global registry. Calling `get` with the same
    // name again anywhere in the program returns the same logger.
    let logger = Logger::get("basic");

    // Attach a handler that writes to stdout using a simple pattern.
    // `%(level)` and `%(message)` are field placeholders.
    logger
        .add_handler(StreamHandler::with_pattern(
            std::io::stdout(),
            "%(level): %(message)",
        ))
        .expect("handler lock should not be poisoned at startup");

    // Emit a few messages. The default level is `Info`, so `debug` is dropped.
    logger.info("hello from a named logger");
    logger.warning("something to keep an eye on");
    logger.error("something went wrong");
}

examples/colorized.rs (line 61)

fn main() {
    // 1. Build a formatter from a pattern.
    //
    //    `%(name)` is a field placeholder. A trailing spec like `-20` controls
    //    width/alignment: a leading `-` left-aligns, the number is the minimum
    //    width, and an optional `.N` truncates to N characters. So:
    //      %(level)-8   -> left-aligned, padded to 8 ("INFO    ")
    //      %(name).12   -> truncated to at most 12 chars
    let mut formatter = Formatter::new("%(timestamp) [%(level)-8] %(name)-12 | %(message)");

    // 2. Customize the timestamp rendering (chrono's strftime syntax).
    formatter.set_time_format("%Y-%m-%d %H:%M:%S");

    // 3. Post-process every rendered line (here: add color).
    formatter.set_transformer(colorize);

    // 4. Configure the ROOT logger once. Every logger created afterwards
    //    inherits a snapshot of root's handlers and level, so you typically
    //    set things up here and then just `Logger::get(...)` everywhere else.
    let root = Logger::root();
    root.add_handler(StreamHandler::new(formatter, std::io::stdout()))
        .expect("root handler lock should not be poisoned at startup");
    root.set_level(Level::Debug); // emit everything Debug and above

    // 5. Grab a named logger and emit one message per level.
    let logger = Logger::get("quickstart");
    logger.debug("a debug message (gray)");
    logger.info("an info message (blue)");
    logger.warning("a warning message (yellow)");
    logger.error("an error message (red)");
    logger.critical("a critical message (deep red)");

    // 6. Levels below a logger's threshold are dropped cheaply (before
    //    formatting). Raise the bar and show that Debug/Info now vanish.
    logger.set_level(Level::Warning);
    logger.debug("you will NOT see this (below threshold)");
    logger.info("you will NOT see this either");
    logger.warning("but warnings still get through");
}

pub fn root() -> Arc<Self>

Returns the shared root logger, the ancestor whose handlers/level new loggers inherit.

Examples found in repository

examples/colorized.rs (line 55)

fn main() {
    // 1. Build a formatter from a pattern.
    //
    //    `%(name)` is a field placeholder. A trailing spec like `-20` controls
    //    width/alignment: a leading `-` left-aligns, the number is the minimum
    //    width, and an optional `.N` truncates to N characters. So:
    //      %(level)-8   -> left-aligned, padded to 8 ("INFO    ")
    //      %(name).12   -> truncated to at most 12 chars
    let mut formatter = Formatter::new("%(timestamp) [%(level)-8] %(name)-12 | %(message)");

    // 2. Customize the timestamp rendering (chrono's strftime syntax).
    formatter.set_time_format("%Y-%m-%d %H:%M:%S");

    // 3. Post-process every rendered line (here: add color).
    formatter.set_transformer(colorize);

    // 4. Configure the ROOT logger once. Every logger created afterwards
    //    inherits a snapshot of root's handlers and level, so you typically
    //    set things up here and then just `Logger::get(...)` everywhere else.
    let root = Logger::root();
    root.add_handler(StreamHandler::new(formatter, std::io::stdout()))
        .expect("root handler lock should not be poisoned at startup");
    root.set_level(Level::Debug); // emit everything Debug and above

    // 5. Grab a named logger and emit one message per level.
    let logger = Logger::get("quickstart");
    logger.debug("a debug message (gray)");
    logger.info("an info message (blue)");
    logger.warning("a warning message (yellow)");
    logger.error("an error message (red)");
    logger.critical("a critical message (deep red)");

    // 6. Levels below a logger's threshold are dropped cheaply (before
    //    formatting). Raise the bar and show that Debug/Info now vanish.
    logger.set_level(Level::Warning);
    logger.debug("you will NOT see this (below threshold)");
    logger.info("you will NOT see this either");
    logger.warning("but warnings still get through");
}

pub fn handlers(&self) -> Vec<Arc<dyn Handler>>

Returns a snapshot clone of this logger’s handlers.

pub fn set_level(&self, level: Level)

Sets the minimum severity this logger will emit.

Examples found in repository

examples/colorized.rs (line 58)

fn main() {
    // 1. Build a formatter from a pattern.
    //
    //    `%(name)` is a field placeholder. A trailing spec like `-20` controls
    //    width/alignment: a leading `-` left-aligns, the number is the minimum
    //    width, and an optional `.N` truncates to N characters. So:
    //      %(level)-8   -> left-aligned, padded to 8 ("INFO    ")
    //      %(name).12   -> truncated to at most 12 chars
    let mut formatter = Formatter::new("%(timestamp) [%(level)-8] %(name)-12 | %(message)");

    // 2. Customize the timestamp rendering (chrono's strftime syntax).
    formatter.set_time_format("%Y-%m-%d %H:%M:%S");

    // 3. Post-process every rendered line (here: add color).
    formatter.set_transformer(colorize);

    // 4. Configure the ROOT logger once. Every logger created afterwards
    //    inherits a snapshot of root's handlers and level, so you typically
    //    set things up here and then just `Logger::get(...)` everywhere else.
    let root = Logger::root();
    root.add_handler(StreamHandler::new(formatter, std::io::stdout()))
        .expect("root handler lock should not be poisoned at startup");
    root.set_level(Level::Debug); // emit everything Debug and above

    // 5. Grab a named logger and emit one message per level.
    let logger = Logger::get("quickstart");
    logger.debug("a debug message (gray)");
    logger.info("an info message (blue)");
    logger.warning("a warning message (yellow)");
    logger.error("an error message (red)");
    logger.critical("a critical message (deep red)");

    // 6. Levels below a logger's threshold are dropped cheaply (before
    //    formatting). Raise the bar and show that Debug/Info now vanish.
    logger.set_level(Level::Warning);
    logger.debug("you will NOT see this (below threshold)");
    logger.info("you will NOT see this either");
    logger.warning("but warnings still get through");
}

pub fn level(&self) -> Level

Returns the logger’s current minimum severity.

pub fn add_handler( &self, handler: impl Handler + 'static, ) -> Result<(), Box<dyn Error>>

Appends a handler. Returns an error only if the internal lock was poisoned by a panic in another thread.

Examples found in repository

examples/quickstart.rs (lines 22-25)

fn main() {
    // Get a named logger from the global registry. Calling `get` with the same
    // name again anywhere in the program returns the same logger.
    let logger = Logger::get("basic");

    // Attach a handler that writes to stdout using a simple pattern.
    // `%(level)` and `%(message)` are field placeholders.
    logger
        .add_handler(StreamHandler::with_pattern(
            std::io::stdout(),
            "%(level): %(message)",
        ))
        .expect("handler lock should not be poisoned at startup");

    // Emit a few messages. The default level is `Info`, so `debug` is dropped.
    logger.info("hello from a named logger");
    logger.warning("something to keep an eye on");
    logger.error("something went wrong");
}

examples/colorized.rs (line 56)

fn main() {
    // 1. Build a formatter from a pattern.
    //
    //    `%(name)` is a field placeholder. A trailing spec like `-20` controls
    //    width/alignment: a leading `-` left-aligns, the number is the minimum
    //    width, and an optional `.N` truncates to N characters. So:
    //      %(level)-8   -> left-aligned, padded to 8 ("INFO    ")
    //      %(name).12   -> truncated to at most 12 chars
    let mut formatter = Formatter::new("%(timestamp) [%(level)-8] %(name)-12 | %(message)");

    // 2. Customize the timestamp rendering (chrono's strftime syntax).
    formatter.set_time_format("%Y-%m-%d %H:%M:%S");

    // 3. Post-process every rendered line (here: add color).
    formatter.set_transformer(colorize);

    // 4. Configure the ROOT logger once. Every logger created afterwards
    //    inherits a snapshot of root's handlers and level, so you typically
    //    set things up here and then just `Logger::get(...)` everywhere else.
    let root = Logger::root();
    root.add_handler(StreamHandler::new(formatter, std::io::stdout()))
        .expect("root handler lock should not be poisoned at startup");
    root.set_level(Level::Debug); // emit everything Debug and above

    // 5. Grab a named logger and emit one message per level.
    let logger = Logger::get("quickstart");
    logger.debug("a debug message (gray)");
    logger.info("an info message (blue)");
    logger.warning("a warning message (yellow)");
    logger.error("an error message (red)");
    logger.critical("a critical message (deep red)");

    // 6. Levels below a logger's threshold are dropped cheaply (before
    //    formatting). Raise the bar and show that Debug/Info now vanish.
    logger.set_level(Level::Warning);
    logger.debug("you will NOT see this (below threshold)");
    logger.info("you will NOT see this either");
    logger.warning("but warnings still get through");
}

pub fn log(&self, level: Level, message: &str)

Emits message at level to every handler, unless level is below the logger’s threshold. Builds one Record (message, level, timestamp, logger name, thread name) and hands it to each handler.

pub fn debug(&self, message: &str)

Logs message at Level::Debug.

Examples found in repository

examples/colorized.rs (line 62)

fn main() {
    // 1. Build a formatter from a pattern.
    //
    //    `%(name)` is a field placeholder. A trailing spec like `-20` controls
    //    width/alignment: a leading `-` left-aligns, the number is the minimum
    //    width, and an optional `.N` truncates to N characters. So:
    //      %(level)-8   -> left-aligned, padded to 8 ("INFO    ")
    //      %(name).12   -> truncated to at most 12 chars
    let mut formatter = Formatter::new("%(timestamp) [%(level)-8] %(name)-12 | %(message)");

    // 2. Customize the timestamp rendering (chrono's strftime syntax).
    formatter.set_time_format("%Y-%m-%d %H:%M:%S");

    // 3. Post-process every rendered line (here: add color).
    formatter.set_transformer(colorize);

    // 4. Configure the ROOT logger once. Every logger created afterwards
    //    inherits a snapshot of root's handlers and level, so you typically
    //    set things up here and then just `Logger::get(...)` everywhere else.
    let root = Logger::root();
    root.add_handler(StreamHandler::new(formatter, std::io::stdout()))
        .expect("root handler lock should not be poisoned at startup");
    root.set_level(Level::Debug); // emit everything Debug and above

    // 5. Grab a named logger and emit one message per level.
    let logger = Logger::get("quickstart");
    logger.debug("a debug message (gray)");
    logger.info("an info message (blue)");
    logger.warning("a warning message (yellow)");
    logger.error("an error message (red)");
    logger.critical("a critical message (deep red)");

    // 6. Levels below a logger's threshold are dropped cheaply (before
    //    formatting). Raise the bar and show that Debug/Info now vanish.
    logger.set_level(Level::Warning);
    logger.debug("you will NOT see this (below threshold)");
    logger.info("you will NOT see this either");
    logger.warning("but warnings still get through");
}

pub fn info(&self, message: &str)

Logs message at Level::Info.

Examples found in repository

examples/quickstart.rs (line 29)

fn main() {
    // Get a named logger from the global registry. Calling `get` with the same
    // name again anywhere in the program returns the same logger.
    let logger = Logger::get("basic");

    // Attach a handler that writes to stdout using a simple pattern.
    // `%(level)` and `%(message)` are field placeholders.
    logger
        .add_handler(StreamHandler::with_pattern(
            std::io::stdout(),
            "%(level): %(message)",
        ))
        .expect("handler lock should not be poisoned at startup");

    // Emit a few messages. The default level is `Info`, so `debug` is dropped.
    logger.info("hello from a named logger");
    logger.warning("something to keep an eye on");
    logger.error("something went wrong");
}

examples/colorized.rs (line 63)

fn main() {
    // 1. Build a formatter from a pattern.
    //
    //    `%(name)` is a field placeholder. A trailing spec like `-20` controls
    //    width/alignment: a leading `-` left-aligns, the number is the minimum
    //    width, and an optional `.N` truncates to N characters. So:
    //      %(level)-8   -> left-aligned, padded to 8 ("INFO    ")
    //      %(name).12   -> truncated to at most 12 chars
    let mut formatter = Formatter::new("%(timestamp) [%(level)-8] %(name)-12 | %(message)");

    // 2. Customize the timestamp rendering (chrono's strftime syntax).
    formatter.set_time_format("%Y-%m-%d %H:%M:%S");

    // 3. Post-process every rendered line (here: add color).
    formatter.set_transformer(colorize);

    // 4. Configure the ROOT logger once. Every logger created afterwards
    //    inherits a snapshot of root's handlers and level, so you typically
    //    set things up here and then just `Logger::get(...)` everywhere else.
    let root = Logger::root();
    root.add_handler(StreamHandler::new(formatter, std::io::stdout()))
        .expect("root handler lock should not be poisoned at startup");
    root.set_level(Level::Debug); // emit everything Debug and above

    // 5. Grab a named logger and emit one message per level.
    let logger = Logger::get("quickstart");
    logger.debug("a debug message (gray)");
    logger.info("an info message (blue)");
    logger.warning("a warning message (yellow)");
    logger.error("an error message (red)");
    logger.critical("a critical message (deep red)");

    // 6. Levels below a logger's threshold are dropped cheaply (before
    //    formatting). Raise the bar and show that Debug/Info now vanish.
    logger.set_level(Level::Warning);
    logger.debug("you will NOT see this (below threshold)");
    logger.info("you will NOT see this either");
    logger.warning("but warnings still get through");
}

pub fn warning(&self, message: &str)

Logs message at Level::Warning.

Examples found in repository

examples/quickstart.rs (line 30)

fn main() {
    // Get a named logger from the global registry. Calling `get` with the same
    // name again anywhere in the program returns the same logger.
    let logger = Logger::get("basic");

    // Attach a handler that writes to stdout using a simple pattern.
    // `%(level)` and `%(message)` are field placeholders.
    logger
        .add_handler(StreamHandler::with_pattern(
            std::io::stdout(),
            "%(level): %(message)",
        ))
        .expect("handler lock should not be poisoned at startup");

    // Emit a few messages. The default level is `Info`, so `debug` is dropped.
    logger.info("hello from a named logger");
    logger.warning("something to keep an eye on");
    logger.error("something went wrong");
}

examples/colorized.rs (line 64)

fn main() {
    // 1. Build a formatter from a pattern.
    //
    //    `%(name)` is a field placeholder. A trailing spec like `-20` controls
    //    width/alignment: a leading `-` left-aligns, the number is the minimum
    //    width, and an optional `.N` truncates to N characters. So:
    //      %(level)-8   -> left-aligned, padded to 8 ("INFO    ")
    //      %(name).12   -> truncated to at most 12 chars
    let mut formatter = Formatter::new("%(timestamp) [%(level)-8] %(name)-12 | %(message)");

    // 2. Customize the timestamp rendering (chrono's strftime syntax).
    formatter.set_time_format("%Y-%m-%d %H:%M:%S");

    // 3. Post-process every rendered line (here: add color).
    formatter.set_transformer(colorize);

    // 4. Configure the ROOT logger once. Every logger created afterwards
    //    inherits a snapshot of root's handlers and level, so you typically
    //    set things up here and then just `Logger::get(...)` everywhere else.
    let root = Logger::root();
    root.add_handler(StreamHandler::new(formatter, std::io::stdout()))
        .expect("root handler lock should not be poisoned at startup");
    root.set_level(Level::Debug); // emit everything Debug and above

    // 5. Grab a named logger and emit one message per level.
    let logger = Logger::get("quickstart");
    logger.debug("a debug message (gray)");
    logger.info("an info message (blue)");
    logger.warning("a warning message (yellow)");
    logger.error("an error message (red)");
    logger.critical("a critical message (deep red)");

    // 6. Levels below a logger's threshold are dropped cheaply (before
    //    formatting). Raise the bar and show that Debug/Info now vanish.
    logger.set_level(Level::Warning);
    logger.debug("you will NOT see this (below threshold)");
    logger.info("you will NOT see this either");
    logger.warning("but warnings still get through");
}

pub fn error(&self, message: &str)

Logs message at Level::Error.

Examples found in repository

examples/quickstart.rs (line 31)

fn main() {
    // Get a named logger from the global registry. Calling `get` with the same
    // name again anywhere in the program returns the same logger.
    let logger = Logger::get("basic");

    // Attach a handler that writes to stdout using a simple pattern.
    // `%(level)` and `%(message)` are field placeholders.
    logger
        .add_handler(StreamHandler::with_pattern(
            std::io::stdout(),
            "%(level): %(message)",
        ))
        .expect("handler lock should not be poisoned at startup");

    // Emit a few messages. The default level is `Info`, so `debug` is dropped.
    logger.info("hello from a named logger");
    logger.warning("something to keep an eye on");
    logger.error("something went wrong");
}

examples/colorized.rs (line 65)

fn main() {
    // 1. Build a formatter from a pattern.
    //
    //    `%(name)` is a field placeholder. A trailing spec like `-20` controls
    //    width/alignment: a leading `-` left-aligns, the number is the minimum
    //    width, and an optional `.N` truncates to N characters. So:
    //      %(level)-8   -> left-aligned, padded to 8 ("INFO    ")
    //      %(name).12   -> truncated to at most 12 chars
    let mut formatter = Formatter::new("%(timestamp) [%(level)-8] %(name)-12 | %(message)");

    // 2. Customize the timestamp rendering (chrono's strftime syntax).
    formatter.set_time_format("%Y-%m-%d %H:%M:%S");

    // 3. Post-process every rendered line (here: add color).
    formatter.set_transformer(colorize);

    // 4. Configure the ROOT logger once. Every logger created afterwards
    //    inherits a snapshot of root's handlers and level, so you typically
    //    set things up here and then just `Logger::get(...)` everywhere else.
    let root = Logger::root();
    root.add_handler(StreamHandler::new(formatter, std::io::stdout()))
        .expect("root handler lock should not be poisoned at startup");
    root.set_level(Level::Debug); // emit everything Debug and above

    // 5. Grab a named logger and emit one message per level.
    let logger = Logger::get("quickstart");
    logger.debug("a debug message (gray)");
    logger.info("an info message (blue)");
    logger.warning("a warning message (yellow)");
    logger.error("an error message (red)");
    logger.critical("a critical message (deep red)");

    // 6. Levels below a logger's threshold are dropped cheaply (before
    //    formatting). Raise the bar and show that Debug/Info now vanish.
    logger.set_level(Level::Warning);
    logger.debug("you will NOT see this (below threshold)");
    logger.info("you will NOT see this either");
    logger.warning("but warnings still get through");
}

pub fn critical(&self, message: &str)

Logs message at Level::Critical.

Examples found in repository

examples/colorized.rs (line 66)

fn main() {
    // 1. Build a formatter from a pattern.
    //
    //    `%(name)` is a field placeholder. A trailing spec like `-20` controls
    //    width/alignment: a leading `-` left-aligns, the number is the minimum
    //    width, and an optional `.N` truncates to N characters. So:
    //      %(level)-8   -> left-aligned, padded to 8 ("INFO    ")
    //      %(name).12   -> truncated to at most 12 chars
    let mut formatter = Formatter::new("%(timestamp) [%(level)-8] %(name)-12 | %(message)");

    // 2. Customize the timestamp rendering (chrono's strftime syntax).
    formatter.set_time_format("%Y-%m-%d %H:%M:%S");

    // 3. Post-process every rendered line (here: add color).
    formatter.set_transformer(colorize);

    // 4. Configure the ROOT logger once. Every logger created afterwards
    //    inherits a snapshot of root's handlers and level, so you typically
    //    set things up here and then just `Logger::get(...)` everywhere else.
    let root = Logger::root();
    root.add_handler(StreamHandler::new(formatter, std::io::stdout()))
        .expect("root handler lock should not be poisoned at startup");
    root.set_level(Level::Debug); // emit everything Debug and above

    // 5. Grab a named logger and emit one message per level.
    let logger = Logger::get("quickstart");
    logger.debug("a debug message (gray)");
    logger.info("an info message (blue)");
    logger.warning("a warning message (yellow)");
    logger.error("an error message (red)");
    logger.critical("a critical message (deep red)");

    // 6. Levels below a logger's threshold are dropped cheaply (before
    //    formatting). Raise the bar and show that Debug/Info now vanish.
    logger.set_level(Level::Warning);
    logger.debug("you will NOT see this (below threshold)");
    logger.info("you will NOT see this either");
    logger.warning("but warnings still get through");
}