secra_logger/

module.rs

//! LoggingModule 实现
//!
//! LoggingModule 是日志系统的 Module 实现，负责初始化日志系统。

use crate::config::LoggingConfig;
use anyhow::{Context as AnyhowContext, Result};
use std::sync::{Arc, Mutex};
use std::fs::OpenOptions;
use tracing_appender::non_blocking;
use tracing_subscriber::{
    layer::SubscriberExt,
    EnvFilter, Registry,
    fmt,
};

/// 日志模块
///
/// LoggingModule 负责初始化日志系统，包括：
/// - 配置 tracing subscriber
/// - 设置文件和控制台输出
/// - 注册 Logger 组件
pub struct LoggingModule {
    /// 文件写入器的 WorkerGuard（必须保持存活）
    _file_guard: Arc<Mutex<Option<non_blocking::WorkerGuard>>>,
}

impl LoggingModule {
    /// 创建新的 LoggingModule
    pub fn new() -> Self {
        Self {
            _file_guard: Arc::new(Mutex::new(None)),
        }
    }
}

impl Default for LoggingModule {
    fn default() -> Self {
        Self::new()
    }
}

impl LoggingModule {
    /// 初始化日志系统
    ///
    /// # 参数
    /// * `config` - 日志配置，如果为 None 则使用默认配置
    pub fn init(&self, config: Option<LoggingConfig>) -> Result<()> {
        // 1. 获取日志配置
        let log_config = config.unwrap_or_else(LoggingConfig::default);
        
        // 2. 生成 logrotate 配置文件（如果启用）
        if let Some(file_config) = &log_config.file {
            if let Some(logrotate_config) = &file_config.logrotate {
                if logrotate_config.enabled {
                    // 生成配置文件（不传 default_path，让 generate_config_file 自动使用当前可执行文件目录）
                    // 如果 logrotate_config.output_path 为 None，会自动使用当前可执行文件目录下的 logrotate/app.conf
                    match logrotate_config.generate_config_file(None) {
                        Ok(path) => {
                            // 使用 println! 因为此时 tracing subscriber 还未初始化
                            println!("Logrotate config generated: {}", path);
                            println!("To test it, run: logrotate -d {}", path);
                        }
                        Err(e) => {
                            // 记录警告但不阻止初始化
                            eprintln!("Warning: Failed to generate logrotate config: {}", e);
                        }
                    }
                }
            }
        }
        
        // 3. 初始化 tracing subscriber
        let (subscriber, file_guard) = build_subscriber(&log_config)
            .context("Failed to build tracing subscriber")?;
        
        // 3. 保存 file_guard（必须保持存活）
        if let Some(guard) = file_guard {
            *self._file_guard.lock().unwrap() = Some(guard);
        }
        
        // 4. 设置全局 subscriber
        // 如果已经设置了全局 subscriber（例如在测试中），尝试设置会失败
        // 在这种情况下，我们仍然继续初始化，因为日志系统已经可用
        match tracing::subscriber::set_global_default(subscriber) {
            Ok(_) => {
                tracing::info!("Logging module initialized");
            }
            Err(e) => {
                // 如果全局 subscriber 已经设置，记录警告但继续
                // 这通常发生在测试环境中，多个测试用例共享同一个进程
                let error_msg = format!("{}", e);
                if error_msg.contains("already been set") {
                    // 使用 println! 而不是 tracing::info!，因为可能已经有其他 subscriber
                    println!("Logging module initialized (using existing subscriber)");
                } else {
                    // 其他错误，返回错误
                    return Err(anyhow::anyhow!("Failed to set global subscriber: {}", e));
                }
            }
        }
        
        Ok(())
    }
    
    /// 关闭日志系统
    ///
    /// 清理资源（WorkerGuard 被 drop 时会等待所有日志写入完成）
    pub fn shutdown(&self) {
        tracing::info!("Logging module shutdown, flushing logs...");
    }
}


/// 构建 tracing subscriber
///
/// 由于 Rust 类型系统的限制，我们需要明确处理每种 layer 组合
/// 使用 boxed() 方法将 layer 转换为 trait object，解决类型推断问题
fn build_subscriber(
    config: &LoggingConfig,
) -> Result<(
    Box<dyn tracing::Subscriber + Send + Sync>,
    Option<non_blocking::WorkerGuard>,
)> {
    // 1. 构建日志过滤器
    let filter = EnvFilter::try_from_default_env()
        .unwrap_or_else(|_| EnvFilter::new(&config.level));
    
    // 2. 构建基础 registry
    let registry = Registry::default().with(filter);
    
    // 3. 根据配置组合不同的 layer
    // 由于类型系统的限制，我们需要明确处理每种组合
    let has_file = matches!(config.output_mode, crate::config::OutputMode::File | crate::config::OutputMode::Both)
        && config.file.as_ref().map(|f| f.enabled).unwrap_or(false);
    let has_console = matches!(config.output_mode, crate::config::OutputMode::Console | crate::config::OutputMode::Both)
        && config.console.as_ref().map(|c| c.enabled).unwrap_or(false);
    
    // 根据组合情况构建 subscriber
    // 使用链式调用，让类型系统自动推断
    match (has_file, has_console) {
        (true, true) => {
            // 文件 + 控制台
            let file_config = config.file.as_ref().unwrap();
            let console_config = config.console.as_ref().unwrap();
            
            // 确保目录存在
            if let Some(parent) = std::path::Path::new(&file_config.path).parent() {
                std::fs::create_dir_all(parent)
                    .with_context(|| format!("Failed to create log directory: {}", parent.display()))?;
            }
            
            // 创建文件写入器
            let file = OpenOptions::new()
                .create(true)
                .append(true)
                .open(&file_config.path)
                .with_context(|| format!("Failed to open log file: {}", file_config.path))?;
            
            let (non_blocking, guard) = non_blocking(file);
            
            // 构建文件层
            let file_layer = fmt::layer()
                .with_writer(non_blocking)
                .json()
                .with_target(true)
                .with_file(true)
                .with_line_number(true)
                .with_ansi(false);
            
            // 构建控制台层
            use std::io;
            let console_layer = fmt::layer()
                .with_writer(io::stdout)
                .json()
                .with_target(true)
                .with_file(true)
                .with_line_number(true)
                .with_ansi(console_config.ansi);
            
            let subscriber = registry
                .with(file_layer)
                .with(console_layer);
            
            Ok((Box::new(subscriber), Some(guard)))
        }
        (true, false) => {
            // 只有文件
            let file_config = config.file.as_ref().unwrap();
            
            // 确保目录存在
            if let Some(parent) = std::path::Path::new(&file_config.path).parent() {
                std::fs::create_dir_all(parent)
                    .with_context(|| format!("Failed to create log directory: {}", parent.display()))?;
            }
            
            // 创建文件写入器
            let file = OpenOptions::new()
                .create(true)
                .append(true)
                .open(&file_config.path)
                .with_context(|| format!("Failed to open log file: {}", file_config.path))?;
            
            let (non_blocking, guard) = non_blocking(file);
            
            // 构建文件层
            let file_layer = fmt::layer()
                .with_writer(non_blocking)
                .json()
                .with_target(true)
                .with_file(true)
                .with_line_number(true)
                .with_ansi(false);
            
            let subscriber = registry.with(file_layer);
            Ok((Box::new(subscriber), Some(guard)))
        }
        (false, true) => {
            // 只有控制台
            let console_config = config.console.as_ref().unwrap();
            
            use std::io;
            let console_layer = fmt::layer()
                .with_writer(io::stdout)
                .json()
                .with_target(true)
                .with_file(true)
                .with_line_number(true)
                .with_ansi(console_config.ansi);
            
            let subscriber = registry.with(console_layer);
            Ok((Box::new(subscriber), None))
        }
        (false, false) => {
            // 没有任何输出层（只有 filter）
            Ok((Box::new(registry), None))
        }
    }
}