winston 0.1.1

winston for rust
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

use super::{transports::Transport, Logger, LoggerOptions};
use logform::BoxedLogFormat as LogFormat;
use std::{collections::HashMap, sync::Arc};

pub struct LoggerBuilder {
    levels: Option<HashMap<String, u8>>,
    format: Option<LogFormat>,
    level: Option<String>,
    transports: Option<Vec<Arc<dyn Transport + Send + Sync>>>,
}

impl LoggerBuilder {
    pub fn new() -> Self {
        LoggerBuilder {
            levels: None,
            format: None,
            level: None,
            transports: None,
        }
    }

    pub fn add_level<T: Into<String>>(mut self, level: T, value: u8) -> Self {
        self.levels
            .get_or_insert_with(HashMap::new)
            .insert(level.into(), value);
        self
    }

    pub fn format(mut self, format: LogFormat) -> Self {
        self.format = Some(format);
        self
    }

    pub fn level<T: Into<String>>(mut self, level: T) -> Self {
        self.level = Some(level.into());
        self
    }

    pub fn add_transport<T: Transport + Send + Sync + 'static>(mut self, transport: T) -> Self {
        self.transports
            .get_or_insert_with(Vec::new)
            .push(Arc::new(transport));
        self
    }

    pub fn build(self) -> Logger {
        let options = LoggerOptions {
            levels: self.levels.or_else(|| LoggerOptions::default().levels),
            format: self.format.or_else(|| LoggerOptions::default().format),
            level: self.level.or_else(|| LoggerOptions::default().level),
            transports: self
                .transports
                .or_else(|| LoggerOptions::default().transports),
        };

        Logger::new(Some(options))
    }
}