如何在使用tracing日志时避免字段重复？

当前痛点：重复字段冗余 #

使用tracing记录日志时，常需要在多次日志调用中重复填写相同的上下文字段（如请求URL、请求ID），写法繁琐且易出错：

let original_url = "https://google.com";
let request_id = 123;

info!("making request", original_url, request_id);

// 发起请求，获取响应

warn!("request failed", original_url, request_id, status_code = response.status_code(), success = false);

理想需求 #

希望能复用上下文字段、动态添加新字段，最终输出的日志将所有相关字段平展到顶层，示例用法：

let myspan = span!(
   tracing::Level::INFO,
   "http_request",
   original_url,
   request_id,
);

info!("making request");

// 发起请求，获取响应

myspan.record("status_code", response.status_code());

myspan.log(tracing::Level::WARN, "request failed", success = false);

期望输出：

{
  "timestamp": "2024-04-17T10:35:17.354371Z",
  "level": "WARN",
  "message": "request failed",
  "success": false,
  "status_code": 500,
  "original_url": "http://google.com",
  "request_id": 123
}

现有span方案的问题 #

直接使用span实现存在诸多限制：

• 必须配置订阅器with_current_span(true)才能显示span字段，但该配置会全局生效，导致所有日志带上冗余span信息
• 即使开启with_current_span(true)，span字段会嵌套在span子对象中，无法直接平展到顶层
• 无法通过record动态添加未提前声明的字段，必须在span定义时用status_code = tracing::field::Empty预留
• 跨await调用时必须使用in_scope管理上下文（该问题影响较小）

更优解决方案 #

方案1：自定义订阅器格式化层，精确控制字段平展 #

通过实现tracing_subscriber::Layer自定义日志格式化逻辑，只对特定名称的span（如http_request）提取并平展字段：

use tracing_subscriber::{fmt, layer::Layer};
use tracing_core::{Event, Subscriber};
use serde_json::{Map, Value};
use chrono::Utc;

struct FlattenHttpSpanLayer;

impl<S: Subscriber + for<'a> tracing_core::registry::LookupSpan<'a>> Layer<S> for FlattenHttpSpanLayer {
    fn on_event(&self, event: &Event<'_>, ctx: tracing_subscriber::layer::Context<'_, S>) {
        let mut fields = Map::new();
        
        // 添加基础日志字段
        fields.insert("message".into(), Value::String(event.message().to_string()));
        fields.insert("level".into(), Value::String(event.metadata().level().to_string()));
        fields.insert("timestamp".into(), Value::String(Utc::now().to_rfc3339()));
        
        // 提取目标span的字段并平展
        if let Some(span) = ctx.lookup_current() {
            if span.name() == "http_request" {
                let mut span_fields = Map::new();
                span.visit_fields(|field| {
                    if let Some(value) = field.value() {
                        span_fields.insert(field.name().into(), Value::String(value.to_string()));
                    }
                    true
                });
                fields.extend(span_fields);
            }
        }
        
        // 输出JSON格式日志
        println!("{}", serde_json::to_string(&fields).unwrap());
    }
}

// 初始化订阅器
tracing_subscriber::registry()
    .with(FlattenHttpSpanLayer)
    .init();

这种方式可精确控制哪些span的字段需要平展，避免全局配置带来的冗余。

方案2：封装上下文结构体+自定义宏，避免重复字段 #

若不想修改订阅器，可定义上下文结构体存储复用字段，配合自定义宏自动注入日志字段：

#[derive(Debug)]
struct RequestCtx {
    original_url: String,
    request_id: u64,
    status_code: Option<u16>,
    success: bool,
}

impl RequestCtx {
    fn new(original_url: &str, request_id: u64) -> Self {
        Self {
            original_url: original_url.to_string(),
            request_id,
            status_code: None,
            success: true,
        }
    }

    fn mark_failed(&mut self, code: u16) {
        self.status_code = Some(code);
        self.success = false;
    }
}

// 自定义宏，自动注入上下文字段
#[macro_export]
macro_rules! req_info {
    ($ctx:expr, $msg:expr) => {
        info!(
            $msg,
            original_url = $ctx.original_url,
            request_id = $ctx.request_id
        );
    };
}

#[macro_export]
macro_rules! req_warn {
    ($ctx:expr, $msg:expr) => {
        warn!(
            $msg,
            original_url = $ctx.original_url,
            request_id = $ctx.request_id,
            status_code = $ctx.status_code,
            success = $ctx.success
        );
    };
}

// 使用示例
let mut ctx = RequestCtx::new("https://google.com", 123);
req_info!(ctx, "making request");

// 发起请求失败后
ctx.mark_failed(500);
req_warn!(ctx, "request failed");

这种方式无需修改tracing底层逻辑，通过封装快速解决重复字段问题，同时支持动态更新字段。

方案3：预声明span字段+自定义格式化 #

若坚持使用span，可提前在span中声明所有可能用到的字段，再通过自定义格式化实现平展：

// 预声明所有可能的字段
let myspan = span!(
   tracing::Level::INFO,
   "http_request",
   original_url,
   request_id,
   status_code = tracing::field::Empty,
   success = tracing::field::Empty,
);

// 进入上下文（跨await用in_scope）
let _guard = myspan.enter();

info!("making request");

// 动态更新字段
myspan.record("status_code", &500);
myspan.record("success", &false);

warn!("request failed");

后续通过类似方案1的自定义格式化层，将span字段平展到顶层即可。

内容的提问来源于stack exchange，提问作者Daniel Porteous