rstaples 0.1.1

Utility functions
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

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

use log::LevelFilter;

use crate::error::Result;

pub struct StaplesLogger {
    verbose: bool,
    log_file_path: Option<PathBuf>,
    log_level: LevelFilter,
}

impl Default for StaplesLogger {
    fn default() -> Self {
        Self {
            verbose: false,
            log_file_path: None,
            log_level: LevelFilter::Warn,
        }
    }
}

impl StaplesLogger {
    pub fn new() -> Self {
        StaplesLogger::default()
    }

    pub fn with_stdout(mut self) -> Self {
        self.verbose = true;
        self
    }

    pub fn with_log_file<P>(mut self, path: P) -> Self
    where
        P: AsRef<Path>,
    {
        self.log_file_path = Some(path.as_ref().to_path_buf());
        self
    }

    pub fn with_log_level(mut self, level: LevelFilter) -> Self {
        self.log_level = level;
        self
    }

    pub fn start(&self) -> Result<()> {
        let f = fern::Dispatch::new()
            .format(|out, message, record| {
                let now_ms = chrono::Local::now().timestamp_millis();
                let now_sec = now_ms / 1000;
                let now_ms = now_ms - (now_sec * 1000);

                let target = match record.line() {
                    Some(v) => format!("{}:{v}", record.target()),
                    None => record.target().to_string(),
                };

                out.finish(format_args!(
                    "{}.{:03} :: {:<5} :: {:<45} {}",
                    now_sec,
                    now_ms,
                    record.level(),
                    target,
                    message
                ))
            })
            .level(self.log_level);

        let f = match &self.log_file_path {
            Some(v) => f.chain(fern::log_file(v)?),
            None => f,
        };

        let f = match self.verbose {
            true => f.chain(std::io::stdout()),
            false => f,
        };

        f.apply()?;
        Ok(())
    }
}