loggify 1.4.0

Small and simple rust logger
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use crate::Loggify;

use log;
use log::{Level, SetLoggerError};

/// Struct for building a new logger
pub struct LogBuilder {
    exclude: Vec<String>,
    level: Level,
    time_format: String,
    log_target: bool,
    color: bool
}

impl LogBuilder {
    /// Creates a new instance of the `LogBuilder`
    /// 
    /// # Defaults
    /// - `level` -> The default level is `Info`
    /// - `exclude` -> No targets are excluded
    /// - `time_format` -> dd.mm.YY HH:MM:SS
    /// - `log_target` -> false
    /// 
    /// # Example
    /// ```
    /// //! Example for initializing the logger with the LogBuilder
    /// use log::{error, warn, info, debug, trace};
    /// use loggify::LogBuilder;
    /// 
    /// /// The `LogBuilder` is used to set more logger options
    /// /// This example will change the log level to Trace
    /// /// and the printed time format to time only
    /// fn main() {
    ///     LogBuilder::new()
    ///         .set_level(log::Level::Trace)
    ///         .set_time_format(String::from("%H:%M:%S"))
    ///         .build()
    ///         .unwrap();
    /// 
    ///     error!("My error message");
    ///     warn!("My warn message");
    ///     info!("My info message");
    ///     debug!("My debug message");
    ///     trace!("My trace message");
    /// }
    /// ```
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a new target to exclude from logging
    /// 
    /// See the example `exclude` for usage
    pub fn add_exclude(mut self, name: String) -> Self {
        self.exclude.push(name);
        self
    }

    /// Sets the minimum level
    pub fn set_level(mut self, level: Level) -> Self {
        self.level = level;
        self
    }

    /// Sets the time format
    /// See https://docs.rs/chrono/0.4.6/chrono/format/strftime/index.html for supported escape sequences
    pub fn set_time_format(mut self, format: String) -> Self {
        self.time_format = format;
        self
    }

    /// Defines if the log target should be printed or not
    /// This option should be used to find out where a log comes
    /// from and what target to exclude from logging
    pub fn set_log_target(mut self, state: bool) -> Self {
        self.log_target = state;
        self
    }

    /// Disables color output
    /// Per default `true`
    pub fn disable_color(mut self) -> Self {
        self.color = false;
        self
    }

    /// Creates a new logger
    pub fn build(self) -> Result<(), SetLoggerError> {
        let logger = Loggify { 
            level: self.level, 
            exclude: self.exclude,
            time_format: self.time_format,
            log_target: self.log_target,
            color: self.color
        };
        log::set_boxed_logger(Box::new(logger))?;
        log::set_max_level(self.level.to_level_filter());
        Ok(())
    }
}

impl Default for LogBuilder {
    fn default() -> Self {
        Self {
            level: Level::Info,
            exclude: Vec::new(),
            time_format: String::from("%d.%m.%Y %H:%M:%S"),
            log_target: false,
            color: std::env::var("LOGGIFY_COLOR")
                .map(|x| x.parse().unwrap_or(true))
                .unwrap_or(true)
        }
    }
}