Struct StderrLogger 

pub struct StderrLogger {}

Implements a GenLogger that outputs to Stderr

Simple Example

Instantiates a logger with default message and timestamp format

use log::info;
use log::LevelFilter;
use poly_logger::StderrLogger;

let mut logger = StderrLogger::new(LevelFilter::Info);
logger.init().unwrap();
info!("This is an INFO message");

Customized Example

Implements with custom timestamp format and message format

use log::info;
use log::LevelFilter;
use poly_logger::StderrLogger;

let mut logger = StderrLogger::new(LevelFilter::Info);
logger.timestamp_format("%X%.6f")
      .msg_format("[{timestamp} {file}:{line}] - {level} - {args}");
logger.init().unwrap();
info!("This is an INFO message with custom formatting");

Note

The call to new() is actually returning an instance of GenLogger. The StderrLogger struct is just a way to instantiate a GenLogger with Stderr as the target for output. See GenLogger for the full list of methods that can be called on the logger instance.

Implementations

impl StderrLogger

pub fn new(level_filter: LevelFilter) -> GenLogger<Stderr>

Examples found in repository

examples/stderr_simple.rs (line 6)

fn main() {
    let logger = StderrLogger::new(LevelFilter::Info);
    logger.init().unwrap();

    trace!("This is an TRACE message");
    debug!("This is a DEBUG message");
    info!("This is an INFO message");
    warn!("This is a WARN message");
    error!("This is an ERROR message");
}

examples/invalid_fmt.rs (line 6)

fn main() {
    let mut logger = StderrLogger::new(LevelFilter::Info);
    logger.msg_format("{foo} [{timestamp} {file}:{line}] - {baz}");
    logger.init().unwrap();

    trace!("This is an TRACE message");
    debug!("This is a DEBUG message");
    info!("This is an INFO message");
    warn!("This is a WARN message");
    error!("This is an ERROR message");
}

examples/stderr.rs (line 6)

fn main() {
    let mut logger = StderrLogger::new(LevelFilter::Info);

    logger.timestamp_format("%X%.6f")
          .msg_format("[{timestamp} {file}:{line}] - {level} - {args}");
    logger.init().unwrap();

    trace!("This is an TRACE message");
    debug!("This is a DEBUG message");
    info!("This is an INFO message");
    warn!("This is a WARN message");
    error!("This is an ERROR message");
}

examples/doc_poly.rs (line 5)

fn main() {
    let mut stderr_log = StderrLogger::new(LevelFilter::Debug);
    stderr_log.msg_format("{args}");

    let mut file_log = FileLogger::new(LevelFilter::Info);
    file_log.filename("./test.log");

    let mut poly_log = PolyLogger::new();
    poly_log.add(file_log.create()); // create() returns the GenLogger
    poly_log.add(stderr_log);
    poly_log.init().unwrap();

    info!("This goes to both loggers");
    debug!("This only goes to stderr");
}

examples/poly2.rs (line 7)

fn main() {
    // Create a few terminal loggers
    let mut tl0 = StderrLogger::new(LevelFilter::Debug);
    tl0.msg_format("TL0: {timestamp} - {level} - {args}");

    let mut tl1 = StderrLogger::new(LevelFilter::Info);
    tl1.msg_format("TL1: {timestamp} - {level} - {args}");

    let mut tl2 = StderrLogger::new(LevelFilter::Warn);
    tl2.msg_format("TL2: {timestamp} - {level} - {args}");

    // Put one one terminal logger into one poly_logger
    let mut pl0 = PolyLogger::new();
    pl0.add(tl0);

    // Put other terminal loggers into another poly_logger
    let mut pl1 = PolyLogger::new();
    pl1.add(tl1);
    pl1.add(tl2);

    // Put second poly_logger into the first poly_logger
    // which is the one we actually register with the 
    // log system via init().
    // Not sure if this would ever make sense, but hey...
    pl0.add(pl1);
    pl0.init().unwrap();

    trace!("This is an TRACE message");
    eprintln!("------------------------------");
    debug!("This is a DEBUG message");
    eprintln!("------------------------------");
    info!("This is an INFO message");
    eprintln!("------------------------------");
    warn!("This is a WARN message");
    eprintln!("------------------------------");
    error!("This is an ERROR message");
}

examples/poly.rs (line 10)

fn main() {
    // Create some logger instances and run all through
    // the PolyLogger
    
    // Default format 
    let tl0 = StderrLogger::new(LevelFilter::Info);

    // Custom format
    let mut tl1 = StderrLogger::new(LevelFilter::Warn);
    tl1.timestamp_format("%a %b %e %T %Y")
       .msg_format("Custom: [{timestamp}] {level} [{file}:{line}] - {args}");

    // Simpler format
    let mut tl2 = StderrLogger::new(LevelFilter::Info);
    tl2.msg_format("Simple1: {level} [{timestamp}] {args}")
       .timestamp_format("%T");

    // Even simpler
    let mut tl3 = StderrLogger::new(LevelFilter::Debug);
    tl3.msg_format("Simple2: {level} - {args}")
       .timestamp_format("");

    // Raw format to stdout
    let mut tl4 = StdoutLogger::new(LevelFilter::Trace);
    tl4.msg_format("{args}")
       .timestamp_format("");

    // File logger
    let filename = "/tmp/file_logger.log";
    let mut fl0 = FileLogger::new(LevelFilter::Info);
    fl0.msg_format("Simple1: {level} [{timestamp}] {args}")
       .timestamp_format("%T")
       .filename(filename);
    println!("Logging to {}", filename);
    
    // Create the poly logger and add our logger instances
    let mut pl = PolyLogger::new();
    pl.add(tl0);
    pl.add(tl1);
    pl.add(tl2);
    pl.add(tl3);
    pl.add(tl4);
    pl.add(fl0.create());
    pl.init().unwrap();

    trace!("This is an TRACE message");
    eprintln!("------------------------------");
    debug!("This is a DEBUG message");
    eprintln!("------------------------------");
    info!("This is an INFO message");
    eprintln!("------------------------------");
    warn!("This is a WARN message");
    eprintln!("------------------------------");
    error!("This is an ERROR message");
}