lunar-logger 0.1.1

Simple logger with write to file functionality
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::path::{Path, PathBuf};

///Builder struct for easier [Logger](crate::Logger) creation
///
///Example:
///
///```
///use lunar_logger::Builder;
///
///Builder::new()
///     .add_crate_filter("wgpu",log::LevelFilter::Warn)
///     .default_filter(log::LevelFilter::Info)
///     .log_to_file()
///     .create()
///     .enable_logger();
///
///log::info!("It works!");
///```
pub struct Builder {
    crate_filters: Vec<(String, log::LevelFilter)>,
    mod_filters: Vec<(String, log::LevelFilter)>,
    default_level: log::LevelFilter,
    log_to_file: bool,
    log_filename: Option<PathBuf>,
    time_format: String,
}

impl Default for Builder {
    fn default() -> Self {
        Self::new()
    }
}

impl Builder {
    ///Creates a new builder
    #[must_use]
    pub fn new() -> Self {
        Self {
            crate_filters: Vec::new(),
            mod_filters: Vec::new(),
            default_level: log::LevelFilter::Info,
            log_to_file: false,
            log_filename: None,
            time_format: String::new(),
        }
    }

    ///Adds a filter for a crate
    #[must_use]
    pub fn add_crate_filter(mut self, crate_name: &str, level: log::LevelFilter) -> Self {
        self.crate_filters.push((crate_name.to_owned(), level));
        self
    }

    ///Adds a filter for a module
    #[must_use]
    pub fn add_mod_filter(mut self, crate_name: &str, level: log::LevelFilter) -> Self {
        self.mod_filters.push((crate_name.to_owned(), level));
        self
    }

    ///Sets the default logging level
    #[must_use]
    pub const fn default_filter(mut self, level: log::LevelFilter) -> Self {
        self.default_level = level;
        self
    }

    ///Enables logging to file
    #[must_use]
    pub const fn log_to_file(mut self) -> Self {
        self.log_to_file = true;
        self
    }

    ///Sets the filename of the log file
    #[must_use]
    pub fn log_filname(mut self, filename: &Path) -> Self {
        self.log_filename = Some(filename.to_owned());
        self
    }

    ///Sets the time stamp format
    #[must_use]
    pub fn time_format(mut self, format: &str) -> Self {
        format.clone_into(&mut self.time_format);
        self
    }

    ///Crates the [Logger](crate::Logger) from the builder
    ///
    ///# Panics
    ///
    ///Will panic if the log filename is not a valid filename
    #[must_use]
    pub fn create(self) -> super::Logger {
        let mut logger = crate::Logger::new();

        for (name, level) in self.crate_filters {
            logger.add_filter(&name, crate::FilterType::Crate, level);
        }
        for (name, level) in self.mod_filters {
            logger.add_filter(&name, crate::FilterType::Module, level);
        }
        logger.set_timestamp_format(&self.time_format);

        if self.log_to_file {
            logger.set_log_to_file();
        }

        if let Some(f) = self.log_filename {
            logger.set_log_file_name(&f).unwrap();
        }

        logger
    }

    ///Creates the logger and sets it to be the logger of the program
    ///
    ///# Errors
    ///
    ///see [enable_logger](crate::Logger::enable_logger)
    ///
    ///# Panics
    ///
    ///Will panic if the log filename is not a valid filename
    pub fn init(self) -> Result<(), crate::LoggerError> {
        self.create().enable_logger()
    }
}