mho 0.1.0

A Rust port of ShellCrash - A tool for managing proxy cores like Clash/Mihomo/SingBox
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

// Logging infrastructure for the Mho application

use crate::config::get_log_dir;
use crate::error::{MhoError, Result};
use std::path::PathBuf;
use std::sync::{Arc, Mutex, OnceLock};

mod file_appender;
mod formatter;

pub use file_appender::FileAppender;
pub use formatter::LogFormatter;

/// Log level enumeration
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum LogLevel {
    Trace = 0,
    Debug = 1,
    Info = 2,
    Warn = 3,
    Error = 4,
}

impl LogLevel {
    pub fn as_str(&self) -> &'static str {
        match self {
            LogLevel::Trace => "TRACE",
            LogLevel::Debug => "DEBUG",
            LogLevel::Info => "INFO",
            LogLevel::Warn => "WARN",
            LogLevel::Error => "ERROR",
        }
    }
}

/// Configuration for the logging system
#[derive(Debug, Clone)]
pub struct LogConfig {
    pub log_dir: PathBuf,
    pub log_level: LogLevel,
    pub max_file_size: u64,
}

impl Default for LogConfig {
    fn default() -> Self {
        Self {
            log_dir: get_log_dir(),
            log_level: LogLevel::Info,
            max_file_size: 1024 * 1024, // 1MB
        }
    }
}

/// Global logger instance
pub struct Logger {
    config: LogConfig,
    appender: Arc<Mutex<FileAppender>>,
}

impl Logger {
    fn new(config: LogConfig) -> Result<Self> {
        let appender = FileAppender::new(config.log_dir.clone(), config.max_file_size)?;

        Ok(Self {
            config,
            appender: Arc::new(Mutex::new(appender)),
        })
    }

    pub fn log(&self, level: LogLevel, module: &str, message: &str) {
        if level < self.config.log_level {
            return;
        }

        let formatted = LogFormatter::format_with_timestamp(level, module, message);

        if let Ok(mut appender) = self.appender.lock() {
            let _ = appender.write_log(level, &formatted);
        }
    }
}

static LOGGER: OnceLock<Arc<Mutex<Option<Logger>>>> = OnceLock::new();

/// Lazily initialise (if needed) and return the global logger cell.
fn logger_cell() -> &'static Arc<Mutex<Option<Logger>>> {
    LOGGER.get_or_init(|| Arc::new(Mutex::new(None)))
}

/// Initialize the logging system with the given configuration
pub fn init_logger(config: LogConfig) -> Result<()> {
    let logger = Logger::new(config)?;

    let cell = logger_cell();
    if let Ok(mut global_logger) = cell.lock() {
        *global_logger = Some(logger);
        Ok(())
    } else {
        Err(MhoError::Log("Failed to acquire logger lock".to_string()))
    }
}

/// Get a reference to the global logger
pub fn get_logger() -> Arc<Mutex<Option<Logger>>> {
    logger_cell().clone()
}

/// Log a message at the specified level
pub fn log(level: LogLevel, module: &str, message: &str) {
    let Some(cell) = LOGGER.get() else { return };
    if let Ok(logger_guard) = cell.lock()
        && let Some(logger) = logger_guard.as_ref()
    {
        logger.log(level, module, message);
    }
}

/// Logging macros for convenient use throughout the codebase
#[macro_export]
macro_rules! log_trace {
    ($($arg:tt)*) => {
        $crate::log::log($crate::log::LogLevel::Trace, module_path!(), &format!($($arg)*))
    };
}

#[macro_export]
macro_rules! log_debug {
    ($($arg:tt)*) => {
        $crate::log::log($crate::log::LogLevel::Debug, module_path!(), &format!($($arg)*))
    };
}

#[macro_export]
macro_rules! log_info {
    ($($arg:tt)*) => {
        $crate::log::log($crate::log::LogLevel::Info, module_path!(), &format!($($arg)*))
    };
}

#[macro_export]
macro_rules! log_warn {
    ($($arg:tt)*) => {
        $crate::log::log($crate::log::LogLevel::Warn, module_path!(), &format!($($arg)*))
    };
}

#[macro_export]
macro_rules! log_error {
    ($($arg:tt)*) => {
        $crate::log::log($crate::log::LogLevel::Error, module_path!(), &format!($($arg)*))
    };
}