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

use colored::Colorize;
use fern::{
    colors::{Color, ColoredLevelConfig},
    Dispatch,
};
use log::{Level, LevelFilter};
/// Converts verbosity number to [LevelFilter](log::LevelFilter) enum.
/// Used for configuring the logging level.
/// # Arguments
///
/// * `verbosity` - verbosity level described by number `u8`
///
/// # Examples
/// ## Converts verbosity number
/// ```
/// use ptero::log::verbosity_to_level_filter;
/// use log::{LevelFilter};
///
/// assert_eq!(verbosity_to_level_filter(0), LevelFilter::Off);
/// assert_eq!(verbosity_to_level_filter(1), LevelFilter::Warn);
/// assert_eq!(verbosity_to_level_filter(2), LevelFilter::Info);
/// assert_eq!(verbosity_to_level_filter(3), LevelFilter::Debug);
/// ```
/// ## Unrecognized verbosity defaults to trace
/// ```
/// use ptero::log::verbosity_to_level_filter;
/// use log::{LevelFilter};
///
/// assert_eq!(verbosity_to_level_filter(4), LevelFilter::Trace);
/// assert_eq!(verbosity_to_level_filter(100), LevelFilter::Trace);
/// assert_eq!(verbosity_to_level_filter(255), LevelFilter::Trace);
/// ```
pub fn verbosity_to_level_filter(verbosity: u8) -> LevelFilter {
    match verbosity {
        0 => LevelFilter::Off,
        1 => LevelFilter::Warn,
        2 => LevelFilter::Info,
        3 => LevelFilter::Debug,
        _ => LevelFilter::Trace,
    }
}

/// Returns pre-configured [ColoredLevelConfig](fern::colors::ColoredLevelConfig) used to color
/// logging level.
fn get_logging_colors() -> ColoredLevelConfig {
    ColoredLevelConfig::new()
        .error(Color::Red)
        .warn(Color::BrightYellow)
        .debug(Color::Magenta)
        .trace(Color::BrightBlack)
}

/// Returns text which will be shown before the message. Used only in stdout formatter.
fn get_level_text(level: &Level) -> &str {
    match level {
        Level::Error => "ERROR",
        Level::Warn => " WARN",
        Level::Info => " INFO",
        Level::Debug => "DEBUG",
        Level::Trace => "TRACE",
    }
}

/// Returns pre-configured stdout logger.
/// It only shows info relevant to user like message and logging level.
/// Uses coloring unlike file logger.
///
/// # Arguments
/// * `log_level` - level filter which is used to restrict amount of logs to user
pub fn get_stdout_logger() -> Dispatch {
    let colors = get_logging_colors();

    fern::Dispatch::new()
        .format(move |out, message, record| {
            out.finish(format_args!(
                "{color_line}{level_txt}\x1B[0m  [{module}]: {message}",
                level_txt = get_level_text(&record.level()),
                color_line =
                    format_args!("\x1B[{}m", colors.get_color(&record.level()).to_fg_str()),
                message = message,
                module = &record.target().dimmed(),
            ));
        })
        .chain(std::io::stderr())
}

/// Returns pre-configured file logger.
/// This logger does not used coloring and adds additional info like date time or module path.
/// It doesn't restrict logging - saves everything beginning from `TRACE` level.
///
/// # Arguments
/// * `log_path` - path to the log file which will be used to store logs
pub fn get_file_logger(log_path: &str) -> Dispatch {
    fern::Dispatch::new()
        .format(move |out, message, record| {
            out.finish(format_args!(
                "{}[{}][{}] - {}",
                chrono::Local::now().format("[%Y-%m-%d][%H:%M:%S]"),
                &record.target(),
                &record.level(),
                message,
            ));
        })
        .chain(fern::log_file(&log_path).unwrap())
}