Struct StreamHandler 

pub struct StreamHandler<W: Write + Send> { /* private fields */ }

A Handler that writes formatted records to any Write sink, guarded by a Mutex so a single stream can be shared across threads.

Implementations

impl<W: Write + Send> StreamHandler<W>

pub fn new(formatter: Formatter, stream: W) -> Self

Creates a handler from an explicit formatter and stream.

Examples found in repository

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 with_pattern(stream: W, pattern: &str) -> Self

Convenience constructor that builds a Formatter from pattern.

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");
}

Trait Implementations

impl<W: Write + Send> Handler for StreamHandler<W>

fn handle(&self, record: &Record<'_>)

Renders and writes a single record.

fn formatter(&self) -> &Formatter

The formatter this handler uses (the logger reads its time_format).