hack_log 0.1.0

A minimalistic logging formatter
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

extern crate env_logger;
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate log;
extern crate clap;
#[cfg(feature = "color")]
extern crate ansi_term;

#[cfg(feature = "color")]
use ansi_term::Colour::{Blue, Green, Red, White, Yellow};
use clap::ArgMatches;
use env_logger::LogBuilder;
use log::{LogLevel, LogLevelFilter, LogRecord, SetLoggerError};
use std::sync::atomic::{AtomicUsize, Ordering};

lazy_static! {
    static ref HACKLOG_INDENT:AtomicUsize = {
        AtomicUsize::new(0)
    };
}


pub fn init(opts: Option<&ArgMatches>, level: Option<LogLevelFilter>) -> Result<(), SetLoggerError> {
    let mut builder = LogBuilder::new();
    init_format(&mut builder);
    if let Some(opts) = opts {
        init_clap(opts, &mut builder);
    }
    if let Some(level) = level {
        builder.filter(None, level);
    }
    builder.init()
}

fn init_format(builder: &mut LogBuilder) {
    #[cfg(not(feature = "color"))]
    builder.format(|record: &LogRecord| {
        format!("{:>ident$} {}",
                match record.level() {
                    LogLevel::Error => "[-]",
                    LogLevel::Warn => "[*]",
                    LogLevel::Info => "[+]",
                    LogLevel::Debug => "[#]",
                    LogLevel::Trace => "[%]",
                },
                record.args(),
                ident=HACKLOG_INDENT.load(Ordering::SeqCst) * 4)
    });
    #[cfg(feature = "color")]
    builder.format(|record: &LogRecord| {
        format!("{holder:>ident$}{} {}",
                match record.level() {
                    LogLevel::Error => Red.paint("[-]"),
                    LogLevel::Warn => Yellow.paint("[*]"),
                    LogLevel::Info => Green.paint("[+]"),
                    LogLevel::Debug => Blue.paint("[#]"),
                    LogLevel::Trace => White.paint("[%]"),
                },
                record.args(),
                holder="",
                ident=HACKLOG_INDENT.load(Ordering::SeqCst) * 4)
    });
}

fn init_clap(opts: &ArgMatches, builder: &mut LogBuilder) {
    builder.filter(None,
                   match opts.occurrences_of("verbose") {
                       n if n >= 3 => LogLevelFilter::Trace,
                       n if n == 2 => LogLevelFilter::Debug,
                       n if n == 1 => LogLevelFilter::Info,
                       _ => LogLevelFilter::Warn,
                   });
}

fn indent() -> usize {
    HACKLOG_INDENT.fetch_add(1, Ordering::SeqCst)
}

fn unindent() -> usize {
    HACKLOG_INDENT.fetch_sub(1, Ordering::SeqCst)
}

#[cfg(test)]
mod tests {
    use super::*;
    use log::LogLevelFilter;

    #[test]
    fn test() {
        init(None, Some(LogLevelFilter::Trace)).unwrap();
        error!("level 1 - error message 1");
        indent();
        error!("level 2 - error message 1");
        indent();
        error!("level 3 - error message 1");
        unindent();
        error!("level 2 - error message 2");
        unindent();
        error!("level 1 - error message 1");
        warn!("a warning message");
        info!("a info message");
        debug!("a debug message");
        trace!("a trace message");
    }
}