simple-log 2.4.0

A simple log. It's really simple use
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! `cargo run --example console`
//!
//! With OutPut
//! ```bash
//! 16:57:13.619320000 [DEBUG] <filter_module:25>:test console debug
//! 16:57:13.619481000 [INFO] <filter_module:26>:test console info
//! 16:57:13.619489000 [WARN] <filter_module:27>:test console warn
//! 16:57:13.619495000 [ERROR] <filter_module:28>:test console error
//! 16:57:13.619501000 [INFO] <filter_module::app:41>:init app
//! 16:57:13.619507000 [INFO] <filter_module::app::launch:46>:init launch
//! 16:57:13.619515000 [DEBUG] <filter_module::app::launch::parser:57>:parser log

//! ```

#[macro_use]
extern crate simple_log;

use log::LevelFilter;
use simple_log::LogConfig;

fn main() -> Result<(), String> {
    let config = r#"
    level = "debug,filter_module::app::ctrl=warn,filter_module::app::launch::conf=error"
    out_kind = "console"
    time_format = "%H:%M:%S.%f"
    "#;
    let conf: LogConfig = toml::from_str(config).unwrap();

    assert_eq!(
        conf,
        LogConfig {
            path: None,
            directory: None,
            level: (
                LevelFilter::Debug,
                vec![
                    ("filter_module::app::ctrl", LevelFilter::Warn).into(),
                    ("filter_module::app::launch::conf", LevelFilter::Error).into(),
                ]
            ),
            size: 0,
            out_kind: vec!["console".into()],
            roll_count: 0,
            time_format: Some("%H:%M:%S.%f".to_string()),
        }
    );

    simple_log::new(conf).unwrap(); //init log

    debug!("test console debug");
    info!("test console info");
    warn!("test console warn");
    error!("test console error");

    app::init_app();
    app::launch::init_launch();
    app::launch::conf::err_conf();
    app::launch::conf::debug_conf(); // this log filter
    app::launch::parser::err_parser();
    app::ctrl::init_ctrl(); // this log filter

    Ok(())
}

pub(crate) mod app {
    pub fn init_app() {
        info!("init app")
    }

    pub mod launch {
        pub fn init_launch() {
            info!("init launch")
        }

        pub mod conf {
            pub fn err_conf() {
                error!("conf log")
            }

            pub fn debug_conf() {
                debug!("conf log")
            }
        }

        pub mod parser {
            pub fn err_parser() {
                debug!("parser log")
            }
        }
    }

    pub mod ctrl {
        pub fn init_ctrl() {
            info!("init ctrl")
        }
    }
}