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

use owo_colors::OwoColorize;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LogLevel {
  Debug,
  Info,
  Warn,
  Error,
}

#[derive(Debug)]
pub struct DefaultLogger(pub LogLevel, pub bool);

impl DefaultLogger {
  pub fn log_level(&self) -> u8 {
    if let Ok(level) = std::env::var("LOG_LEVEL") {
      match &*level.to_lowercase() {
        "debug" => 4,
        "info" => 3,
        "warn" => 2,
        _ => 1,
      }
    } else {
      match self.0 {
        LogLevel::Debug => 4,
        LogLevel::Info => 3,
        LogLevel::Warn => 2,
        LogLevel::Error => 1,
      }
    }
  }
}

impl super::Logger for DefaultLogger {
  fn debug(&self, message: &str) {
    if self.log_level() >= 4 {
      println!(
        "[{}]: {}",
        if self.1 {
          "debug".bright_blue().to_string()
        } else {
          "debug".into()
        },
        message
      );
    }
  }

  fn info(&self, message: &str) {
    if self.log_level() >= 3 {
      println!(
        "[{}]: {}",
        if self.1 {
          "info".green().to_string()
        } else {
          "info".into()
        },
        message
      );
    }
  }

  fn warn(&self, message: &str) {
    if self.log_level() >= 2 {
      println!(
        "[{}]: {}",
        if self.1 {
          "warn".yellow().to_string()
        } else {
          "warn".into()
        },
        message
      );
    }
  }

  fn error(&self, message: &str) {
    if self.log_level() >= 1 {
      println!(
        "[{}]: {}",
        if self.1 {
          "error".bright_red().to_string()
        } else {
          "error".into()
        },
        message
      );
    }
  }

  fn raw(&self, message: &str) {
    println!("{}", message);
  }
}