serwus 0.2.3

Helpers for building actix-web/diesel based services
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

use chrono::*;
use colored::*;
use log::{Level, LevelFilter, Metadata, Record, SetLoggerError, info};

pub struct ConsoleLogger;

pub static LOGGER: ConsoleLogger = ConsoleLogger;

pub fn logger_level() -> String {
    ::std::env::var("LOGGER_LEVEL").unwrap_or_else(|_| "info".to_string())
}

impl log::Log for ConsoleLogger {
    fn enabled(&self, metadata: &Metadata<'_>) -> bool {
        metadata.level() <= Level::Info || logger_level() == "debug"
    }

    fn log(&self, record: &Record<'_>) {
        let now = Utc::now();
        let hour = now.hour();
        let (_, year) = now.year_ce();

        let date = format!(
            "{}-{:02}-{:02} {:02}:{:02}:{:02}",
            year,
            now.month(),
            now.day(),
            hour,
            now.minute(),
            now.second(),
        );

        if self.enabled(record.metadata()) {
            let level = if record.level() == Level::Info {
                format!("{}", record.level()).green()
            } else if record.level() == Level::Error {
                format!("{}", record.level()).red()
            } else if record.level() == Level::Warn {
                format!("{}", record.level()).bright_magenta()
            } else {
                format!("{}", record.level()).yellow()
            };

            let env = ::std::env::var("ENV").unwrap_or_else(|_| "dev".to_string());
            let proj_prefix = ::std::env::var("PROJECT_PREFIX").unwrap_or_else(|_| "".to_string());
            let lib_name = env!("CARGO_PKG_NAME");

            if [Level::Error, Level::Warn].contains(&record.level()) && env != "dev" {
                println!(
                    "[{} {}] {}:{} - {}",
                    level,
                    record.module_path().unwrap_or(""),
                    record.file().unwrap_or(""),
                    record.line().unwrap_or(0),
                    format!("{}", record.args()).green(),
                )
            } else if env != "dev" && record.level() != Level::Debug {
                println!(
                    "[{} {}] - {}",
                    level,
                    record.module_path().unwrap_or(""),
                    record.args(),
                )
            } else if record.module_path().unwrap_or("").contains(&proj_prefix)
                || record.module_path().unwrap_or("").contains(lib_name)
                || record.level() != Level::Debug
            {
                println!(
                    "{}{} {} {}{} {}",
                    "[".to_string().white(),
                    date,
                    level,
                    record.module_path().unwrap_or(""),
                    "]".to_string().white(),
                    format!("{}", record.args()).white(),
                )
            }
        }
    }

    fn flush(&self) {}
}

pub fn init_logger() -> Result<(), SetLoggerError> {
    log::set_logger(&LOGGER)?;

    if logger_level() == "debug" {
        log::set_max_level(LevelFilter::Debug);
    } else {
        log::set_max_level(LevelFilter::Info);
    }

    info!("Logger init...");

    Ok(())
}