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)
        }
    }
}