Rust日志记录库free_log_client的使用，高效灵活的日志客户端实现与集成

安装

在项目目录中运行以下Cargo命令：

cargo add free_log_client

或者在Cargo.toml中添加以下行：

free_log_client = "0.5.0"

基本使用示例

use free_log_client::{Logger, LogLevel};

fn main() {
    // 创建日志记录器实例
    let logger = Logger::new();
    
    // 记录不同级别的日志
    logger.log(LogLevel::Info, "Application started");
    logger.log(LogLevel::Debug, "Debugging information");
    logger.log(LogLevel::Warning, "This is a warning");
    logger.log(LogLevel::Error, "An error occurred");
    
    // 也可以使用便捷方法
    logger.info("User logged in");
    logger.debug(format!("Current value: {}", 42));
    logger.warn("Disk space low");
    logger.error("Failed to connect to database");
}

高级配置示例

use free_log_client::{Logger, LogLevel, LogConfig};
use std::path::PathBuf;

fn main() {
    // 创建自定义配置
    let config = LogConfig {
        log_file: Some(PathBuf::from("app.log")),  // 指定日志文件
        max_file_size: 10 * 1024 * 1024,          // 10MB最大文件大小
        max_backups: 5,                           // 保留5个备份文件
        log_to_console: true,                     // 同时在控制台输出
        min_log_level: LogLevel::Debug,           // 最低记录级别为Debug
    };
    
    // 使用配置初始化日志记录器
    let logger = Logger::with_config(config);
    
    // 记录日志
    logger.debug("Detailed debug information");
    logger.info("System initialized successfully");
    
    // 结构化日志记录
    logger.with_fields(vec![
        ("user_id", "12345"),
        ("action", "file_upload"),
    ]).info("User performed action");
}

异步日志记录示例

use free_log_client::{Logger, LogLevel};
use tokio::runtime::Runtime;

async fn async_task(logger: &Logger) {
    logger.info("Starting async task");
    // 模拟一些工作
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    logger.info("Async task completed");
}

fn main() {
    let logger = Logger::new();
    let rt = Runtime::new().unwrap();
    
    rt.block_on(async {
        logger.info("Application started");
        
        let tasks = vec![
            async_task(&logger),
            async_task(&logger),
            async_task(&logger),
        ];
        
        futures::future::join_all(tasks).await;
        
        logger.info("All tasks completed");
    });
}

日志过滤示例

use free_log_client::{Logger, LogLevel, LogFilter};

fn main() {
    let logger = Logger::new()
        .with_filter(LogFilter::new()
            // 只记录来自特定模块的日志
            .allow_module("my_app::database")
            // 排除特定模块的调试日志
            .deny_level_for_module("my_app::network", LogLevel::Debug)
            // 设置全局最低日志级别
            .min_level(LogLevel::Info));
    
    // 这些日志会被记录
    logger.module("my_app::database").info("Connected to DB");
    logger.module("my_app::network").warn("Connection slow");
    
    // 这些日志不会被记录
    logger.module("my_app::network").debug("Packet received");
    logger.module("my_app::utils").info("Utility function called");
}

完整示例demo

下面是一个结合了上述所有功能的完整示例：

use free_log_client::{Logger, LogLevel, LogConfig, LogFilter};
use std::path::PathBuf;
use tokio::runtime::Runtime;

// 异步任务示例
async fn perform_async_operation(logger: &Logger, task_id: i32) {
    logger.info(&format!("Starting async task {}", task_id));
    tokio::time::sleep(std::time::Duration::from_millis(500)).await;
    logger.debug(&format!("Task {} in progress", task_id));
    tokio::time::sleep(std::time::Duration::from_millis(500)).await;
    logger.info(&format!("Async task {} completed", task_id));
}

fn main() {
    // 创建自定义配置
    let config = LogConfig {
        log_file: Some(PathBuf::from("demo.log")),
        max_file_size: 5 * 1024 * 1024,  // 5MB
        max_backups: 3,
        log_to_console: true,
        min_log_level: LogLevel::Debug,
    };
    
    // 初始化带过滤器的日志记录器
    let logger = Logger::with_config(config)
        .with_filter(LogFilter::new()
            .allow_module("demo::core")
            .deny_level_for_module("demo::network", LogLevel::Debug)
            .min_level(LogLevel::Info));
    
    // 同步日志记录
    logger.module("demo::core").info("Application starting");
    logger.module("demo::network").debug("This debug won't be logged"); // 会被过滤
    logger.module("demo::core").debug("Core debug information");
    
    // 结构化日志
    logger.with_fields(vec![
        ("version", "1.0.0"),
        ("environment", "production"),
    ]).info("System initialized");
    
    // 异步日志记录
    let rt = Runtime::new().unwrap();
    rt.block_on(async {
        let tasks = (1..=3).map(|i| perform_async_operation(&logger, i));
        futures::future::join_all(tasks).await;
        
        logger.module("demo::core").info("All async tasks completed");
    });
    
    // 错误日志示例
    match some_operation() {
        Ok(_) => logger.info("Operation succeeded"),
        Err(e) => logger.error(&format!("Operation failed: {}", e)),
    }
}

fn some_operation() -> Result<(), String> {
    // 模拟可能失败的操作
    Err("Something went wrong".to_string())
}

free_log_client是一个高效灵活的Rust日志记录库，支持多种日志级别、文件输出、异步记录和灵活的过滤配置。通过简单的API，开发者可以轻松集成到各种Rust项目中。