secra_logger/

config.rs

//! 日志配置模型

use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// 日志配置
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LoggingConfig {
    /// 日志级别（trace | debug | info | warn | error）
    #[serde(default = "default_log_level")]
    pub level: String,
    
    /// 日志输出模式（file | console | both）
    #[serde(default = "default_output_mode")]
    pub output_mode: OutputMode,
    
    /// 文件输出配置（output_mode 为 file 或 both 时有效）
    #[serde(default)]
    pub file: Option<LogFileConfig>,
    
    /// 控制台输出配置（output_mode 为 console 或 both 时有效）
    #[serde(default)]
    pub console: Option<LogConsoleConfig>,
    
    /// 是否启用 Request ID 注入
    #[serde(default = "default_true")]
    pub enable_request_id: bool,
    
    /// 日志字段规范化配置
    #[serde(default)]
    pub fields: LogFieldsConfig,
    
    /// Vector 日志收集器配置（可选）
    #[serde(default)]
    pub vector: Option<VectorConfig>,
}

/// 日志输出模式
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum OutputMode {
    /// 只输出到文件
    File,
    /// 只输出到控制台
    Console,
    /// 同时输出到文件和控制台
    Both,
}

/// 文件输出配置
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LogFileConfig {
    /// 日志文件路径（单文件，不滚动）
    pub path: String,
    
    /// 是否启用（默认启用）
    #[serde(default = "default_true")]
    pub enabled: bool,
    
    /// Logrotate 配置（用于日志文件滚动管理）
    #[serde(default)]
    pub logrotate: Option<LogrotateConfig>,
}

/// 控制台输出配置
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LogConsoleConfig {
    /// 是否启用（默认启用）
    #[serde(default = "default_true")]
    pub enabled: bool,
    
    /// 是否使用彩色输出（默认 true）
    #[serde(default = "default_true")]
    pub ansi: bool,
}

/// 日志字段规范化配置
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LogFieldsConfig {
    /// 是否启用字段规范化
    #[serde(default = "default_true")]
    pub enabled: bool,
    
    /// 字段映射规则（可选）
    #[serde(default)]
    pub mappings: HashMap<String, String>,
}

impl Default for LogFieldsConfig {
    fn default() -> Self {
        Self {
            enabled: default_true(),
            mappings: HashMap::new(),
        }
    }
}

/// Logrotate 配置
/// 
/// Logrotate 是 Linux 系统上的日志轮转工具，用于管理日志文件的滚动、压缩和清理。
/// 此配置用于生成 logrotate 配置文件，以便系统自动管理日志文件。
/// 
/// 支持 logrotate 的完整配置选项，包括轮转策略、压缩、脚本执行、邮件通知等。
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LogrotateConfig {
    /// 是否启用 logrotate（默认 false，需要手动配置）
    #[serde(default = "default_false")]
    pub enabled: bool,
    
    /// 日志文件路径模式（支持通配符，如 /var/log/app/*.log）
    pub path: String,
    
    /// 轮转周期（daily | weekly | monthly | yearly | size）
    /// - daily: 每天轮转
    /// - weekly: 每周轮转
    /// - monthly: 每月轮转
    /// - yearly: 每年轮转
    /// - size: 按大小轮转（需要配合 size 或 maxsize 使用）
    #[serde(default = "default_rotate_period")]
    pub rotate: String,
    
    /// 文件大小限制（当日志文件达到此大小时进行轮转，单位：KB, MB, GB）
    /// 例如：100M, 1G。与 rotate 配合使用，当 rotate 为 size 时优先使用此选项
    #[serde(default)]
    pub size: Option<String>,
    
    /// 最大文件大小（当 rotate 为 size 时使用，单位：KB, MB, GB）
    /// 例如：100M, 1G（已废弃，建议使用 size）
    #[serde(default)]
    pub maxsize: Option<String>,
    
    /// 最小文件大小（小于此大小的文件不进行轮转，单位：KB, MB, GB）
    /// 例如：1M
    #[serde(default)]
    pub minsize: Option<String>,
    
    /// 保留的日志文件数量（超过此数量的旧日志将被删除）
    #[serde(default = "default_rotate_count")]
    pub rotate_count: u32,
    
    /// 最大保留天数（超过此天数的旧日志将被删除）
    /// 例如：30 表示保留 30 天
    #[serde(default)]
    pub maxage: Option<u32>,
    
    /// 起始轮转编号（默认从 1 开始）
    #[serde(default = "default_one")]
    pub start: u32,
    
    /// 是否压缩旧日志文件（默认 true）
    #[serde(default = "default_true")]
    pub compress: bool,
    
    /// 压缩延迟（轮转后 N 个周期再压缩，0 表示立即压缩）
    #[serde(default = "default_zero")]
    pub delaycompress: u32,
    
    /// 压缩命令（默认使用 gzip）
    /// 例如：/usr/bin/bzip2
    #[serde(default)]
    pub compresscmd: Option<String>,
    
    /// 解压缩命令（默认使用 gunzip）
    /// 例如：/usr/bin/bunzip2
    #[serde(default)]
    pub uncompresscmd: Option<String>,
    
    /// 压缩文件扩展名（默认 .gz）
    /// 例如：.bz2, .xz
    #[serde(default = "default_compress_ext")]
    pub compressext: String,
    
    /// 压缩选项（传递给压缩命令的选项）
    /// 例如：-9（最高压缩级别）
    #[serde(default)]
    pub compressoptions: Option<String>,
    
    /// 是否在轮转时创建新文件（默认 true）
    #[serde(default = "default_true")]
    pub create: bool,
    
    /// 新文件的权限（八进制格式，如 0644）
    #[serde(default = "default_file_mode")]
    pub create_mode: String,
    
    /// 新文件的所有者（user:group，如 app:app）
    #[serde(default)]
    pub create_owner: Option<String>,
    
    /// 是否使用 copy 模式（复制原文件后截断，而不是移动）
    /// 适用于无法重命名的日志文件（默认 false）
    #[serde(default = "default_false")]
    pub copy: bool,
    
    /// 是否使用 copytruncate 模式（复制后截断原文件）
    /// 适用于无法重命名或发送信号的应用程序（默认 false）
    #[serde(default = "default_false")]
    pub copytruncate: bool,
    
    /// 是否在轮转后执行脚本（默认 false）
    #[serde(default = "default_false")]
    pub postrotate: bool,
    
    /// 轮转后执行的脚本命令（postrotate 为 true 时使用）
    /// 例如："/bin/kill -HUP `cat /var/run/app.pid 2> /dev/null` 2> /dev/null || true"
    #[serde(default)]
    pub postrotate_script: Option<String>,
    
    /// 是否在轮转前执行脚本（默认 false）
    #[serde(default = "default_false")]
    pub prerotate: bool,
    
    /// 轮转前执行的脚本命令（prerotate 为 true 时使用）
    #[serde(default)]
    pub prerotate_script: Option<String>,
    
    /// 是否在第一次轮转前执行脚本（默认 false）
    #[serde(default = "default_false")]
    pub firstaction: bool,
    
    /// 第一次轮转前执行的脚本命令（firstaction 为 true 时使用）
    #[serde(default)]
    pub firstaction_script: Option<String>,
    
    /// 是否在最后一次轮转后执行脚本（默认 false）
    #[serde(default = "default_false")]
    pub lastaction: bool,
    
    /// 最后一次轮转后执行的脚本命令（lastaction 为 true 时使用）
    #[serde(default)]
    pub lastaction_script: Option<String>,
    
    /// 是否忽略缺失的日志文件（默认 false，缺失文件会报错）
    #[serde(default = "default_false")]
    pub missingok: bool,
    
    /// 是否在日志文件为空时不轮转（默认 false）
    #[serde(default = "default_false")]
    pub notifempty: bool,
    
    /// 是否即使文件为空也轮转（与 notifempty 相反，默认 false）
    #[serde(default = "default_false")]
    pub ifempty: bool,
    
    /// 是否共享脚本（默认 false，每个日志组共享一个脚本）
    #[serde(default = "default_false")]
    pub sharedscripts: bool,
    
    /// 是否使用日期扩展名（默认 false，使用数字扩展名 .1, .2, ...）
    /// 为 true 时使用日期格式，如 .20260114
    #[serde(default = "default_false")]
    pub dateext: bool,
    
    /// 日期扩展名格式（dateext 为 true 时使用）
    /// 默认：%Y%m%d（年月日）
    /// 其他选项：%Y%m%d-%H%M%S（年月日-时分秒）
    #[serde(default = "default_date_format")]
    pub dateformat: String,
    
    /// 旧日志文件目录（可选，用于将旧日志移动到指定目录）
    /// 例如：/var/log/app/archive
    #[serde(default)]
    pub olddir: Option<String>,
    
    /// 是否不使用 olddir（默认 false）
    #[serde(default = "default_false")]
    pub noolddir: bool,
    
    /// 压缩文件扩展名（用于指定压缩后的文件扩展名）
    /// 例如：.log.gz
    #[serde(default)]
    pub extension: Option<String>,
    
    /// 禁止的扩展名列表（这些扩展名的文件不会被轮转）
    /// 例如：["~", ".bak"]
    #[serde(default)]
    pub tabooext: Vec<String>,
    
    /// 以指定用户身份运行脚本（user:group）
    /// 例如：app:app
    #[serde(default)]
    pub su: Option<String>,
    
    /// 是否发送邮件通知（默认 false）
    #[serde(default = "default_false")]
    pub mail: bool,
    
    /// 邮件地址（轮转前发送邮件）
    /// 例如：admin@example.com
    #[serde(default)]
    pub mailfirst: Option<String>,
    
    /// 是否在轮转后发送邮件（默认 false）
    #[serde(default = "default_false")]
    pub maillast: bool,
    
    /// 是否不发送邮件（默认 false）
    #[serde(default = "default_false")]
    pub nomail: bool,
    
    /// 包含其他配置文件
    /// 例如：/etc/logrotate.d/includes
    #[serde(default)]
    pub include: Vec<String>,
    
    /// 是否安全删除文件（使用 shred 命令，默认 false）
    #[serde(default = "default_false")]
    pub shred: bool,
    
    /// 安全删除循环次数（shred 为 true 时使用，默认 0）
    #[serde(default = "default_zero")]
    pub shredcycles: u32,
    
    /// 是否不压缩（与 compress 相反，默认 false）
    #[serde(default = "default_false")]
    pub nocompress: bool,
    
    /// logrotate 配置文件输出路径（可选）
    /// 如果未指定，将使用可执行文件目录下的 logrotate/app.conf
    /// 例如："./logrotate/app.conf" 或 "/etc/logrotate.d/app"
    #[serde(default)]
    pub output_path: Option<String>,
}

impl LogrotateConfig {
    /// 生成 logrotate 配置文件内容
    pub fn to_logrotate_config(&self) -> String {
        let mut config = String::new();
        
        // 日志文件路径
        config.push_str(&format!("{}\n", self.path));
        config.push_str("{\n");
        
        // 轮转周期
        config.push_str(&format!("    {}\n", self.rotate));
        
        // 文件大小限制
        if let Some(size) = &self.size {
            config.push_str(&format!("    size {}\n", size));
        } else if let Some(maxsize) = &self.maxsize {
            config.push_str(&format!("    maxsize {}\n", maxsize));
        }
        
        // 最小文件大小
        if let Some(minsize) = &self.minsize {
            config.push_str(&format!("    minsize {}\n", minsize));
        }
        
        // 保留文件数量
        config.push_str(&format!("    rotate {}\n", self.rotate_count));
        
        // 最大保留天数
        if let Some(maxage) = self.maxage {
            config.push_str(&format!("    maxage {}\n", maxage));
        }
        
        // 起始编号
        if self.start != 1 {
            config.push_str(&format!("    start {}\n", self.start));
        }
        
        // 压缩选项
        if self.nocompress {
            config.push_str("    nocompress\n");
        } else if self.compress {
            config.push_str("    compress\n");
            if self.delaycompress > 0 {
                config.push_str(&format!("    delaycompress {}\n", self.delaycompress));
            }
            if let Some(cmd) = &self.compresscmd {
                config.push_str(&format!("    compresscmd {}\n", cmd));
            }
            if let Some(cmd) = &self.uncompresscmd {
                config.push_str(&format!("    uncompresscmd {}\n", cmd));
            }
            if self.compressext != ".gz" {
                config.push_str(&format!("    compressext {}\n", self.compressext));
            }
            if let Some(opts) = &self.compressoptions {
                config.push_str(&format!("    compressoptions {}\n", opts));
            }
        }
        
        // 文件创建
        if self.create {
            let owner = self.create_owner.as_ref()
                .map(|o| format!(" {}", o))
                .unwrap_or_default();
            config.push_str(&format!("    create {} {}{}\n", 
                self.create_mode, self.create_mode, owner));
        }
        
        // copy 和 copytruncate
        if self.copy {
            config.push_str("    copy\n");
        }
        if self.copytruncate {
            config.push_str("    copytruncate\n");
        }
        
        // 文件处理选项
        if self.missingok {
            config.push_str("    missingok\n");
        }
        if self.notifempty {
            config.push_str("    notifempty\n");
        }
        if self.ifempty {
            config.push_str("    ifempty\n");
        }
        
        // 日期扩展名
        if self.dateext {
            config.push_str("    dateext\n");
            if self.dateformat != "%Y%m%d" {
                config.push_str(&format!("    dateformat {}\n", self.dateformat));
            }
        }
        
        // 旧日志目录
        if let Some(olddir) = &self.olddir {
            config.push_str(&format!("    olddir {}\n", olddir));
        }
        if self.noolddir {
            config.push_str("    noolddir\n");
        }
        
        // 扩展名
        if let Some(ext) = &self.extension {
            config.push_str(&format!("    extension {}\n", ext));
        }
        
        // 禁止的扩展名
        if !self.tabooext.is_empty() {
            config.push_str(&format!("    tabooext {}\n", self.tabooext.join(" ")));
        }
        
        // 共享脚本
        if self.sharedscripts {
            config.push_str("    sharedscripts\n");
        }
        
        // 用户身份
        if let Some(su) = &self.su {
            config.push_str(&format!("    su {}\n", su));
        }
        
        // 邮件选项
        if self.nomail {
            config.push_str("    nomail\n");
        } else if self.mail {
            config.push_str("    mail\n");
        }
        if let Some(addr) = &self.mailfirst {
            config.push_str(&format!("    mailfirst {}\n", addr));
        }
        if self.maillast {
            config.push_str("    maillast\n");
        }
        
        // 包含其他配置
        for include_path in &self.include {
            config.push_str(&format!("    include {}\n", include_path));
        }
        
        // 安全删除
        if self.shred {
            config.push_str("    shred\n");
            if self.shredcycles > 0 {
                config.push_str(&format!("    shredcycles {}\n", self.shredcycles));
            }
        }
        
        // 脚本执行
        if self.firstaction {
            if let Some(script) = &self.firstaction_script {
                config.push_str("    firstaction\n");
                config.push_str(&format!("        {}\n", script));
                config.push_str("    endscript\n");
            }
        }
        
        if self.prerotate {
            if let Some(script) = &self.prerotate_script {
                config.push_str("    prerotate\n");
                config.push_str(&format!("        {}\n", script));
                config.push_str("    endscript\n");
            }
        }
        
        if self.postrotate {
            if let Some(script) = &self.postrotate_script {
                config.push_str("    postrotate\n");
                config.push_str(&format!("        {}\n", script));
                config.push_str("    endscript\n");
            }
        }
        
        if self.lastaction {
            if let Some(script) = &self.lastaction_script {
                config.push_str("    lastaction\n");
                config.push_str(&format!("        {}\n", script));
                config.push_str("    endscript\n");
            }
        }
        
        config.push_str("}\n");
        config
    }
    
    /// 生成并保存 logrotate 配置文件
    /// 
    /// # 参数
    /// * `default_path` - 默认输出路径（当 output_path 未指定时使用）
    ///                     如果为 None，则自动使用当前可执行文件目录下的 logrotate/app.conf
    /// 
    /// # 返回值
    /// * 生成的配置文件路径
    pub fn generate_config_file(&self, default_path: Option<&str>) -> Result<String> {
        if !self.enabled {
            return Err(anyhow::anyhow!("Logrotate is not enabled"));
        }
        
        // 确定输出路径
        let output_path_str: String = if let Some(path) = &self.output_path {
            // 如果配置中指定了 output_path，优先使用
            path.clone()
        } else if let Some(path) = default_path {
            // 如果提供了 default_path 参数，使用它
            path.to_string()
        } else {
            // 否则，自动使用当前可执行文件目录下的 logrotate/app.conf
            let exe_path = std::env::current_exe()
                .context("Failed to get current executable path")?;
            let exe_dir = exe_path.parent()
                .ok_or_else(|| anyhow::anyhow!("Failed to get executable directory"))?;
            let auto_path = exe_dir.join("logrotate").join("app.conf");
            auto_path.to_string_lossy().to_string()
        };
        
        // 创建目录（如果不存在）
        if let Some(parent) = std::path::Path::new(&output_path_str).parent() {
            std::fs::create_dir_all(parent)
                .with_context(|| format!("Failed to create logrotate directory: {}", parent.display()))?;
        }
        
        // 生成配置文件内容
        let config_content = self.to_logrotate_config();
        
        // 写入文件
        std::fs::write(&output_path_str, config_content)
            .with_context(|| format!("Failed to write logrotate config to {}", output_path_str))?;
        
        Ok(output_path_str)
    }
}

/// Vector 日志收集器配置
/// 
/// Vector 是一个高性能的日志、指标和追踪数据收集器。
/// 此配置用于生成 Vector 配置文件，以便将日志发送到各种目标（Loki、Elasticsearch、S3 等）。
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct VectorConfig {
    /// 是否启用 Vector 配置生成（默认 false）
    #[serde(default = "default_false")]
    pub enabled: bool,
    
    /// Vector 配置输出路径（生成的配置文件保存位置）
    #[serde(default = "default_vector_config_path")]
    pub config_path: String,
    
    /// 日志源配置
    #[serde(default)]
    pub source: VectorSourceConfig,
    
    /// 日志转换配置
    #[serde(default)]
    pub transforms: Vec<VectorTransformConfig>,
    
    /// 日志输出目标配置
    #[serde(default)]
    pub sinks: Vec<VectorSinkConfig>,
}

/// Vector 源配置
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct VectorSourceConfig {
    /// 源名称（默认 app_logs）
    #[serde(default = "default_source_name")]
    pub name: String,
    
    /// 日志文件路径（支持通配符，如 logs/*.log）
    pub paths: Vec<String>,
    
    /// 读取模式（beginning | end）
    /// - beginning: 从文件开头读取（适用于新文件）
    /// - end: 从文件末尾读取（适用于已存在的文件）
    #[serde(default = "default_read_from")]
    pub read_from: String,
    
    /// 是否启用多行日志解析（默认 false）
    #[serde(default = "default_false")]
    pub multiline: bool,
    
    /// 多行日志模式（multiline 为 true 时使用）
    /// 例如：r"^\d{4}-\d{2}-\d{2}" 匹配以日期开头的行
    #[serde(default)]
    pub multiline_pattern: Option<String>,
    
    /// 是否忽略未找到的文件（默认 false）
    #[serde(default = "default_false")]
    pub ignore_not_found: bool,
    
    /// 包含的文件模式（glob 模式，默认包含所有匹配的文件）
    #[serde(default = "default_empty_vec")]
    pub include: Vec<String>,
    
    /// 排除的文件模式（glob 模式）
    #[serde(default)]
    pub exclude: Vec<String>,
}

/// Vector 转换配置
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct VectorTransformConfig {
    /// 转换器名称（唯一标识）
    pub name: String,
    
    /// 转换器类型（remap | filter | reduce | sample 等）
    pub transform_type: String,
    
    /// 输入源（来自哪个 source 或 transform）
    pub inputs: Vec<String>,
    
    /// 转换脚本或配置（根据 transform_type 不同而不同）
    /// 对于 remap 类型，这里是 VRL (Vector Remap Language) 脚本
    pub source: Option<String>,
    
    /// 其他配置项（键值对）
    #[serde(default)]
    pub options: HashMap<String, String>,
}

/// Vector 输出目标配置
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct VectorSinkConfig {
    /// 输出目标名称（唯一标识）
    pub name: String,
    
    /// 输出类型（loki | elasticsearch | s3 | http | file | console 等）
    pub sink_type: String,
    
    /// 输入源（来自哪个 transform）
    pub inputs: Vec<String>,
    
    /// 端点 URL（根据 sink_type 不同而不同）
    /// - loki: http://loki:3100
    /// - elasticsearch: http://elasticsearch:9200
    /// - s3: s3://bucket-name/path
    /// - http: http://endpoint:port
    #[serde(default)]
    pub endpoint: Option<String>,
    
    /// 标签配置（用于 Loki 等需要标签的目标）
    #[serde(default)]
    pub labels: HashMap<String, String>,
    
    /// 编码格式（json | text | native）
    #[serde(default = "default_encoding")]
    pub encoding: String,
    
    /// 压缩方式（gzip | snappy | none）
    #[serde(default = "default_compression")]
    pub compression: String,
    
    /// 批量配置
    #[serde(default)]
    pub batch: Option<VectorBatchConfig>,
    
    /// 请求重试配置
    #[serde(default)]
    pub request: Option<VectorRequestConfig>,
    
    /// 其他配置项（键值对）
    #[serde(default)]
    pub options: HashMap<String, String>,
}

/// Vector 批量配置
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct VectorBatchConfig {
    /// 最大批量大小（字节）
    #[serde(default = "default_batch_max_bytes")]
    pub max_bytes: u64,
    
    /// 最大批量事件数
    #[serde(default = "default_batch_max_events")]
    pub max_events: u32,
    
    /// 批量超时时间（秒）
    #[serde(default = "default_batch_timeout")]
    pub timeout_secs: u32,
}

/// Vector 请求配置
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct VectorRequestConfig {
    /// 重试次数
    #[serde(default = "default_retry_attempts")]
    pub retry_attempts: u32,
    
    /// 重试退避时间（秒）
    #[serde(default = "default_retry_backoff")]
    pub retry_backoff_secs: u32,
    
    /// 请求超时时间（秒）
    #[serde(default = "default_request_timeout")]
    pub timeout_secs: u32,
    
    /// 请求速率限制（每秒请求数）
    #[serde(default)]
    pub rate_limit: Option<u32>,
}

// 默认值函数
fn default_false() -> bool {
    false
}

fn default_zero() -> u32 {
    0
}

fn default_one() -> u32 {
    1
}

fn default_rotate_period() -> String {
    "daily".to_string()
}

fn default_rotate_count() -> u32 {
    7
}

fn default_file_mode() -> String {
    "0644".to_string()
}

fn default_date_format() -> String {
    "%Y%m%d".to_string()
}

fn default_compress_ext() -> String {
    ".gz".to_string()
}

fn default_vector_config_path() -> String {
    "vector.toml".to_string()
}

fn default_source_name() -> String {
    "app_logs".to_string()
}

fn default_read_from() -> String {
    "beginning".to_string()
}

fn default_encoding() -> String {
    "json".to_string()
}

fn default_compression() -> String {
    "gzip".to_string()
}

fn default_batch_max_bytes() -> u64 {
    1048576 // 1MB
}

fn default_batch_max_events() -> u32 {
    500
}

fn default_batch_timeout() -> u32 {
    10
}

fn default_retry_attempts() -> u32 {
    5
}

fn default_retry_backoff() -> u32 {
    1
}

fn default_request_timeout() -> u32 {
    30
}

fn default_empty_vec() -> Vec<String> {
    Vec::new()
}

impl Default for VectorSourceConfig {
    fn default() -> Self {
        Self {
            name: default_source_name(),
            paths: vec!["logs/app.log".to_string()],
            read_from: default_read_from(),
            multiline: default_false(),
            multiline_pattern: None,
            ignore_not_found: default_false(),
            include: default_empty_vec(),
            exclude: Vec::new(),
        }
    }
}

// 默认值函数
fn default_log_level() -> String {
    "info".to_string()
}

fn default_output_mode() -> OutputMode {
    OutputMode::File
}

fn default_true() -> bool {
    true
}

impl LoggingConfig {
    /// 验证配置的有效性
    pub fn validate(&self) -> Result<()> {
        // 验证日志级别
        match self.level.as_str() {
            "trace" | "debug" | "info" | "warn" | "error" => {},
            _ => anyhow::bail!("Invalid log level: {}", self.level),
        }
        
        // 验证文件配置
        if matches!(self.output_mode, OutputMode::File | OutputMode::Both) {
            if let Some(file_config) = &self.file {
                if file_config.enabled && file_config.path.is_empty() {
                    anyhow::bail!("Log file path cannot be empty when file output is enabled");
                }
            } else {
                anyhow::bail!("File config is required when output_mode is file or both");
            }
        }
        
        // 验证控制台配置
        if matches!(self.output_mode, OutputMode::Console | OutputMode::Both) {
            if self.console.is_none() {
                anyhow::bail!("Console config is required when output_mode is console or both");
            }
        }
        
        Ok(())
    }
}

impl Default for LoggingConfig {
    fn default() -> Self {
        Self {
            level: default_log_level(),
            output_mode: default_output_mode(),
            file: Some(LogFileConfig {
                path: "logs/app.log".to_string(),
                enabled: true,
                logrotate: None,
            }),
            console: None,
            enable_request_id: true,
            fields: LogFieldsConfig::default(),
            vector: None,
        }
    }
}