Struct Console

pub struct Console { /* private fields */ }

Standard console output target.

This target writes log messages to the standard output (stdout) or standard error (stderr) using the Rust println! | eprintln! macro.

Implementations

impl Console

pub fn new() -> Self

Creates a new console target

Examples found in repository

examples/output.rs (line 6)

fn main() {
    traccia::init_with_config(traccia::Config {
        level: LogLevel::Debug,
        targets: vec![Box::new(Console::new().output(Output::Stderr))],
        ..Default::default()
    });

    debug!("This will be logged to stderr.");
    info!("In fact, all messages will be logged to stderr.");
    error!("This is an error logged to stderr!!!");
    fatal!("This is a fatal error logged to stderr!!!");
}

examples/filtered-output.rs (line 7)

fn main() {
    traccia::init_with_config(traccia::Config {
        level: LogLevel::Debug,
        targets: vec![Box::new(
            Console::new()
                .filtered_output(LogLevel::Error, Output::Stderr)
                .filtered_output(LogLevel::Fatal, Output::Stderr),
        )],
        ..Default::default()
    });

    debug!("This will be logged to stdout");
    info!("In fact, only error and fatal messages will be logged to stderr.");

    error!("This is an error logged to stderr!!!");
    fatal!("This is a fatal error logged to stderr!!!");
}

examples/level-filtering.rs (line 7)

fn main() {
    traccia::init_with_config(traccia::Config {
        level: LogLevel::Trace,
        targets: vec![
            Box::new(traccia::Console::new()),
            Box::new(
                traccia::File::new("./.logs/latest.log", FileMode::Truncate)
                    .expect("Failed to open file.")
                    .filtered(LogLevel::Fatal),
            ),
        ],
        ..Default::default()
    });

    info!("This will not be written to latest.log, but will be printed to console.");
    error!("It will write fatal messages only!");
    fatal!("Like this :(");
}

examples/target.rs (line 7)

fn main() {
    traccia::init_with_config(traccia::Config {
        level: LogLevel::Trace,
        targets: vec![
            Box::new(traccia::Console::new()),
            Box::new(
                traccia::File::new(".logs/latest.log", FileMode::Truncate)
                    .unwrap()
                    .filtered(LogLevel::Fatal),
            ),
        ],
        ..Default::default()
    });

    trace!("This is a 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");
    fatal!("This is a fatal message");
}

examples/hooks.rs (line 27)

fn main() {
    traccia::set_hook(Hook::AfterLog(Box::new(|_, target| {
        if let TargetId::Console(_) = target {
            println!("This will be printed after the log message");
        }
    })));

    traccia::set_hook(Hook::BeforeLog(Box::new(|level, target| {
        if let TargetId::File(_) = target {
            if level == LogLevel::Info {
                println!("This will be printed only before calling the info! macro on a file.")
            }
        }
    })));

    traccia::set_hook(Hook::BeforeLog(Box::new(|_, target| {
        if let TargetId::Console(_) = target {
            println!("This will be printed before the log message");
        }
    })));

    traccia::init_with_config(traccia::Config {
        level: LogLevel::Trace,
        targets: vec![
            Box::new(traccia::Console::new()),
            Box::new(
                traccia::File::new("./.logs/latest.log", traccia::FileMode::Truncate)
                    .expect("Failed to open file."),
            ),
        ],
        ..Default::default()
    });

    info!("This is a test log message");
    warn!("This is a test warning message");
}

pub fn filtered(self, level: LogLevel) -> Self

Builder method to set the custom filter level for this target.

pub fn output(self, output: Output) -> Self

Builder method to set the custom output for the console. This will write to the output for all the logs that target this console.

If you want to set the output for a specific log level, use filtered_outputs.

(e.g. You want to write all LogLevel::Error logs to stderr and all other logs to stdout)

Examples found in repository

examples/output.rs (line 6)

fn main() {
    traccia::init_with_config(traccia::Config {
        level: LogLevel::Debug,
        targets: vec![Box::new(Console::new().output(Output::Stderr))],
        ..Default::default()
    });

    debug!("This will be logged to stderr.");
    info!("In fact, all messages will be logged to stderr.");
    error!("This is an error logged to stderr!!!");
    fatal!("This is a fatal error logged to stderr!!!");
}

pub fn filtered_output(self, level: LogLevel, output: Output) -> Self

Builder method to set the custom output for a specific log level. This behaves like the output method, but only applies to the specified log level.

If you want to set the output for all logs, use output. Note: This will override the output set by output.

(e.g. If you set output to Stderr, calling filtered_outputs(LogLevel::Info, Output::Stdout) will log all LogLevel::Info logs to stdout and all other logs to stderr)

Examples found in repository

examples/filtered-output.rs (line 8)

fn main() {
    traccia::init_with_config(traccia::Config {
        level: LogLevel::Debug,
        targets: vec![Box::new(
            Console::new()
                .filtered_output(LogLevel::Error, Output::Stderr)
                .filtered_output(LogLevel::Fatal, Output::Stderr),
        )],
        ..Default::default()
    });

    debug!("This will be logged to stdout");
    info!("In fact, only error and fatal messages will be logged to stderr.");

    error!("This is an error logged to stderr!!!");
    fatal!("This is a fatal error logged to stderr!!!");
}

Trait Implementations

impl Clone for Console

fn clone(&self) -> Console

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Target for Console

fn write(&self, level: LogLevel, formatted: &str) -> Result<(), Error>

Writes the formatted log message to the console.

Arguments

• formatted - The formatted log message to write

Returns

Always returns Ok(())

fn filter_level(&self) -> Option<LogLevel>

Returns the custom filter level for the console target. If the filter level is set, log messages with a lower level will be ignored.

Useful for filtering log messages written to the console.

fn id(&self) -> TargetId

Returns the target ID for the console target. This is used to identify the target in the logger.