Go语言请求库可观测性落地指南：如何零侵入注入OpenTelemetry Trace、结构化日志与Prometheus指标（含Gin+req集成示例）

第一章：Go语言请求库可观测性落地总览

在微服务与云原生架构持续演进的背景下，HTTP客户端行为的可观测性已成为系统稳定性保障的关键环节。Go语言标准库net/http虽轻量高效，但默认缺乏请求追踪、指标采集和日志上下文关联能力；直接使用裸http.Client易导致链路断裂、超时归因困难、错误分布模糊等问题。因此，构建具备可观测能力的请求层，需在客户端初始化、请求执行、响应处理等关键路径中注入标准化观测点。

核心可观测维度

• 分布式追踪：为每次请求注入并透传trace-id与span-id，与OpenTelemetry生态对齐
• 指标监控：采集http_client_requests_total（按method、status、host、duration分桶）、http_client_request_duration_seconds等Prometheus兼容指标
• 结构化日志：在请求发起前、响应接收后、错误发生时输出含request_id、url、status_code、duration_ms、error字段的JSON日志

主流实践路径对比

方案	优势	适用场景
go.opentelemetry.io/contrib/instrumentation/net/http/httptrace + 自定义RoundTripper	零依赖、细粒度控制	对性能敏感且需深度定制的场景
github.com/sony/gobreaker + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp	熔断+追踪一体化	需要弹性保障与链路追踪结合的生产环境
基于resty/v2封装可观测中间件	开箱即用、支持重试/拦截器/日志钩子	快速落地、团队熟悉Resty生态

快速启用OpenTelemetry追踪示例

import (
    "net/http"
    "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
    "go.opentelemetry.io/otel"
)

// 构建可观测HTTP客户端：自动注入trace context并上报span
client := &http.Client{
    Transport: otelhttp.NewTransport(http.DefaultTransport),
}

// 发起请求时，otelhttp.RoundTripper自动将当前span context写入Header
req, _ := http.NewRequest("GET", "https://api.example.com/users", nil)
resp, err := client.Do(req)
if err != nil {
    // 错误自动关联span，可追溯至上游调用链
}

该方案无需修改业务请求逻辑，仅替换http.Client.Transport即可获得全链路追踪能力，是可观测性落地的最小可行起点。

第二章：OpenTelemetry Trace 零侵入注入实战

2.1 OpenTelemetry Go SDK 核心模型与请求链路生命周期分析

OpenTelemetry Go SDK 的核心围绕 Tracer、Span、Context 和 Propagator 四大抽象构建，共同支撑分布式请求的可观测性。

Span 生命周期关键阶段

• Start: 创建 Span 并注入上下文（如 trace.SpanContext）
• Active: 记录事件、属性、状态码（span.SetStatus()）
• End: 自动计算耗时、上报至 Exporter（触发 span.End() 后不可修改）

ctx, span := tracer.Start(context.Background(), "api.handler")
defer span.End() // 必须显式调用，否则 Span 不会结束并上报
span.SetAttributes(attribute.String("http.method", "GET"))

tracer.Start() 返回带 Span 的新 context.Context；defer span.End() 确保资源及时释放；SetAttributes() 以键值对形式注入结构化元数据，支持后续查询与过滤。

请求链路传播机制

组件	作用
TextMapPropagator	在 HTTP Header 中注入/提取 traceparent
B3Propagator	兼容 Zipkin 生态的 X-B3-TraceId 传递

graph TD
    A[Client Request] -->|inject traceparent| B[HTTP Header]
    B --> C[Server Handler]
    C -->|extract & link| D[New Span as Child]

2.2 基于 http.RoundTripper 的无侵入 Trace 注入原理与封装实践

HTTP 客户端链路追踪的核心在于拦截请求生命周期，而 http.RoundTripper 是 http.Client 发起实际网络调用的唯一可插拔接口，天然适合作为 Trace 注入切面。

为什么选择 RoundTripper？

• 无需修改业务代码（零侵入）
• 覆盖所有 http.Client.Do() 调用（包括 SDK 内部 HTTP 请求）
• 可统一注入 trace-id、span-id 和 X-B3-* 等传播头

封装示例：TracingRoundTripper

type TracingRoundTripper struct {
    base http.RoundTripper
    tracer trace.Tracer
}

func (t *TracingRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
    ctx := req.Context()
    span := t.tracer.Start(ctx, "http.client.request") // 自动继承父 span
    defer span.End()

    // 注入 W3C TraceContext 或 B3 headers
    carrier := propagation.HeaderCarrier(req.Header)
    t.tracer.Extract(ctx, carrier) // 读取上游 trace 上下文
    t.tracer.Inject(span.Context(), carrier) // 向下游透传

    return t.base.RoundTrip(req.WithContext(span.Context()))
}

逻辑分析：该实现将 span 绑定到 req.Context()，确保后续中间件/Handler 可延续同一 trace 上下文；propagation.HeaderCarrier 封装 header 读写，兼容 OpenTelemetry 标准；t.base 保留原始传输能力，满足可组合性。

关键参数说明

字段	类型	作用
base	http.RoundTripper	底层真实传输器（如 http.DefaultTransport）
tracer	trace.Tracer	OpenTelemetry 兼容 tracer 实例
carrier	propagation.TextMapCarrier	header 传播载体，解耦序列化逻辑

graph TD
    A[Client.Do] --> B[TracingRoundTripper.RoundTrip]
    B --> C[Start Span]
    C --> D[Inject Trace Headers]
    D --> E[base.RoundTrip]
    E --> F[Response]
    F --> G[End Span]

2.3 req 库自定义 Transport 集成 OTel Tracer 的完整实现

为实现 HTTP 客户端请求的端到端链路追踪，需将 OpenTelemetry Tracer 注入 req 库底层 Transport 层。

自定义 Transport 构造逻辑

继承 req.Transport，重写 RoundTrip 方法，在发起请求前注入 span 上下文：

type TracedTransport struct {
    base http.RoundTripper
    tracer trace.Tracer
}

func (t *TracedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    ctx, span := t.tracer.Start(req.Context(), "http.client.request")
    defer span.End()

    // 将 span context 注入 HTTP headers
    propagator := otel.GetTextMapPropagator()
    propagator.Inject(ctx, propagation.HeaderCarrier(req.Header))

    return t.base.RoundTrip(req)
}

逻辑说明：req.Context() 提供原始上下文；tracer.Start() 创建子 span 并自动关联父 span；propagator.Inject() 将 traceparent 等字段写入 req.Header，确保服务端可继续链路。

关键参数对照表

参数	作用	OTel 对应组件
req.Context()	携带上游 span context	context.Context
trace.Tracer	创建并管理 span 生命周期	otel.Tracer("req-client")
HeaderCarrier	实现 TextMapCarrier 接口用于 header 透传	propagation.HeaderCarrier

链路注入流程（mermaid）

graph TD
    A[req.Do] --> B[TracedTransport.RoundTrip]
    B --> C[tracer.Start]
    C --> D[propagator.Inject]
    D --> E[base.RoundTrip]
    E --> F[HTTP Server 接收 traceparent]

2.4 Gin 中间件与客户端请求的 Span 关联策略（parent-child 与 follow-from）

Gin 中间件是 OpenTracing / OpenTelemetry 上下文注入的关键入口点。为实现精确的分布式链路追踪，需根据调用语义选择合适的 Span 关系模型。

parent-child 模式（默认同步调用）

适用于服务端主动发起子调用（如 HTTP Client 请求下游服务）：

func tracingMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        span, ctx := tracer.StartSpanFromContext(
            c.Request.Context(), // ← 从 HTTP 请求上下文提取 traceID & spanID
            "handle-request",
            opentracing.ChildOf(c.Request.Context().Value(opentracing.SpanContextKey).(opentracing.SpanContext)),
        )
        defer span.Finish()
        c.Request = c.Request.WithContext(ctx) // 注入新 Span 上下文
        c.Next()
    }
}

ChildOf 显式声明父子依赖：子 Span 的 parent_id 继承自父 Span，形成严格时序因果链；c.Request.Context() 提供初始 SpanContext，确保跨中间件/Handler 连续性。

follow-from 模式（异步/消息场景）

适用于事件驱动或回调场景（如 MQ 消费、Webhook 响应），不构成控制流依赖：	关系类型	语义含义	OpenTracing API	是否传播 parent_id
ChildOf	控制流嵌套调用	opentracing.ChildOf(sc)	是
FollowsFrom	异步触发、无阻塞依赖	opentracing.FollowsFrom(sc)	否（仅共享 trace_id）

graph TD
    A[Client Request] -->|HTTP| B[Gin Handler]
    B --> C[DB Query]:::child
    B --> D[Async Notification]:::follow
    classDef child fill:#4CAF50,stroke:#388E3C;
    classDef follow fill:#2196F3,stroke:#0D47A1;

2.5 跨服务 Context 透传与 B3/TraceContext 协议兼容性验证

在微服务链路追踪中，跨进程传递 traceId、spanId 和采样标志是实现全链路可观测性的基础。B3（Zipkin）与 W3C TraceContext 是当前主流的两种传播协议，二者字段语义高度重叠但格式与大小写约定不同。

协议字段映射关系

B3 Header	TraceContext Header	说明
X-B3-TraceId	traceparent	后者含 version+traceId+spanId+flags
X-B3-SpanId	—（内嵌于 traceparent）	TraceContext 不单独暴露 spanId
X-B3-Sampled	tracestate（可选）	sampled=1 需转为 traceparent flags 字段第1位

自动协议桥接代码示例

public class B3ToTraceContextBridge {
  public static String toTraceParent(String b3TraceId, String b3SpanId) {
    // B3 traceId/spanId 为16进制字符串，需补零至32/16位
    String tid = Strings.padStart(b3TraceId, 32, '0').toLowerCase();
    String sid = Strings.padStart(b3SpanId, 16, '0').toLowerCase();
    return String.format("00-%s-%s-01", tid, sid); // flags=01 → sampled=true
  }
}

逻辑分析：该方法将 B3 的独立 header 映射为 W3C traceparent 格式（version-traceid-spanid-flags）。flags=01 表示采样开启；padStart 确保长度合规，避免解析失败。

上下文透传流程

graph TD
  A[Service A] -->|inject B3 headers| B[HTTP Client]
  B -->|propagate traceparent + tracestate| C[Service B]
  C -->|extract & normalize| D[Tracer SDK]

第三章：结构化日志与请求上下文融合

3.1 zerolog/logrus 结构化日志设计原则与 HTTP 请求字段建模

结构化日志的核心是语义明确、机器可解析、字段可索引。HTTP 请求日志需捕获可观测性关键维度：method, path, status, latency, user_id, trace_id。

必选字段建模规范

• req_id：全局唯一请求标识（如 X-Request-ID）
• client_ip：真实客户端 IP（需穿透代理解析 X-Forwarded-For）
• user_agent：精简提取设备/OS/浏览器类型，避免原始字符串膨胀

zerolog 字段注入示例

log.Info().
    Str("req_id", r.Header.Get("X-Request-ID")).
    Str("method", r.Method).
    Str("path", r.URL.Path).
    Int("status", statusCode).
    Dur("latency", time.Since(start)).
    Str("user_id", userIDFromCtx(r.Context())).
    Msg("http_request_complete")

此写法避免字符串拼接，所有字段以键值对原生序列化为 JSON；Dur 自动转为纳秒级整数，兼容时序数据库聚合；userIDFromCtx 确保从 context 安全提取，不依赖 cookie 或 header 重复解析。

字段	类型	是否索引	说明
req_id	string	✅	链路追踪根 ID
latency	int64	✅	单位：纳秒，支持 P99 计算
user_agent	string	❌	建议额外提取 ua_os 等标签字段

graph TD
    A[HTTP Request] --> B{Parse Headers}
    B --> C[Extract req_id, client_ip]
    B --> D[Enrich user_id from JWT]
    C --> E[Log with zerolog]
    D --> E

3.2 req.Request/req.Response 生命周期钩子中自动注入 trace_id、span_id、req_id

在 HTTP 请求处理链路中，通过中间件拦截 req.Request 和 req.Response 的生命周期钩子（如 BeforeRequest、AfterResponse），可实现分布式追踪上下文的无侵入注入。

注入时机与顺序

• BeforeRequest：生成 trace_id（全局唯一）、span_id（当前操作）、req_id（请求级短标识）
• AfterResponse：透传至响应头（如 X-Trace-ID、X-Span-ID）

示例中间件代码

func TraceIDMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 从 header 或新生成 trace_id/span_id/req_id
        traceID := r.Header.Get("X-Trace-ID")
        if traceID == "" {
            traceID = uuid.New().String()
        }
        spanID := uuid.New().String()
        reqID := fmt.Sprintf("req-%d", time.Now().UnixNano()%100000)

        // 注入到 context 与 request header
        ctx := context.WithValue(r.Context(), "trace_id", traceID)
        r = r.WithContext(ctx)
        r.Header.Set("X-Trace-ID", traceID)
        r.Header.Set("X-Span-ID", spanID)
        r.Header.Set("X-Req-ID", reqID)

        next.ServeHTTP(w, r)
    })
}

逻辑分析：该中间件在请求进入时统一生成/继承追踪 ID，并写入 r.Context() 供下游服务获取；同时设置响应头，确保调用链路可追溯。req_id 使用时间戳哈希降低冲突概率，兼顾可读性与性能。

字段	生成策略	用途
trace_id	全局唯一 UUID	标识一次完整分布式调用
span_id	当前操作唯一 UUID	标识单个服务内的执行片段
req_id	时间哈希（轻量级）	日志快速关联原始请求

graph TD
    A[HTTP Request] --> B{BeforeRequest Hook}
    B --> C[生成/继承 trace_id/span_id/req_id]
    C --> D[注入 Context & Headers]
    D --> E[业务 Handler]
    E --> F{AfterResponse Hook}
    F --> G[透传至 Response Headers]

3.3 Gin 全局日志中间件与客户端日志上下文一致性对齐

为实现服务端日志与前端追踪ID（如 X-Request-ID）严格对齐，需在 Gin 全局中间件中注入统一上下文。

日志上下文注入中间件

func LogContextMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        reqID := c.GetHeader("X-Request-ID")
        if reqID == "" {
            reqID = uuid.New().String()
        }
        // 将请求ID注入gin.Context与zap.Fields
        c.Set("req_id", reqID)
        c.Next()
    }
}

逻辑分析：该中间件优先读取客户端透传的 X-Request-ID；若缺失则自动生成 UUID，确保每个请求拥有唯一、可跨系统传递的标识。c.Set() 使 ID 可被后续 handler 和日志模块安全获取。

关键字段映射表

客户端 Header	服务端 Context Key	日志字段名
X-Request-ID	"req_id"	request_id
X-Trace-ID	"trace_id"	trace_id
X-User-ID	"user_id"	user_id

请求生命周期同步示意

graph TD
A[Client] -->|X-Request-ID: abc123| B(Gin Middleware)
B --> C[Handler]
C --> D[Zap Logger]
D -->|log fields: {request_id:“abc123”}| E[ELK/SLS]

第四章：Prometheus 指标采集体系构建

4.1 HTTP 客户端核心指标定义：requests_total、request_duration_seconds、errors_total

Prometheus 生态中，HTTP 客户端监控依赖三个基础指标协同刻画请求生命周期：

指标语义与用途

• requests_total：计数器（Counter），累计所有 HTTP 请求次数，按 method、status_code、host 等标签维度切分
• request_duration_seconds：直方图（Histogram），记录请求耗时分布，自动生成 _bucket、_sum、_count 子指标
• errors_total：独立计数器，专用于捕获非 2xx/3xx 响应（或业务自定义错误逻辑），提升告警灵敏度

典型直方图配置示例

# client_metrics.yaml
- name: "http_client_request_duration_seconds"
  help: "HTTP client request latency in seconds."
  type: histogram
  buckets: [0.01, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0]

该配置生成 8 个累积桶（如 http_client_request_duration_seconds_bucket{le="0.1"}），配合 _sum 可计算平均延迟，_count 与 requests_total 交叉验证数据完整性。

指标名	类型	核心标签	聚合建议
requests_total	Counter	method, status_code, url_path	rate(requests_total[5m])
request_duration_seconds_sum	Counter	同上	rate(...) / rate(..._count)
errors_total	Counter	error_type, method	irate(errors_total[1m]) > 0

graph TD
    A[HTTP Request] --> B{Response Status}
    B -->|2xx/3xx| C[+1 to requests_total]
    B -->|4xx/5xx| D[+1 to errors_total]
    A --> E[Observe latency → request_duration_seconds]

4.2 基于 req.Hook 实现细粒度指标打点（按 method、host、status_code、error_type 维度）

req.Hook 是高性能 HTTP 客户端 req 库提供的生命周期钩子机制，可在请求发起前、响应接收后、错误发生时注入可观测性逻辑。

指标维度设计

• method: req.Method() 提取 GET/POST 等
• host: 从 req.URL.Host 解析，标准化为 api.example.com
• status_code: resp.StatusCode（响应存在时）
• error_type: 分类 net.Error、*url.Error、context.DeadlineExceeded 等

打点实现示例

req.AddHook(&req.Hook{
    After: func(h *req.HookContext) error {
        tags := map[string]string{
            "method":      h.Req.Method,
            "host":        h.Req.URL.Host,
            "status_code": strconv.Itoa(h.Resp.StatusCode),
            "error_type":  getErrorType(h.Err),
        }
        metrics.Counter("http.client.requests").With(tags).Inc()
        return nil
    },
})

逻辑说明：After 钩子在响应返回或错误抛出后统一执行；h.Resp 和 h.Err 互斥，需用 h.Resp != nil 判断状态码有效性；getErrorType() 对 nil 错误返回 "none"，确保标签完整性。

维度组合效果

method	host	status_code	error_type	count
GET	api.example.com	200	none	1248
POST	auth.internal	0	context.Canceled	37

4.3 Gin 服务端与 req 客户端指标协同建模与 service-level objective（SLO）对齐

为实现端到端 SLO 对齐，需将 Gin 服务端的 http_request_duration_seconds 与 req 客户端的 http_client_request_latency_seconds 在统一标签体系下关联。

数据同步机制

通过 OpenTelemetry SDK 注入共用 trace ID 与语义化标签（如 slo_target="99.5%", service_name="auth-api"），确保两端指标可按 trace_id + span_id 联合下钻。

指标映射表

客户端指标	服务端指标	对齐维度
req_http_duration_ms{op="login"}	gin_http_request_duration_seconds{handler="LoginHandler"}	op ≡ handler, status_code

// Gin 中注入 SLO 关键标签
r.Use(otelmiddleware.NewMiddleware("auth-api",
    otelmiddleware.WithMeterProvider(mp),
    otelmiddleware.WithServerName("auth-api"),
    otelmiddleware.WithAttributes(
        attribute.String("slo.target", "99.5%"),
        attribute.String("slo.budget", "0.005"),
    ),
))

该配置使每个 HTTP span 自动携带 slo.target 属性，供 Prometheus 采集后与 req 客户端指标通过 slo.target 标签 join，支撑 SLO 计算（如 rate(http_client_request_latency_seconds_count{code="2xx",slo_target="99.5%"}[7d]) / rate(http_client_request_latency_seconds_count[7d])）。

graph TD A[req Client] –>|trace_id + slo.target| B[OTel Collector] C[Gin Server] –>|same trace_id + slo.target| B B –> D[Prometheus] D –> E[SLO Calculator]

4.4 指标采集器注册、GaugeVec/Summary 初始化及 Prometheus Exporter 配置实践

指标注册与向量化初始化

使用 prometheus.NewGaugeVec 和 prometheus.NewSummary 构建可标签化指标：

// 定义带 label 的 GaugeVec：监控 HTTP 请求延迟（毫秒）
httpLatency = prometheus.NewGaugeVec(
    prometheus.GaugeOpts{
        Name: "http_request_duration_ms",
        Help: "HTTP request duration in milliseconds",
    },
    []string{"method", "status_code"},
)

// Summary 类型：记录请求处理时间分布
httpSummary = prometheus.NewSummary(
    prometheus.SummaryOpts{
        Name:       "http_request_duration_seconds",
        Help:       "Latency distribution of HTTP requests",
        Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
    },
)

GaugeVec 支持多维标签动态打点，Summary 自动计算分位数；二者均需通过 prometheus.MustRegister() 注册至默认注册表。

Exporter 启动配置

启动内置 HTTP handler：

http.Handle("/metrics", promhttp.Handler())
log.Fatal(http.ListenAndServe(":9090", nil))

组件	用途
GaugeVec	实时状态值（如并发连接数）
Summary	请求延迟分布（含 quantile 计算）
promhttp	标准化 /metrics 端点暴露

graph TD A[定义 GaugeVec/Summary] –> B[MustRegister 注册] B –> C[HTTP Handler 暴露 /metrics] C –> D[Prometheus Server 抓取]

第五章：全链路可观测性效果验证与生产建议

效果验证方法论：黄金信号+业务指标双轨校验

在某电商大促压测场景中，团队将SLO（Service Level Objective）拆解为四类黄金信号：延迟（P95

生产环境灰度验证路径

采用三阶段渐进式验证策略：

阶段	范围	观测重点	持续时间
Alpha	2台边缘网关节点	OpenTelemetry Collector 吞吐稳定性、采样丢包率	72 小时
Beta	订单域全部 Pod（含主备集群）	跨服务 Span 上下文透传完整性、日志-指标-链路三者 traceID 关联率	5 天
Gamma	全链路（含第三方支付回调）	异步消息队列（RocketMQ）消费延迟追踪、DB 连接池等待时间聚合准确性	14 天

关键配置陷阱与规避方案

在 Kubernetes 环境中部署 eBPF 基于的网络观测组件时，曾出现宿主机内核 panic。根本原因为 bpf_probe_read_kernel() 在 5.4.0-105-generic 内核中对 struct sock 的字段偏移计算失效。解决方案如下：

# 升级内核并启用 BTF 支持
sudo apt install linux-image-5.15.0-107-generic linux-tools-5.15.0-107-generic
sudo bpftool btf dump file /sys/kernel/btf/vmlinux format c > vmlinux.h

同时在 DaemonSet 中强制指定 hostNetwork: true 并禁用 net_admin Capabilities，改用 --privileged=false + securityContext.capabilities.add: ["SYS_ADMIN"] 组合。

日志采样策略调优实录

某金融风控服务日均日志量达 42TB，原始全量采集导致 Loki 存储成本激增。通过分析 14 天历史日志，发现 83% 的 ERROR 日志集中于 com.xxx.risk.RuleEngine.execute() 方法，且 92% 的 WARN 日志携带 risk_score > 95 标签。最终落地动态采样规则：

pipeline:
- match:
    selector: '{app="risk-service"} |~ "ERROR|WARN"'
    stages:
    - labels:
        level: ""
        risk_score: ""
    - json:
        expressions:
          level: "level"
          risk_score: "risk_score"
    - drop:
        expression: 'level == "WARN" && (risk_score == "" || risk_score | float < 95)'

告警降噪与闭环机制

构建“可观测性-运维-SRE”三方协同看板，将 Prometheus Alertmanager 的 firing 告警自动同步至企业微信机器人，并附带可点击的 Grafana 临时仪表盘链接（含预设时间范围与 traceID 查询参数）。当某次数据库慢查询告警触发后，值班工程师点击链接即跳转至实时 SQL 执行计划视图，并通过 pg_stat_statements 关联展示该 SQL 的历史执行次数、平均耗时波动曲线及最近一次执行的完整堆栈。

容器逃逸风险下的观测加固

在容器运行时安全加固后，部分 sidecar 注入失败导致 metrics 端点不可达。引入 kube-state-metrics + node-exporter 双源校验机制：当某 Pod 的 /metrics 接口连续 3 次 HTTP 503，立即触发 kubectl get pod -o wide 输出其所在 Node 的磁盘 I/O 等待、cgroup memory.pressure 值，并比对 container_last_seen 时间戳与 node_boot_time_seconds 差值，排除因 kubelet 未上报导致的误判。

生产就绪检查清单

• [x] 所有服务已注入 OpenTelemetry Java Agent（v1.32.0），禁用 otel.instrumentation.common.default-enabled=false
• [x] Loki 日志保留策略按业务等级分层：核心链路 90 天，外围服务 14 天，审计日志单独归档至 S3
• [x] 每个微服务命名空间均部署 prometheus-operator 提供的 ServiceMonitor，target 标签包含 env=prod 和 team=finance
• [x] 全链路 traceID 已透传至 Kafka 消息头（X-B3-TraceId），消费者端完成 kafka-consumer-groups --describe 与 Jaeger 查询结果交叉验证

flowchart LR
A[用户请求] --> B[API Gateway]
B --> C{是否命中缓存？}
C -->|是| D[返回CDN缓存]
C -->|否| E[调用订单服务]
E --> F[调用库存服务]
F --> G[调用支付服务]
G --> H[异步写入Kafka]
H --> I[风控服务消费]
I --> J[更新ES索引]
J --> K[推送APP推送服务]
K --> L[用户收到通知]
style A fill:#4CAF50,stroke:#388E3C
style L fill:#2196F3,stroke:#0D47A1