Skip to main content

PolyLogger

Struct PolyLogger

pub struct PolyLogger { /* private fields */ }

Expand description

Implements a super-logger that can redirect to other loggers

This is useful if you want to log some messages to STDERR or STDOUT and some to File in perhaps a different format. When using PolyLogger, you create any number of child loggers and add them to the PolyLogger. Then you set the PolyLogger instance as the only one to be passed to the log system via init().

§Example

Create a file logger with the default timestamp/message format, and also a raw logger for debug messages which gets sent to STDERR.

use log::{debug,info,LevelFilter};
use poly_logger::{FileLogger,StderrLogger,PolyLogger};

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();

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

Implementations§

impl PolyLogger

pub fn new() -> Self

Instantiate a new PolyLogger

Examples found in repository ?

examples/doc_poly.rs (line 11)

4fn main() {
5    let mut stderr_log = StderrLogger::new(LevelFilter::Debug);
6    stderr_log.msg_format("{args}");
7
8    let mut file_log = FileLogger::new(LevelFilter::Info);
9    file_log.filename("./test.log");
10
11    let mut poly_log = PolyLogger::new();
12    poly_log.add(file_log.create()); // create() returns the GenLogger
13    poly_log.add(stderr_log);
14    poly_log.init().unwrap();
15
16    info!("This goes to both loggers");
17    debug!("This only goes to stderr");
18}

More examples

Hide additional examples

examples/poly2.rs (line 17)

5fn main() {
6    // Create a few terminal loggers
7    let mut tl0 = StderrLogger::new(LevelFilter::Debug);
8    tl0.msg_format("TL0: {timestamp} - {level} - {args}");
9
10    let mut tl1 = StderrLogger::new(LevelFilter::Info);
11    tl1.msg_format("TL1: {timestamp} - {level} - {args}");
12
13    let mut tl2 = StderrLogger::new(LevelFilter::Warn);
14    tl2.msg_format("TL2: {timestamp} - {level} - {args}");
15
16    // Put one one terminal logger into one poly_logger
17    let mut pl0 = PolyLogger::new();
18    pl0.add(tl0);
19
20    // Put other terminal loggers into another poly_logger
21    let mut pl1 = PolyLogger::new();
22    pl1.add(tl1);
23    pl1.add(tl2);
24
25    // Put second poly_logger into the first poly_logger
26    // which is the one we actually register with the 
27    // log system via init().
28    // Not sure if this would ever make sense, but hey...
29    pl0.add(pl1);
30    pl0.init().unwrap();
31
32    trace!("This is an TRACE message");
33    eprintln!("------------------------------");
34    debug!("This is a DEBUG message");
35    eprintln!("------------------------------");
36    info!("This is an INFO message");
37    eprintln!("------------------------------");
38    warn!("This is a WARN message");
39    eprintln!("------------------------------");
40    error!("This is an ERROR message");
41}

examples/poly.rs (line 41)

5fn main() {
6    // Create some logger instances and run all through
7    // the PolyLogger
8    
9    // Default format 
10    let tl0 = StderrLogger::new(LevelFilter::Info);
11
12    // Custom format
13    let mut tl1 = StderrLogger::new(LevelFilter::Warn);
14    tl1.timestamp_format("%a %b %e %T %Y")
15       .msg_format("Custom: [{timestamp}] {level} [{file}:{line}] - {args}");
16
17    // Simpler format
18    let mut tl2 = StderrLogger::new(LevelFilter::Info);
19    tl2.msg_format("Simple1: {level} [{timestamp}] {args}")
20       .timestamp_format("%T");
21
22    // Even simpler
23    let mut tl3 = StderrLogger::new(LevelFilter::Debug);
24    tl3.msg_format("Simple2: {level} - {args}")
25       .timestamp_format("");
26
27    // Raw format to stdout
28    let mut tl4 = StdoutLogger::new(LevelFilter::Trace);
29    tl4.msg_format("{args}")
30       .timestamp_format("");
31
32    // File logger
33    let filename = "/tmp/file_logger.log";
34    let mut fl0 = FileLogger::new(LevelFilter::Info);
35    fl0.msg_format("Simple1: {level} [{timestamp}] {args}")
36       .timestamp_format("%T")
37       .filename(filename);
38    println!("Logging to {}", filename);
39    
40    // Create the poly logger and add our logger instances
41    let mut pl = PolyLogger::new();
42    pl.add(tl0);
43    pl.add(tl1);
44    pl.add(tl2);
45    pl.add(tl3);
46    pl.add(tl4);
47    pl.add(fl0.create());
48    pl.init().unwrap();
49
50    trace!("This is an TRACE message");
51    eprintln!("------------------------------");
52    debug!("This is a DEBUG message");
53    eprintln!("------------------------------");
54    info!("This is an INFO message");
55    eprintln!("------------------------------");
56    warn!("This is a WARN message");
57    eprintln!("------------------------------");
58    error!("This is an ERROR message");
59}

pub fn init(self) -> Result<(), SetLoggerError>

Initializes the log interface using this PolyLogger as a boxed logger. This moves self so is the last method to call on this object.

Examples found in repository ?

examples/doc_poly.rs (line 14)

4fn main() {
5    let mut stderr_log = StderrLogger::new(LevelFilter::Debug);
6    stderr_log.msg_format("{args}");
7
8    let mut file_log = FileLogger::new(LevelFilter::Info);
9    file_log.filename("./test.log");
10
11    let mut poly_log = PolyLogger::new();
12    poly_log.add(file_log.create()); // create() returns the GenLogger
13    poly_log.add(stderr_log);
14    poly_log.init().unwrap();
15
16    info!("This goes to both loggers");
17    debug!("This only goes to stderr");
18}

More examples

Hide additional examples

examples/poly2.rs (line 30)

5fn main() {
6    // Create a few terminal loggers
7    let mut tl0 = StderrLogger::new(LevelFilter::Debug);
8    tl0.msg_format("TL0: {timestamp} - {level} - {args}");
9
10    let mut tl1 = StderrLogger::new(LevelFilter::Info);
11    tl1.msg_format("TL1: {timestamp} - {level} - {args}");
12
13    let mut tl2 = StderrLogger::new(LevelFilter::Warn);
14    tl2.msg_format("TL2: {timestamp} - {level} - {args}");
15
16    // Put one one terminal logger into one poly_logger
17    let mut pl0 = PolyLogger::new();
18    pl0.add(tl0);
19
20    // Put other terminal loggers into another poly_logger
21    let mut pl1 = PolyLogger::new();
22    pl1.add(tl1);
23    pl1.add(tl2);
24
25    // Put second poly_logger into the first poly_logger
26    // which is the one we actually register with the 
27    // log system via init().
28    // Not sure if this would ever make sense, but hey...
29    pl0.add(pl1);
30    pl0.init().unwrap();
31
32    trace!("This is an TRACE message");
33    eprintln!("------------------------------");
34    debug!("This is a DEBUG message");
35    eprintln!("------------------------------");
36    info!("This is an INFO message");
37    eprintln!("------------------------------");
38    warn!("This is a WARN message");
39    eprintln!("------------------------------");
40    error!("This is an ERROR message");
41}

examples/poly.rs (line 48)

5fn main() {
6    // Create some logger instances and run all through
7    // the PolyLogger
8    
9    // Default format 
10    let tl0 = StderrLogger::new(LevelFilter::Info);
11
12    // Custom format
13    let mut tl1 = StderrLogger::new(LevelFilter::Warn);
14    tl1.timestamp_format("%a %b %e %T %Y")
15       .msg_format("Custom: [{timestamp}] {level} [{file}:{line}] - {args}");
16
17    // Simpler format
18    let mut tl2 = StderrLogger::new(LevelFilter::Info);
19    tl2.msg_format("Simple1: {level} [{timestamp}] {args}")
20       .timestamp_format("%T");
21
22    // Even simpler
23    let mut tl3 = StderrLogger::new(LevelFilter::Debug);
24    tl3.msg_format("Simple2: {level} - {args}")
25       .timestamp_format("");
26
27    // Raw format to stdout
28    let mut tl4 = StdoutLogger::new(LevelFilter::Trace);
29    tl4.msg_format("{args}")
30       .timestamp_format("");
31
32    // File logger
33    let filename = "/tmp/file_logger.log";
34    let mut fl0 = FileLogger::new(LevelFilter::Info);
35    fl0.msg_format("Simple1: {level} [{timestamp}] {args}")
36       .timestamp_format("%T")
37       .filename(filename);
38    println!("Logging to {}", filename);
39    
40    // Create the poly logger and add our logger instances
41    let mut pl = PolyLogger::new();
42    pl.add(tl0);
43    pl.add(tl1);
44    pl.add(tl2);
45    pl.add(tl3);
46    pl.add(tl4);
47    pl.add(fl0.create());
48    pl.init().unwrap();
49
50    trace!("This is an TRACE message");
51    eprintln!("------------------------------");
52    debug!("This is a DEBUG message");
53    eprintln!("------------------------------");
54    info!("This is an INFO message");
55    eprintln!("------------------------------");
56    warn!("This is a WARN message");
57    eprintln!("------------------------------");
58    error!("This is an ERROR message");
59}

pub fn max_level(&self) -> Level

Returns the maximum log Level of any of the child loggers added to this PolyLogger

pub fn add<T: Log + 'static>(&mut self, logger: T)

Adds a logger to this PolyLogger. This can be anything that implements the log::Log interface.

Examples found in repository ?

examples/doc_poly.rs (line 12)

4fn main() {
5    let mut stderr_log = StderrLogger::new(LevelFilter::Debug);
6    stderr_log.msg_format("{args}");
7
8    let mut file_log = FileLogger::new(LevelFilter::Info);
9    file_log.filename("./test.log");
10
11    let mut poly_log = PolyLogger::new();
12    poly_log.add(file_log.create()); // create() returns the GenLogger
13    poly_log.add(stderr_log);
14    poly_log.init().unwrap();
15
16    info!("This goes to both loggers");
17    debug!("This only goes to stderr");
18}

More examples

Hide additional examples

examples/poly2.rs (line 18)

5fn main() {
6    // Create a few terminal loggers
7    let mut tl0 = StderrLogger::new(LevelFilter::Debug);
8    tl0.msg_format("TL0: {timestamp} - {level} - {args}");
9
10    let mut tl1 = StderrLogger::new(LevelFilter::Info);
11    tl1.msg_format("TL1: {timestamp} - {level} - {args}");
12
13    let mut tl2 = StderrLogger::new(LevelFilter::Warn);
14    tl2.msg_format("TL2: {timestamp} - {level} - {args}");
15
16    // Put one one terminal logger into one poly_logger
17    let mut pl0 = PolyLogger::new();
18    pl0.add(tl0);
19
20    // Put other terminal loggers into another poly_logger
21    let mut pl1 = PolyLogger::new();
22    pl1.add(tl1);
23    pl1.add(tl2);
24
25    // Put second poly_logger into the first poly_logger
26    // which is the one we actually register with the 
27    // log system via init().
28    // Not sure if this would ever make sense, but hey...
29    pl0.add(pl1);
30    pl0.init().unwrap();
31
32    trace!("This is an TRACE message");
33    eprintln!("------------------------------");
34    debug!("This is a DEBUG message");
35    eprintln!("------------------------------");
36    info!("This is an INFO message");
37    eprintln!("------------------------------");
38    warn!("This is a WARN message");
39    eprintln!("------------------------------");
40    error!("This is an ERROR message");
41}

examples/poly.rs (line 42)

5fn main() {
6    // Create some logger instances and run all through
7    // the PolyLogger
8    
9    // Default format 
10    let tl0 = StderrLogger::new(LevelFilter::Info);
11
12    // Custom format
13    let mut tl1 = StderrLogger::new(LevelFilter::Warn);
14    tl1.timestamp_format("%a %b %e %T %Y")
15       .msg_format("Custom: [{timestamp}] {level} [{file}:{line}] - {args}");
16
17    // Simpler format
18    let mut tl2 = StderrLogger::new(LevelFilter::Info);
19    tl2.msg_format("Simple1: {level} [{timestamp}] {args}")
20       .timestamp_format("%T");
21
22    // Even simpler
23    let mut tl3 = StderrLogger::new(LevelFilter::Debug);
24    tl3.msg_format("Simple2: {level} - {args}")
25       .timestamp_format("");
26
27    // Raw format to stdout
28    let mut tl4 = StdoutLogger::new(LevelFilter::Trace);
29    tl4.msg_format("{args}")
30       .timestamp_format("");
31
32    // File logger
33    let filename = "/tmp/file_logger.log";
34    let mut fl0 = FileLogger::new(LevelFilter::Info);
35    fl0.msg_format("Simple1: {level} [{timestamp}] {args}")
36       .timestamp_format("%T")
37       .filename(filename);
38    println!("Logging to {}", filename);
39    
40    // Create the poly logger and add our logger instances
41    let mut pl = PolyLogger::new();
42    pl.add(tl0);
43    pl.add(tl1);
44    pl.add(tl2);
45    pl.add(tl3);
46    pl.add(tl4);
47    pl.add(fl0.create());
48    pl.init().unwrap();
49
50    trace!("This is an TRACE message");
51    eprintln!("------------------------------");
52    debug!("This is a DEBUG message");
53    eprintln!("------------------------------");
54    info!("This is an INFO message");
55    eprintln!("------------------------------");
56    warn!("This is a WARN message");
57    eprintln!("------------------------------");
58    error!("This is an ERROR message");
59}

Trait Implementations§

impl Debug for PolyLogger

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

impl Log for PolyLogger

fn enabled(&self, metadata: &Metadata<'_>) -> bool

Determines if a log message with the specified metadata would be logged. Read more

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

Logs the Record. Read more

fn flush(&self)

Flushes any buffered records.

Auto Trait Implementations§

impl Freeze for PolyLogger

impl !RefUnwindSafe for PolyLogger

impl Send for PolyLogger

impl Sync for PolyLogger

impl Unpin for PolyLogger

impl UnsafeUnpin for PolyLogger

impl !UnwindSafe for PolyLogger

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.