tlogger 0.1.4

A simple logging library with a neat style and customizablity.
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use std::{
    fs::{self, File, OpenOptions},
    io::Write,
    path::PathBuf,
};

use chrono::{DateTime, Local, Timelike};

use crate::strip_ansi_codes;

pub enum LogInterval {
    OneHour,
    ThreeHour,
    SixHour,
    NineHour,
    TwelveHour,
    OneDay,
}

impl LogInterval {
    fn get_file_timestamp(&self, now: DateTime<Local>) -> String {
        match self {
            LogInterval::OneHour => {
                let start_hour = now.hour();
                let end_hour = (start_hour + 1) % 24;
                format!(
                    "{}-{:02}h-{:02}h",
                    now.format("%Y-%m-%d"),
                    start_hour,
                    end_hour
                )
            }
            LogInterval::ThreeHour => {
                let start_hour = (now.hour() / 3) * 3;
                let end_hour = (start_hour + 3) % 24;
                format!(
                    "{}-{:02}h-{:02}h",
                    now.format("%Y-%m-%d"),
                    start_hour,
                    end_hour
                )
            }
            LogInterval::SixHour => {
                let start_hour = (now.hour() / 6) * 6;
                let end_hour = (start_hour + 6) % 24;
                format!(
                    "{}-{:02}h-{:02}h",
                    now.format("%Y-%m-%d"),
                    start_hour,
                    end_hour
                )
            }
            LogInterval::NineHour => {
                let start_hour = (now.hour() / 9) * 9;
                let end_hour = (start_hour + 9) % 24;
                format!(
                    "{}-{:02}h-{:02}h",
                    now.format("%Y-%m-%d"),
                    start_hour,
                    end_hour
                )
            }
            LogInterval::TwelveHour => {
                let start_hour = (now.hour() / 12) * 12;
                let end_hour = (start_hour + 12) % 24;
                format!(
                    "{}-{:02}h-{:02}h",
                    now.format("%Y-%m-%d"),
                    start_hour,
                    end_hour
                )
            }
            LogInterval::OneDay => {
                format!("{}-00h-24h", now.format("%Y-%m-%d"))
            }
        }
    }
}

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

impl LogLevel {
    // Helper function to extract log level from message
    fn from_message(message: &str) -> Option<LogLevel> {
        if message.contains("ℹ") {
            Some(LogLevel::Info)
        } else if message.contains("⚠") {
            Some(LogLevel::Warn)
        } else if message.contains("✖") {
            Some(LogLevel::Error)
        } else if message.contains("✔") {
            Some(LogLevel::Success)
        } else if message.contains("⁂") {
            Some(LogLevel::Debug)
        } else {
            None
        }
    }
}

pub struct Logger {
    base_path: PathBuf,
    log_interval: LogInterval,
    log_levels: Vec<LogLevel>,
}

impl Logger {
    pub fn new<P: Into<PathBuf>>(base_path: P, log_interval: LogInterval) -> std::io::Result<Self> {
        let base_path = base_path.into();
        fs::create_dir_all(&base_path)?;
        Ok(Logger {
            base_path,
            log_interval,
            log_levels: vec![
                LogLevel::Debug,
                LogLevel::Info,
                LogLevel::Warn,
                LogLevel::Error,
                LogLevel::Success,
            ],
        })
    }

    /// Clear all log levels
    pub fn clear_log_levels(&mut self) {
        self.log_levels.clear();
    }

    /// Add the types of logs to be saved to log files.
    pub fn add_log_level(&mut self, log_level: LogLevel) {
        self.log_levels.push(log_level);
    }

    fn get_log_file(&self) -> std::io::Result<File> {
        let now = Local::now();
        let timestamp = self.log_interval.get_file_timestamp(now);
        let file_name = format!("{}.log", timestamp);
        let file_path = self.base_path.join(file_name);

        OpenOptions::new().create(true).append(true).open(file_path)
    }

    pub fn log(&self, message: &str) -> std::io::Result<()> {
        // Check if this message's log level is in our allowed levels
        if let Some(level) = LogLevel::from_message(message) {
            if self.log_levels.contains(&level) {
                let mut file = self.get_log_file()?;
                let cleaned_message = strip_ansi_codes(message);
                file.write_all(cleaned_message.as_bytes())?;
                file.write_all(b"\n")?;
            }
        }
        Ok(())
    }
}