Enum OutputChannel 

pub enum OutputChannel {
    File(FileSettings),
    Console,
    Auto(FileSettings),
}

Output Types for Logger.

Variants

File(FileSettings)

Store to files.

Console

Output to stdout.

Auto(FileSettings)

If dev mode -> stdout, If release -> file

Implementations

impl OutputChannel

pub fn console() -> Self

pub fn auto() -> Self

pub fn file( path: PathBuf, capacity: usize, file_size: FileSize, filename: String, file_extension: String, ) -> Self

Examples found in repository

examples/demo.rs (lines 15-21)

fn main() {
    let formatter = MessageFormatter::new(
        "::",
        "{timestamp:-6:30:right}{splitter}{modules:_:_:left}{splitter}{message}",
        "%Y-%m-%d %H:%M:%S.%f",
    );

    let output = OutputChannel::file(
        "./logs".into(),
        10,
        FileSize::from_kilobytes(1),
        "new_logger".into(),
        "log".into(),
    );

    let settings = Settings::new(true, 5, output, formatter);

    let logger = Logger::new(settings);
    let joiner = logger.run_async();

    let logger_logger_01 = logger.clone();
    let logger_logger_02 = logger.clone();
    let _ = thread::spawn(move || {
        logger_logger_01.log(&vec!["THREAD1".into(), "MAIN".into()], "Starting...");

        let mut counter = 0;
        loop {
            logger_logger_01.log(
                &vec!["THREAD1".into(), "WORKER".into()],
                format!("Processing Job: {counter}").as_str(),
            );
            counter += 1;
            sleep(Duration::from_secs(1));
        }
    });

    let _ = thread::spawn(move || {
        logger_logger_02.log(&vec!["THREAD2".into(), "MAIN".into()], "Starting...");

        let mut counter = 0;
        loop {
            logger_logger_02.log(
                &vec!["THREAD2".into(), "WORKER".into()],
                format!("Processing Job: {counter}").as_str(),
            );
            counter += 2;
            sleep(Duration::from_millis(400));
        }
    });

    let _ = thread::spawn(move || {
        log!("Starting...");

        let mut counter = 0;
        loop {
            log!(format!("Try Process Job: {counter}").as_str());

            // Log as text
            log!(
                ["THREAD3", "MODULE1"],
                format!("Try Process Job: {counter}").as_str()
            );
            let module_str = "RAW_MODULE";
            let thread3_str = "THREAD3";

            // Log from vars
            log!(
                [thread3_str, module_str],
                format!("Try Process Job: {counter}").as_str()
            );

            // Log as ident
            log!((RAW_MODULE, RAW_MODULE2, RAW_MODULE3), "some");
            counter += 2;
            sleep(Duration::from_millis(400));
        }
    });

    match joiner {
        Some(j) => {
            let _ = j.join();
        }
        None => {}
    };
}

pub fn settings(&self) -> Option<&FileSettings>

Trait Implementations

impl Clone for OutputChannel

fn clone(&self) -> OutputChannel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OutputChannel

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

Formats the value using the given formatter.

impl Default for OutputChannel

fn default() -> Self

Returns the “default value” for a type.