Rust结构化日志库slog-bunyan的使用,slog-bunyan为Rust应用提供Bunyan格式的JSON日志记录功能

Rust结构化日志库slog-bunyan的使用

slog-bunyan是一个为Rust应用提供Bunyan格式JSON日志记录功能的库,基于slog-json构建,会输出符合Bunyan定义的JSON日志字段。

安装

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

cargo add slog-bunyan

或者在Cargo.toml中添加:

slog-bunyan = "2.5.0"

使用示例

下面是一个完整的slog-bunyan使用示例:

use slog::{info, o, Drain, Logger};
use slog_bunyan::default;
use std::sync::Mutex;

fn main() {
    // 创建Bunyan格式的日志drain
    let drain = default(std::io::stdout());
    
    // 使用Mutex包装drain以支持线程安全
    let drain = Mutex::new(drain).fuse();
    
    // 创建根logger
    let root_logger = Logger::root(drain, o!("version" => "1.0.0"));
    
    // 创建子logger,添加更多上下文信息
    let log = root_logger.new(o!("component" => "main"));
    
    // 记录结构化日志
    info!(log, "Application started"; 
        "pid" => std::process::id(),
        "config" => "production",
        "thread_count" => 4
    );
    
    // 记录错误日志
    info!(log, "Processing request"; 
        "method" => "GET",
        "path" => "/api/users",
        "status" => 200,
        "duration_ms" => 42
    );
}

输出示例

上面的代码会产生类似这样的JSON格式日志:

{
  "name": "your-app",
  "hostname": "your-host",
  "pid": 12345,
  "level": 30,
  "msg": "Application started",
  "time": "2024-01-05T12:34:56.789Z",
  "v": 0,
  "version": "1.0.0",
  "component": "main",
  "config": "production",
  "thread_count": 4
}

主要特性

  • 输出符合Bunyan日志格式的JSON
  • 支持结构化日志记录
  • 线程安全
  • 可与其他slog drain组合使用
  • 支持自定义字段和上下文

slog-bunyan是构建生产级Rust应用程序日志系统的理想选择,特别是需要与现有Bunyan日志处理工具集成时。

完整示例代码

下面是一个更完整的slog-bunyan使用示例,包含了不同日志级别和自定义配置:

use slog::{debug, error, info, warn, o, Drain, Logger};
use slog_bunyan::{default, with_name};
use std::sync::Mutex;

fn main() {
    // 创建自定义名称的Bunyan logger
    let drain = with_name("my-rust-app", std::io::stdout());
    
    // 使用Mutex包装drain以支持线程安全
    let drain = Mutex::new(drain.fuse());
    
    // 创建根logger并添加全局字段
    let root_logger = Logger::root(
        drain,
        o!(
            "version" => env!("CARGO_PKG_VERSION"),
            "environment" => "production",
            "service" => "api-server"
        )
    );
    
    // 创建子logger用于特定模块
    let http_log = root_logger.new(o!("component" => "http"));
    let db_log = root_logger.new(o!("component" => "database"));
    
    // 记录不同级别的日志
    debug!(http_log, "Debug message"; "detail" => "verbose info");
    info!(http_log, "HTTP request received";
        "method" => "POST",
        "path" => "/users",
        "client_ip" => "192.168.1.1"
    );
    
    warn!(db_log, "Slow query detected";
        "query" => "SELECT * FROM users",
        "duration_ms" => 256
    );
    
    error!(root_logger, "Critical error occurred";
        "error" => "Connection timeout",
        "retry_count" => 3,
        "backtrace" => "..."
    );
    
    // 记录带有嵌套结构的日志
    info!(root_logger, "Application metrics";
        "metrics" => {
            "cpu_usage" => 42.5,
            "memory_mb" => 128,
            "active_connections" => 24
        }
    );
}

完整输出示例

[
  {
    "name": "my-rust-app",
    "hostname": "your-host",
    "pid": 12345,
    "level": 20,
    "msg": "Debug message",
    "time": "2024-01-05T12:34:56.789Z",
    "v": 0,
    "version": "1.0.0",
    "environment": "production",
    "service": "api-server",
    "component": "http",
    "detail": "verbose info"
  },
  {
    "name": "my-rust-app",
    "hostname": "your-host",
    "pid": 12345,
    "level": 30,
    "msg": "HTTP request received",
    "time": "2024-01-05T12:34:56.790Z",
    "v": 0,
    "version": "1.0.0",
    "environment": "production",
    "service": "api-server",
    "component": "http",
    "method": "POST",
    "path": "/users",
    "client_ip": "192.168.1.1"
  },
  {
    "name": "my-rust-app",
    "hostname": "your-host",
    "pid": 12345,
    "level": 40,
    "msg": "Slow query detected",
    "time": "2024-01-05T12:34:56.791Z",
    "v": 0,
    "version": "1.0.0",
    "environment": "production",
    "service": "api-server",
    "component": "database",
    "query": "SELECT * FROM users",
    "duration_ms": 256
  },
  {
    "name": "my-rust-app",
    "hostname": "your-host",
    "pid": 12345,
    "level": 50,
    "msg": "Critical error occurred",
    "time": "2024-01-05T12:34:56.792Z",
    "v": 0,
    "version": "1.0.0",
    "environment": "production",
    "service": "api-server",
    "error": "Connection timeout",
    "retry_count": 3,
    "backtrace": "..."
  },
  {
    "name": "my-rust-app",
    "hostname": "your-host",
    "pid": 12345,
    "level": 30,
    "msg": "Application metrics",
    "time": "2024-01-05T12:34:56.793Z",
    "v": 0,
    "version": "1.0.0",
    "environment": "production",
    "service": "api-server",
    "metrics": {
      "cpu_usage": 42.5,
      "memory_mb": 128,
      "active_connections": 24
    }
  }
]

1 回复

Rust结构化日志库slog-bunyan使用指南

slog-bunyan是一个Rust日志库,它为slog生态系统提供了Bunyan格式的JSON日志记录功能。Bunyan是一种流行的结构化日志格式,特别适合在Node.js生态系统中使用,但通过slog-bunyan也可以在Rust应用中使用。

主要特性

  • 生成符合Bunyan规范的JSON日志
  • slog生态系统无缝集成
  • 支持日志级别、时间戳、主机名等标准字段
  • 可自定义的日志记录格式

使用方法

1. 添加依赖

首先,在Cargo.toml中添加依赖:

[dependencies]
slog = "2"
slog-bunyan = "2"
slog-term = "2"  # 可选,用于终端输出
slog-async = "2"  # 推荐,异步记录器

2. 基本使用示例

use slog::{info, o, Drain};
use slog_bunyan::{default, with_name};
use std::sync::Mutex;

fn main() {
    // 创建Bunyan格式的记录器
    let root_logger = slog::Logger::root(
        Mutex::new(default(std::io::stdout())).map(slog::Fuse),
        o!("version" => "0.1.0", "hostname" => "my-server")
    );
    
    info!(root_logger, "Application started"; "pid" => std::process::id());
    
    // 使用with_name创建带有特定名称的记录器
    let module_logger = root_logger.new(o!("module" => "database"));
    info!(module_logger, "Connected to database"; "connection_time_ms" => 42);
}

3. 异步记录器示例

为了提高性能,推荐使用异步记录器:

use slog::{info, o, Drain};
use slog_bunyan::with_name;
use slog_async::Async;

fn main() {
    let decorator = slog_term::PlainDecorator::new(std::io::stdout());
    let drain = slog_term::FullFormat::new(decorator).build().fuse();
    let drain = Async::new(drain).build().fuse();
    
    let log = slog::Logger::root(
        drain,
        o!("name" => "myapp", "hostname" => "localhost", "pid" => std::process::id())
    );
    
    info!(log, "Application started with async logging");
}

4. 输出示例

上述代码会生成类似以下的JSON日志:

{
  "name": "myapp",
  "hostname": "localhost",
  "pid": 12345,
  "level": 30,
  "msg": "Application started with async logging",
  "time": "2023-05-01T12:34:56.789Z",
  "v": 0
}

高级用法

自定义字段

info!(log, "User logged in"; 
    "user_id" => 42,
    "email" => "user@example.com",
    "ip" => "192.168.1.1"
);

错误记录

match some_operation() {
    Ok(_) => info!(log, "Operation succeeded"),
    Err(e) => error!(log, "Operation failed"; "error" => format!("{}", e)),
}

配置选项

slog-bunyan提供了一些配置选项:

let drain = slog_bunyan::Builder::new()
    .set_name("myapp")
    .set_level(slog::Level::Info)
    .build(std::io::stdout())
    .unwrap();

日志级别

slog-bunyan支持标准的日志级别:

  • critical (50)
  • error (40)
  • warning (30)
  • info (20)
  • debug (10)
  • trace (5)

slog-bunyan是一个强大的工具,可以帮助你在Rust应用中实现结构化日志记录,特别适合需要与现有Bunyan日志处理工具集成的场景。

完整示例代码

下面是一个完整的slog-bunyan使用示例,结合了基本使用和异步记录器:

use slog::{info, error, o, Drain, Logger};
use slog_bunyan::{default, with_name};
use slog_async::Async;
use std::sync::Mutex;

// 数据库操作模拟函数
fn database_operation() -> Result<(), String> {
    // 模拟数据库操作
    Ok(())
}

fn main() {
    // 创建异步Bunyan记录器
    let async_drain = Async::new(
        Mutex::new(default(std::io::stdout())).map(slog::Fuse)
    ).build().fuse();
    
    // 创建根记录器
    let root_logger = Logger::root(
        async_drain,
        o!("version" => "1.0.0", 
           "hostname" => "production-server",
           "pid" => std::process::id())
    );
    
    // 记录应用启动信息
    info!(root_logger, "Application starting up");
    
    // 创建模块专用记录器
    let db_logger = root_logger.new(o!("module" => "database"));
    
    // 记录数据库操作
    match database_operation() {
        Ok(_) => info!(db_logger, "Database operation succeeded"),
        Err(e) => error!(db_logger, "Database operation failed"; "error" => e),
    }
    
    // 记录用户登录信息
    info!(root_logger, "User login";
        "user_id" => 1001,
        "username" => "rustacean",
        "ip" => "10.0.0.1"
    );
    
    // 使用Builder配置记录器
    let custom_logger = {
        let drain = slog_bunyan::Builder::new()
            .set_name("custom-app")
            .set_level(slog::Level::Debug)
            .build(std::io::stdout())
            .unwrap();
            
        Logger::root(Async::new(drain.fuse()).build().fuse(), o!())
    };
    
    info!(custom_logger, "Custom logger message");
}

这个完整示例展示了:

  1. 创建异步Bunyan记录器
  2. 添加全局字段(版本、主机名、进程ID)
  3. 创建模块专用记录器
  4. 记录结构化日志信息
  5. 错误处理日志记录
  6. 使用Builder自定义记录器配置

输出结果会是符合Bunyan格式的JSON日志,包含所有指定的字段和上下文信息。

回到顶部