Struct Formatter 

pub struct Formatter {
    pub time_format: &'static str,
    /* private fields */
}

Renders a Record into a string according to a pattern.

The pattern is parsed once (at construction) into a list of [Segment]s, so format does no parsing per call. Patterns mix literal text with field placeholders of the form %(name) optionally followed by a format spec (alignment/width), e.g. "[%(level)-8] %(message)".

Fields

time_format: &'static str

The chrono strftime format used to render the timestamp field (e.g. "%Y-%m-%d %H:%M:%S").

Implementations

impl Formatter

pub fn new(pattern: &str) -> Self

Creates a formatter from a pattern string, parsing it into segments now so that format is allocation-light per call.

Examples found in repository

examples/colorized.rs (line 44)

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 add_field(&mut self, name: &str, resolve: fn(&str) -> &str) -> &mut Self

Registers a transform for a field name. When a %(name) placeholder is rendered, the raw record value is passed through resolve before alignment/width is applied. Returns &mut Self for chaining.

pub fn format(&self, record: &Record<'_>) -> String

Renders record into a string, substituting each %(name) placeholder with the record’s value (or "" if absent), applying any registered field transform and the placeholder’s spec. A trailing newline is appended. If a transformer is set, it post-processes the whole line.

pub fn set_transformer( &mut self, transformer: impl Fn(&Record<'_>, &String) -> String + Send + Sync + 'static, )

Installs a post-processing hook that receives the record and the fully rendered line and returns the final string (e.g. to add ANSI colors).

Examples found in repository

examples/colorized.rs (line 50)

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 set_time_format(&mut self, time_format: &'static str)

Sets the chrono strftime format used to render the timestamp field.

Examples found in repository

examples/colorized.rs (line 47)

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