Rust分布式追踪库tracing-distributed使用指南

概述

tracing-distributed是基于Rust tracing生态系统的分布式追踪库，主要用于实现跨服务调用链监控和性能分析。它扩展了标准tracing库的功能，为分布式系统提供了端到端的请求追踪能力。

主要特性

• 跨服务调用链追踪
• 上下文传播支持
• 性能开销低
• 兼容主流追踪后端
• 支持灵活的采样策略

完整示例代码

下面是一个完整的示例，展示如何使用tracing-distributed实现分布式追踪：

// 1. 添加依赖
/*
[dependencies]
tracing = "0.1"
tracing-distributed = "0.2"
tracing-subscriber = { version = "0.3", features = ["json"] }
reqwest = "0.11"
tokio = { version = "1.0", features = ["full"] }
*/

use tracing::{info_span, instrument};
use tracing_distributed::{DistributedTracer, Propagation, propagate};
use tracing_subscriber::prelude::*;
use std::time::Duration;
use reqwest::{Request, Response, header::HeaderMap};
use tokio::time::sleep;

// 模拟Request和Response类型
#[derive(Debug)]
struct Request {
    method: String,
    path: String,
    headers: HeaderMap,
}

#[derive(Debug)]
struct Response {
    status: u16,
}

impl Response {
    fn new() -> Self {
        Response { status: 200 }
    }
}

#[derive(Debug)]
enum Error {
    Reqwest(String),
}

// 初始化追踪系统
fn init_tracing() {
    let tracer = DistributedTracer::new()
        .with_propagation(Propagation::B3) // 使用B3传播格式
        .with_service_name("my-service");
    
    tracing_subscriber::registry()
        .with(tracer)
        .init();
}

// 处理请求的函数
#[instrument]
async fn handle_request(request: Request) -> Result<Response, Error> {
    // 从请求头中提取上下文
    let parent_ctx = propagate::extract_from_headers(&request.headers);
    
    // 创建子span
    let span = info_span!("request_processing", 
        http.method = %request.method,
        http.path = %request.path
    );
    
    // 在上下文中执行
    let _guard = span.set_parent(&parent_ctx).enter();
    
    // 模拟处理逻辑
    sleep(Duration::from_millis(50)).await;
    
    // 调用下游服务
    call_downstream_service("http://example.com/api").await?;
    
    Ok(Response::new())
}

// 调用下游服务的函数
#[instrument]
async fn call_downstream_service(url: &str) -> Result<(), Error> {
    let client = reqwest::Client::new();
    
    // 创建请求并注入追踪上下文
    let mut request = client.get(url);
    propagate::inject_into_headers(&mut request);
    
    // 发送请求
    let response = request.send().await
        .map_err(|e| Error::Reqwest(e.to_string()))?;
    
    // 模拟处理响应
    sleep(Duration::from_millis(30)).await;
    
    Ok(())
}

// 自定义采样器
struct CustomSampler;

impl tracing_distributed::Sampler for CustomSampler {
    fn sample(&self, context: &tracing::span::Context) -> tracing_distributed::SamplingDecision {
        // 只采样根span和带有特定标签的span
        if context.is_root() {
            tracing_distributed::SamplingDecision::RecordAndSample
        } else if context.has_field("http.method") {
            tracing_distributed::SamplingDecision::RecordAndSample
        } else {
            tracing_distributed::SamplingDecision::RecordOnly
        }
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化追踪
    init_tracing();
    
    // 模拟请求
    let mut headers = HeaderMap::new();
    let request = Request {
        method: "GET".to_string(),
        path: "/api/test".to_string(),
        headers,
    };
    
    // 处理请求
    let _ = handle_request(request).await?;
    
    Ok(())
}

最佳实践说明

1. 服务入口点：在服务入口处创建根span，如HTTP请求处理函数
2. 关键操作：为数据库查询、外部API调用等关键操作创建子span
3. 上下文传播：确保在跨服务调用时正确传播上下文
4. 采样策略：根据业务需求定制采样策略，平衡追踪数据和系统性能
5. 标签命名：使用一致的命名规范，如http.method、db.query等

性能分析扩展

可以通过添加metrics来增强性能监控：

use tracing_distributed::metrics;

#[instrument]
async fn expensive_operation() {
    let start = std::time::Instant::now();
    
    // 模拟耗时操作
    sleep(Duration::from_millis(100)).await;
    
    // 记录耗时
    metrics::histogram!("operation.duration", start.elapsed());
    metrics::counter!("operation.count", 1);
    
    // 记录错误率
    metrics::gauge!("operation.in_progress", -1f64);
}