Skip to main content

openauth_core/env/
logger.rs

1use std::sync::Arc;
2
3/// Log severity level.
4#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5pub enum LogLevel {
6    Debug,
7    Info,
8    Success,
9    Warn,
10    Error,
11}
12
13impl LogLevel {
14    const fn rank(self) -> u8 {
15        match self {
16            Self::Debug => 0,
17            Self::Info | Self::Success => 1,
18            Self::Warn => 2,
19            Self::Error => 3,
20        }
21    }
22
23    const fn handler_level(self) -> Self {
24        match self {
25            Self::Success => Self::Info,
26            level => level,
27        }
28    }
29}
30
31type LogHandler = dyn Fn(LogLevel, &str, &[&str]) + Send + Sync;
32
33/// Logger configuration.
34#[derive(Clone)]
35pub struct LoggerOptions {
36    level: LogLevel,
37    disabled: bool,
38    handler: Option<Arc<LogHandler>>,
39}
40
41impl LoggerOptions {
42    pub fn new(level: LogLevel) -> Self {
43        Self {
44            level,
45            disabled: false,
46            handler: None,
47        }
48    }
49
50    pub fn disabled(mut self, disabled: bool) -> Self {
51        self.disabled = disabled;
52        self
53    }
54
55    pub fn with_handler(
56        mut self,
57        handler: impl Fn(LogLevel, &str, &[&str]) + Send + Sync + 'static,
58    ) -> Self {
59        self.handler = Some(Arc::new(handler));
60        self
61    }
62}
63
64impl Default for LoggerOptions {
65    fn default() -> Self {
66        Self::new(LogLevel::Warn)
67    }
68}
69
70/// Core logger.
71#[derive(Clone)]
72pub struct Logger {
73    options: LoggerOptions,
74}
75
76impl Logger {
77    pub fn level(&self) -> LogLevel {
78        self.options.level
79    }
80
81    pub fn debug(&self, message: &str, args: &[&str]) {
82        self.log(LogLevel::Debug, message, args);
83    }
84
85    pub fn info(&self, message: &str, args: &[&str]) {
86        self.log(LogLevel::Info, message, args);
87    }
88
89    pub fn success(&self, message: &str, args: &[&str]) {
90        self.log(LogLevel::Success, message, args);
91    }
92
93    pub fn warn(&self, message: &str, args: &[&str]) {
94        self.log(LogLevel::Warn, message, args);
95    }
96
97    pub fn error(&self, message: &str, args: &[&str]) {
98        self.log(LogLevel::Error, message, args);
99    }
100
101    fn log(&self, level: LogLevel, message: &str, args: &[&str]) {
102        if self.options.disabled || !should_publish_log(self.options.level, level) {
103            return;
104        }
105
106        if let Some(handler) = &self.options.handler {
107            handler(level.handler_level(), message, args);
108        }
109    }
110}
111
112/// Create a logger from options.
113pub fn create_logger(options: LoggerOptions) -> Logger {
114    Logger { options }
115}
116
117/// Return whether a log event should be published for the configured level.
118pub fn should_publish_log(current_log_level: LogLevel, log_level: LogLevel) -> bool {
119    log_level.rank() >= current_log_level.rank()
120}