Go HTTP中间件性能断崖式下跌：从middleware链中defer panic恢复到context.WithTimeout传递的链路污染问题

第一章：Go HTTP中间件性能断崖式下跌的典型现象与根因定位

当Go Web服务在QPS超过2000后响应延迟陡增至200ms以上、P99延迟突破500ms，且CPU使用率未饱和（runtime.mallocgc与net/http.(*conn).serve深度交织。

常见性能黑洞类型

• 同步阻塞型日志中间件：直接调用log.Printf写磁盘，每请求阻塞3–8ms（SSD随机IO延迟）
• 未复用的JSON解析中间件：每次请求新建json.Decoder，触发高频小对象分配
• 全局互斥锁滥用：如用sync.Mutex保护共享计数器，导致高并发下锁争用加剧

快速根因定位三步法

1. 启动运行时分析：

   # 采集30秒CPU与goroutine profile
   go tool pprof -http=:8080 http://localhost:6060/debug/pprof/profile?seconds=30
   go tool pprof -http=:8081 http://localhost:6060/debug/pprof/goroutine?debug=2

2. 检查中间件内存分配热点：

   // 在中间件入口添加临时跟踪（生产环境慎用）
   import "runtime"
   var memStats runtime.MemStats
   runtime.ReadMemStats(&memStats)
   log.Printf("Alloc = %v MiB", memStats.Alloc/1024/1024) // 对比前后差值

3. 验证goroutine泄漏：
   执行 curl 'http://localhost:6060/debug/pprof/goroutine?debug=2' | grep -c "your-middleware-name"，若数值随请求单调递增即确认泄漏。

指标	健康阈值	危险信号
GC pause (P99)		> 10ms
Goroutine count		> 1000 且持续增长
Alloc rate		> 50 MB/s（无大文件上传）

根本原因往往不在业务逻辑，而在中间件对http.Handler接口的误用——例如在闭包中捕获*http.Request并异步处理，导致请求上下文生命周期失控，进而拖垮整个连接复用机制。

第二章：defer panic恢复机制在middleware链中的深层陷阱

2.1 defer执行时机与goroutine生命周期的耦合分析

defer的本质：栈帧清理钩子

defer语句注册的函数并非立即执行，而是被压入当前 goroutine 的 defer 链表，仅在函数返回前（包括正常 return 和 panic）按后进先出顺序调用。其生命周期严格绑定于所属函数的栈帧存续期。

goroutine 退出 ≠ defer 执行

当 goroutine 因函数返回而结束时，其 defer 链表才被遍历执行；若 goroutine 被 runtime.Goexit() 终止，则仍会触发所有已注册的 defer——这是关键耦合点。

func example() {
    defer fmt.Println("A") // 压入当前函数 defer 链表
    go func() {
        defer fmt.Println("B") // 属于匿名函数的 defer，绑定其栈帧
        runtime.Goexit()       // 此 goroutine 退出前仍执行 "B"
    }()
    time.Sleep(10 * time.Millisecond)
}

逻辑分析："B" 由子 goroutine 自身的函数返回路径触发（Goexit 模拟 return），而 "A" 在 example 返回时执行。二者无跨 goroutine 传递关系，defer 不跨协程共享。

关键约束对比

场景	defer 是否执行	原因说明
函数正常 return	✅	栈帧销毁前遍历链表
函数 panic 后 recover	✅	defer 在 panic 传播前执行
goroutine 被系统抢占终止	❌	无函数返回路径，链表未触达

graph TD
    A[goroutine 启动] --> B[执行函数]
    B --> C{函数是否返回？}
    C -->|是| D[遍历 defer 链表并执行]
    C -->|否| E[栈帧驻留，defer 暂不触发]
    D --> F[函数返回，栈帧销毁]

2.2 panic/recover在HTTP handler链中破坏context取消传播的实证实验

实验设计思路

构造三层 HTTP handler 链（middleware → auth → handler），在中间层触发 panic 并用 recover 捕获，观察 ctx.Done() 通道是否仍能响应上游取消。

关键代码复现

func panicMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("recovered: %v", err)
                // ❗ recover 后未显式调用 next.ServeHTTP，但 context 仍被“静默劫持”
            }
        }()
        ctx := r.Context()
        select {
        case <-ctx.Done():
            log.Println("context cancelled BEFORE panic") // 此行可能永不执行
        default:
        }
        panic("simulated error")
        next.ServeHTTP(w, r) // unreachable, 但 recover 后流程已脱离原 context 生命周期
    })
}

逻辑分析：recover 拦截 panic 后，goroutine 继续执行，但原 http.Server 内部对 r.Context() 的取消监听逻辑已被中断；ctx.Done() 不再受 http.TimeoutHandler 或客户端断连影响，导致资源泄漏。

对比行为表

场景	context.Done() 是否关闭	可观测超时行为	是否释放底层连接
无 panic，正常链路	✅ 是	✅ 是	✅ 是
panic + recover（未重抛）	❌ 否	❌ 否	❌ 否

根本原因图示

graph TD
    A[HTTP Server] --> B[Accept Conn]
    B --> C[Start Context with Timeout]
    C --> D[panicMiddleware]
    D --> E{panic?}
    E -->|Yes| F[recover → 跳出 defer]
    F --> G[Context 监听 goroutine 泄漏]
    G --> H[Done channel 永不关闭]

2.3 基于pprof与trace的中间件panic恢复路径性能损耗量化对比

在微服务中间件中，recover() 恢复 panic 的路径存在隐式开销，需精确量化。

pprof CPU 火焰图采样差异

启用 runtime.SetBlockProfileRate(1) 后，recover() 调用栈在 net/http handler 中引入平均 1.8μs 额外延迟（Go 1.22）：

func middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                // 注：此处触发 goroutine 栈扫描与 defer 链遍历
                http.Error(w, "Internal Error", http.StatusInternalServerError)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

逻辑分析：recover() 触发运行时栈展开（stack unwinding），pprof 在 runtime.gopanic 和 runtime.recovery 处采样密集；GODEBUG=gctrace=1 显示 GC STW 无影响，但 goroutine 调度器需额外 2–3 个调度周期完成状态清理。

trace 分析关键路径耗时

阶段	pprof 测量均值	trace 精确耗时	差异来源
panic 发生到 defer 执行	420ns	398ns	pprof 采样间隔导致低估
recover() 返回至 error 处理	1.38μs	1.72μs	trace 捕获 runtime.deferproc 调用

性能损耗归因

• recover() 强制触发 runtime.scanstack（即使无指针）
• 每次 panic 恢复增加约 0.6% 的 P99 延迟（压测 QPS=5k 时）

graph TD
    A[HTTP 请求进入] --> B[panic 触发]
    B --> C[runtime.gopanic]
    C --> D[runtime.recovery]
    D --> E[defer 链执行]
    E --> F[stack scan + scheduler sync]
    F --> G[恢复 handler 流程]

2.4 混合使用defer recover与http.Error导致的错误包装泄漏复现实战

复现场景：HTTP Handler 中的错误捕获链断裂

当 defer func() { if r := recover(); r != nil { http.Error(w, "server error", http.StatusInternalServerError) } }() 被调用时，原始 panic 错误（如 &url.Error{...}）被丢弃，http.Error 仅写入静态字符串，未保留原始错误链。

关键代码缺陷示例

func handler(w http.ResponseWriter, r *http.Request) {
    defer func() {
        if err := recover(); err != nil {
            // ❌ 错误：丢失 err 的类型、堆栈、causes
            http.Error(w, "internal server error", http.StatusInternalServerError)
        }
    }()
    json.NewDecoder(r.Body).Decode(&struct{}{}) // 可能 panic
}

逻辑分析：recover() 返回 interface{}，未转换为 error；http.Error 不接受 error 参数，无法触发 fmt.Errorf("wrap: %w", err) 风格包装。参数 w 是响应写入器，"internal server error" 是硬编码消息，无上下文透出。

泄漏对比表

方式	是否保留原始 error	是否含 stack trace	是否可 errors.Is/As 判断
http.Error(w, msg, code)	❌	❌	❌
http.Error(w, err.Error(), code)	❌（仅字符串）	❌	❌

正确修复路径

• 使用 log.Printf("panic: %+v", err) 记录原始 panic；
• 改用 http.Error(w, http.StatusText(http.StatusInternalServerError), ...) + 单独返回结构化错误响应体。

2.5 替代方案 benchmark：recover wrapper vs. error return early vs. middleware error channel

三种错误处理范式的语义差异

• recover wrapper：延迟捕获 panic，适合不可预知的运行时崩溃（如 nil dereference）
• Error return early：显式传播错误，符合 Go 的惯用法，利于静态分析与测试
• Middleware error channel：解耦错误分发与处理，适用于高并发请求链路中的统一熔断/日志

性能基准关键指标（10k req/s 压测）

方案	平均延迟	内存分配/req	panic 恢复成功率
recover wrapper	1.8 ms	416 B	100%
error return early	0.3 ms	24 B	—
middleware channel	0.9 ms	128 B	—

// middleware error channel 示例（带缓冲通道避免阻塞）
func WithErrorChannel(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        errCh := make(chan error, 1)
        go func() { // 启动异步错误监听
            select {
            case err := <-errCh:
                log.Error("middleware error", "err", err)
                http.Error(w, "server error", http.StatusInternalServerError)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

该实现通过 goroutine + buffered channel 实现非阻塞错误上报；errCh 容量为 1 防止 handler 阻塞，需配合 defer close(errCh) 或显式发送确保通道关闭。

第三章：context.WithTimeout在中间件链中的隐式污染机制

3.1 context.Value与timeout cancel signal在跨中间件传递时的不可见依赖分析

当 HTTP 请求穿越 Gin → gRPC → Redis 中间件链路时，context.Value 与 context.WithTimeout/WithCancel 常被混用，却隐含关键耦合：

• context.Value 仅传递只读数据（如 traceID、userID），不触发任何控制流；
• timeout/cancel 则驱动生命周期终止信号，但其传播完全依赖 context 的父子继承关系。

数据同步机制

以下代码揭示典型误用：

func middlewareA(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := context.WithValue(r.Context(), "user", "alice")
        ctx, cancel := context.WithTimeout(ctx, 5*time.Second) // ❌ 错误：cancel 未被调用！
        r = r.WithContext(ctx)
        next.ServeHTTP(w, r)
        // cancel 被遗忘 → timeout 不生效
    })
}

逻辑分析：context.WithTimeout 返回的 cancel 函数必须显式调用（通常 defer 或在 handler 结束时），否则子 context 永远不会因超时被取消；Value 的存在不保证 cancel 被传播或触发。

依赖关系可视化

graph TD
    A[HTTP Handler] -->|ctx.WithValue + WithTimeout| B[Gin Middleware]
    B --> C[gRPC Client]
    C --> D[Redis Client]
    D -.->|cancel 信号丢失| A
    style D stroke:#f66,stroke-width:2px

组件	是否继承 cancel？	是否透传 Value？	风险点
Gin 中间件	是	是	cancel 忘记调用
gRPC client	是（需显式传入）	否（需手动注入）	traceID 丢失
Redis client	否（默认忽略）	否	timeout 完全失效

3.2 WithTimeout嵌套调用引发的cancel race与goroutine泄漏现场还原

问题复现场景

以下代码模拟两层 WithTimeout 嵌套，外层 100ms，内层 50ms：

func nestedTimeout() {
    ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer cancel()

    go func() {
        innerCtx, innerCancel := context.WithTimeout(ctx, 50*time.Millisecond)
        defer innerCancel() // ⚠️ 可能永不执行！
        time.Sleep(80 * time.Millisecond) // 超出内层但未超外层
        fmt.Println("inner done")
    }()
    time.Sleep(120 * time.Millisecond)
}

逻辑分析：内层 WithTimeout 依赖 ctx.Done() 传播取消信号；但当内层 timer 先触发并调用 innerCancel() 时，若外层尚未完成 cancel()，innerCtx 的 Done() channel 已关闭，而 goroutine 仍在运行——此时 innerCancel() 被 defer 延迟执行，但 goroutine 已退出，defer 不生效，导致 innerCancel() 永不调用，底层 timer 和 goroutine 泄漏。

关键风险点

• 外层 ctx 取消时机与内层 timer 触发存在竞态（cancel race）
• defer innerCancel() 在 goroutine 退出前未执行 → timer 持有引用不释放

泄漏验证指标

指标	正常值	泄漏表现
runtime.NumGoroutine()	稳定波动	持续增长
time.Timer 实例数	0	>0 且不回收

graph TD
    A[启动 goroutine] --> B[创建 innerCtx + timer]
    B --> C{inner timer 触发?}
    C -->|是| D[发送 cancel signal]
    C -->|否| E[等待 sleep 结束]
    D --> F[goroutine 退出]
    F --> G[defer innerCancel 未执行]
    G --> H[Timer 持有 goroutine 引用 → 泄漏]

3.3 基于go tool trace识别context cancel风暴的火焰图诊断实践

当大量 goroutine 同时响应 context.Canceled，会触发密集的取消链传播与清理逻辑，在 go tool trace 中表现为高频、短时、堆叠深的 runtime.gopark 和 context.cancel 调用簇。

火焰图关键特征

• 横轴：调用栈耗时（采样归一化）
• 纵轴：调用深度
• 红色高亮区域集中于 context.(*cancelCtx).cancel → runtime.gopark → sync.runtime_SemacquireMutex

复现与采集示例

# 启动带 trace 的服务（启用 context 取消压测）
GODEBUG=asyncpreemptoff=1 go run -gcflags="-l" main.go &
go tool trace -http=:8080 trace.out

参数说明：asyncpreemptoff=1 减少抢占干扰，提升 cancel 事件时序保真度；-gcflags="-l" 禁用内联，确保 context.cancel 调用栈可追踪。

典型 cancel 链路（mermaid）

graph TD
    A[HTTP Handler] --> B[context.WithTimeout]
    B --> C[DB Query Goroutine]
    B --> D[Cache Fetch Goroutine]
    C --> E[context.selectgo]
    D --> E
    E --> F[context.cancel]
    F --> G[runtime.gopark]

指标	正常值	Cancel风暴征兆
context.cancel 调用频次		> 5000/s
平均 cancel 耗时	~0.2μs	> 15μs（锁竞争升高）

第四章：构建高性能、可观测、抗污染的中间件链路设计范式

4.1 统一context生命周期管理：从request-scoped context factory到middleware-aware context pool

传统 request-scoped context 工厂在中间件链中易产生上下文泄漏或提前释放。为解耦生命周期与 HTTP 生命周期，引入 middleware-aware context pool。

核心演进路径

• 单次请求 → 多中间件协作 → 跨中间件状态共享 → 池化复用与自动回收
• Context 不再绑定 http.Request，而是由 middleware chain 显式传播与标记

Context Pool 管理策略

策略	触发条件	回收动作
OnNext	中间件调用 next() 前	冻结当前 context 状态
OnReturn	next() 返回后	恢复/合并子 context
OnPanic	中间件 panic	强制清理并标记异常态

// Middleware-aware context pool 示例
func WithContextPool(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        poolCtx := pool.Acquire(ctx) // 从池获取（带引用计数）
        defer pool.Release(poolCtx) // 自动回收，非 defer r.Context()
        r = r.WithContext(poolCtx)
        next.ServeHTTP(w, r)
    })
}

pool.Acquire() 基于 ctx.Value("middleware_id") 分区获取；pool.Release() 触发引用计数减一 + 空闲超时清理。避免 Goroutine 泄漏与 context 泄露。

graph TD
    A[Request Start] --> B{Middleware 1}
    B --> C[Acquire from Pool]
    C --> D[Middleware 2]
    D --> E[Propagate poolCtx]
    E --> F[Response End]
    F --> G[Release on pool exit]

4.2 panic-safe中间件契约设计：基于error-first handler签名与结构化错误传播协议

核心契约原则

• 所有中间件必须遵循 func(http.Handler) http.Handler 签名，且内部不得直接调用 panic()
• 错误必须通过 error 返回值显式传递，禁止隐式崩溃

error-first handler 示例

func RecoverMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                http.Error(w, "internal server error", http.StatusInternalServerError)
                log.Printf("PANIC: %v", err) // 结构化日志
            }
        }()
        next.ServeHTTP(w, r)
    })
}

逻辑分析：defer 中捕获 panic 后转为 HTTP 500 响应，并记录结构化日志；next.ServeHTTP 是唯一执行点，确保错误传播路径可控。参数 w/r 保持原始语义，不引入额外上下文。

错误传播协议对比

方式	panic 传播	error 返回	可观测性	恢复能力
原生 panic	❌（进程级中断）	—	低	无
error-first 中间件	✅（被拦截）	✅（显式链式）	高（日志+metric）	✅（降级/重试）

graph TD
    A[Request] --> B[RecoverMiddleware]
    B --> C{panic?}
    C -->|Yes| D[Log + 500 Response]
    C -->|No| E[Next Handler]
    E --> F[Structured Error Propagation]

4.3 timeout感知型中间件开发规范：WithTimeout仅在入口层注入，链路中通过deadline propagation替代

核心原则

• 入口层（如 HTTP handler、gRPC server）唯一调用 context.WithTimeout()
• 下游服务间传递 ctx.Deadline() 与 ctx.Err()，禁止重复创建新 timeout context

Deadline 传播示例

func ServeHTTP(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second) // ✅ 入口层唯一注入
    defer cancel()
    result, err := service.Process(ctx) // 透传 ctx，不重设 timeout
}

逻辑分析：r.Context() 继承自 HTTP server，WithTimeout 仅在此处生成 deadline；service.Process 接收原始 ctx 并调用 ctx.Deadline() 获取剩余时间，避免嵌套超时导致“时间坍缩”。

中间件行为对比

场景	是否合规	风险
在 middleware A 中 WithTimeout(ctx, 2s)	❌	叠加超时，链路总耗时不可控
调用 next(ctx) 前 ctx = ctx.WithValue(...)	✅	仅扩展元数据，不干扰 deadline

流程示意

graph TD
    A[HTTP Entry] -->|WithTimeout 5s| B[Service Layer]
    B -->|ctx.Deadline()| C[DB Client]
    C -->|ctx.Err() on timeout| D[Graceful Cancel]

4.4 链路级可观测性增强：集成context.Context值注入trace.Span、metrics.Labels与log.Fields的标准化实践

统一上下文载体设计

context.Context 是 Go 生态中跨调用传递元数据的事实标准。为避免重复传参与上下文污染，需将 trace、metrics、log 三类可观测性载体统一注入 context.Context。

标准化注入模式

func WithObservability(ctx context.Context, span trace.Span, labels metrics.Labels, fields log.Fields) context.Context {
    ctx = trace.ContextWithSpan(ctx, span)
    ctx = metrics.ContextWithLabels(ctx, labels)
    ctx = log.ContextWithFields(ctx, fields)
    return ctx
}

逻辑分析：该函数按顺序注入三类可观测对象。trace.ContextWithSpan 将 Span 绑定至 ctx；metrics.ContextWithLabels 存储 label 映射（支持动态指标打标）；log.ContextWithFields 使日志自动携带结构化字段。所有注入均使用 context.WithValue 的安全封装，键为私有 unexportedKey 类型，防止键冲突。

关键注入键对照表

观测类型	注入键（私有类型）	生命周期语义
trace.Span	spanKey{}	跨 goroutine 传播 Span
metrics.Labels	labelsKey{}	仅限当前请求链路
log.Fields	fieldsKey{}	支持嵌套字段合并

自动传播机制示意

graph TD
    A[HTTP Handler] --> B[WithObservability]
    B --> C[DB Query]
    B --> D[RPC Call]
    C & D --> E[Log/Metric/Trace 输出]

第五章：从性能断崖到稳定高可用：Go HTTP服务中间件演进路线图

熔断降级：从手动 panic 恢复到自适应 CircuitBreaker

某电商大促期间，订单服务因下游库存接口超时雪崩，QPS 从 12000 骤降至 800。团队紧急上线 gobreaker 中间件，配置 MaxRequests: 50、Timeout: 30s、ReadyToTrip: func(counts gobreaker.Counts) bool { return float64(counts.TotalFailures)/float64(counts.TotalRequests) > 0.6 }。上线后故障窗口缩短至 47 秒，错误率压降至 0.3%。关键改进在于将熔断状态持久化至本地 LevelDB，避免重启失忆。

日志与追踪：结构化日志 + OpenTelemetry 全链路注入

旧版 log.Printf 导致日志无法关联请求生命周期。重构后统一使用 zerolog + otelhttp 中间件：

mux.Use(func(next http.Handler) http.Handler {
    return otelhttp.NewHandler(
        http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            ctx := r.Context()
            span := trace.SpanFromContext(ctx)
            log.Ctx(ctx).Info().Str("trace_id", span.SpanContext().TraceID().String()).Str("path", r.URL.Path).Msg("request_start")
            next.ServeHTTP(w, r)
        }),
        "api",
        otelhttp.WithFilter(func(r *http.Request) bool { return r.URL.Path != "/health" }),
    )
})

限流策略：从单一令牌桶到多维度分级限流

初期仅对 /api/v1/order 全局限流 5000 QPS，导致 VIP 用户与普通用户同等待遇。演进为三层限流：	维度	策略	示例阈值	生效位置
IP 级	滑动窗口计数	200 req/60s	入口网关中间件
用户 ID 级	分布式令牌桶	1000 req/30s	JWT 解析后中间件
接口路径+方法	自定义配额组	POST /order: 3000 QPS	路由匹配中间件

健康检查与优雅退出：SIGTERM 处理与依赖探活

服务升级时曾出现连接拒绝（connection refused）持续 12 秒。现采用双阶段健康检查：

1. /healthz 返回 {"status":"ok","dependencies":{"redis":"up","pg":"up"}}；
2. 主进程监听 syscall.SIGTERM，触发 srv.Shutdown() 前执行 redisClient.Close() 和 pgDB.Close()，并阻塞至所有活跃 HTTP 连接空闲超 15 秒或强制终止（max 30s）。

动态配置热加载：基于 etcd 的中间件开关控制

通过 etcd/client/v3 监听 /config/middleware/rate_limit_enabled 键变更，当值从 "false" 变为 "true" 时，自动更新 rateLimiter.Enabled = true 并刷新内存令牌桶池。实测配置生效延迟

错误分类与响应体标准化

统一错误中间件将 errors.Is(err, ErrInsufficientStock) 映射为 409 Conflict，errors.As(err, &validationErr) 映射为 422 Unprocessable Entity，并封装标准响应体：

{
  "code": "STOCK_SHORTAGE",
  "message": "库存不足",
  "details": {"sku_id": "SK-7892", "available": 0},
  "request_id": "req_8a3f9b2c"
}

流量染色与灰度路由

在反向代理层解析 X-Env: staging 或 X-Canary: user-id-12345 请求头，动态注入 context.WithValue(ctx, middleware.KeyTrafficType, "canary")，后续中间件据此分流至灰度实例池，实现 5% 用户流量的渐进式验证。

性能对比：演进前后核心指标变化

指标	V1.0（裸 net/http）	V3.2（全中间件栈）	提升幅度
P99 响应延迟	1420 ms	86 ms	↓94%
故障自愈平均耗时	186 s	3.2 s	↓98.3%
内存泄漏率（/hr）	12.7 MB	0.03 MB	↓99.8%
配置变更生效延迟	重启耗时 4.2s	热加载 0.78s	↓99.1%

flowchart LR
    A[HTTP Request] --> B[IP 限流]
    B --> C{是否放行？}
    C -->|否| D[返回 429]
    C -->|是| E[JWT 验证]
    E --> F[用户级限流]
    F --> G{是否放行？}
    G -->|否| D
    G -->|是| H[熔断器检查]
    H --> I[业务 Handler]
    I --> J[OpenTelemetry 注入]
    J --> K[结构化日志]
    K --> L[HTTP Response]