Go基础HTTP服务根基：ServeMux路由冲突优先级、HandlerFunc中间件链执行顺序与context超时传递

第一章：Go基础HTTP服务的核心架构与设计哲学

Go语言的HTTP服务设计以“小而美、组合优于继承”为根本信条。标准库 net/http 并未提供繁复的框架抽象，而是通过极简的接口（如 http.Handler）和可组合的中间件模式，将控制权交还给开发者。其核心由三部分构成：监听器（http.Server）、路由分发器（http.ServeMux 或自定义 Handler）与处理器（满足 ServeHTTP(http.ResponseWriter, *http.Request) 签名的任意类型）。这种分层清晰、职责单一的结构，使服务既轻量又高度可定制。

标准库的极简主义实践

http.ListenAndServe 仅需两行即可启动一个生产就绪的基础服务：

// 创建一个满足 http.Handler 接口的函数值（即 HandlerFunc）
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("Hello from Go HTTP"))
})
// 启动服务器：绑定地址并注册处理器
log.Fatal(http.ListenAndServe(":8080", handler)) // 阻塞运行，错误时 panic

该代码未依赖任何第三方包，却已具备完整请求响应生命周期管理——连接建立、头解析、路由匹配、响应写入与连接关闭均由标准库静默完成。

接口驱动的扩展能力

http.Handler 是唯一必需实现的核心接口，所有增强功能均通过组合构建：

• 日志中间件：包装原始 Handler，在调用前后注入日志逻辑
• 跨域支持：修改响应头后委托给下游 Handler
• 路由复用：http.ServeMux 本身是 Handler，可嵌套至其他 Handler 中

组件	类型	关键特性
http.ResponseWriter	接口	抽象响应写入行为，支持 Header/Status/Write 分离
*http.Request	结构体	不可变上下文容器，含 URL、Header、Body 等字段
http.Handler	接口	ServeHTTP(ResponseWriter, *Request) 唯一方法

这种设计拒绝魔法，强调显式契约，使调试、测试与替换变得直观自然。

第二章：ServeMux路由机制深度解析

2.1 路由树结构与路径匹配算法（理论）与自定义PrefixTree实现对比实验（实践）

路由匹配本质是字符串前缀树（Trie）上的最长前缀匹配问题。标准 http.ServeMux 使用简单切片线性遍历，而高性能框架（如 Gin、Echo）采用带通配符支持的多叉 PrefixTree（即“路由树”），节点按路径段分层，支持 :id 动态参数与 *filepath 通配。

核心差异：匹配语义与时间复杂度

• 线性匹配：O(n) 路径数，每次全量字符串比较
• PrefixTree 匹配：O(m) 路径深度（m 为段数），单次字符级跳转

自定义 PrefixTree 关键设计

type node struct {
    children map[string]*node // key: 静态段或 ":param"
    handler  http.Handler
    isParam  bool             // 是否为 :param 节点
    isCatchAll bool           // 是否为 *catchall
}

逻辑分析：children 以段名（如 "users"）或占位符标识（":"/"*"）为键，避免正则回溯；isParam 与 isCatchAll 标志位驱动匹配优先级规则（静态 > 参数 > 通配）。

实现方案	平均匹配耗时（10k 路由）	内存占用	支持动态参数
http.ServeMux	186 μs	低	❌
自定义 PrefixTree	4.2 μs	中	✅

graph TD
    A[/GET /api/users/123/] --> B[Split → [“api”, “users”, “123”]]
    B --> C{Node “api” exists?}
    C -->|Yes| D{Node “users” exists?}
    D -->|Yes| E{Node “123” exists?}
    E -->|No| F[Check param child “:id”]
    F -->|Match| G[Bind id=123 & invoke handler]

2.2 通配符路由与子路径嵌套的优先级判定规则（理论）与冲突场景复现与调试（实践）

Vue Router 和 React Router 均遵循 “最具体匹配优先” 原则：静态路径 > 动态参数路径（:id） > 通配符路径（* 或 /:pathMatch(.*)*）。

路由匹配优先级表

路由模式	匹配示例	优先级
/user/settings	精确静态路径	⭐⭐⭐⭐⭐
/user/:id	单段动态参数	⭐⭐⭐⭐
/user/:id/profile	嵌套动态+静态	⭐⭐⭐⭐⭐（比 /user/:id 更具体）
/user/*	通配符（最低）	⭐

冲突复现代码（Vue Router 4）

const routes = [
  { path: '/admin', component: AdminHome },
  { path: '/admin/users', component: UserList }, // ✅ 高优先级静态
  { path: '/admin/:id', component: AdminDetail }, // ⚠️ 会拦截 /admin/users！
  { path: '/admin/*', component: NotFound },      // ❌ 永远不触发（被前两者覆盖）
]

逻辑分析：/admin/users 同时满足 /admin/users（精确）和 /admin/:id（:id 可匹配 "users" 字符串），但因 Vue Router 按定义顺序 + 具体性双重判定，静态路径 /admin/users 仍胜出；若交换两行顺序，则 /admin/users 将被误捕获为 id="users"。参数说明：:id 是贪婪单段匹配，不支持斜杠；* 必须置于末尾且无前置同级更具体路由。

调试建议流程

graph TD
  A[访问 /admin/users] --> B{路由表遍历}
  B --> C[匹配 /admin/users？是 → 返回]
  B --> D[匹配 /admin/:id？是 → 但已有更具体静态匹配 → 跳过]
  C --> E[渲染 UserList]

2.3 DefaultServeMux与自定义ServeMux的并发安全边界（理论）与goroutine泄漏检测实战（实践）

Go 的 http.ServeMux 是线程安全的——其内部使用读写锁保护路由映射，但仅限于注册/查找操作；DefaultServeMux 与自定义 ServeMux 在并发安全边界上完全一致。

数据同步机制

ServeMux 的 ServeHTTP 方法只读 mu.RLock()，而 Handle/HandleFunc 写操作需 mu.Lock()。因此：

• ✅ 并发 Handler 执行安全
• ❌ 动态热更新路由时需避免高频 Handle() 调用

mux := http.NewServeMux()
mux.HandleFunc("/api", func(w http.ResponseWriter, r *http.Request) {
    time.Sleep(100 * time.Millisecond) // 模拟长耗时逻辑
    w.WriteHeader(http.StatusOK)
})
// 注：此 Handler 内部无锁，goroutine 生命周期由 HTTP server 管理

该 Handler 不引入新 goroutine；若内部显式 go f() 且未管控生命周期，则触发泄漏。

goroutine 泄漏检测三步法

• 使用 pprof 抓取 goroutine profile
• 分析 runtime.Stack() 中阻塞在 select{} 或 chan recv 的栈帧
• 结合 net/http server 日志定位未完成请求

工具	命令示例	关键指标
pprof	go tool pprof http://localhost:6060/debug/pprof/goroutine?debug=2	runtime.gopark 占比
go tool trace	go tool trace trace.out	Goroutines > 10k 持续增长

graph TD
    A[HTTP 请求到达] --> B{ServeMux 查找 Handler}
    B --> C[启动 goroutine 执行 Handler]
    C --> D[Handler 完成？]
    D -- 是 --> E[goroutine 退出]
    D -- 否 --> F[等待 I/O 或 channel]
    F --> G[若永不唤醒 → 泄漏]

2.4 HTTP方法感知路由与OPTIONS预检处理（理论）与CORS中间件兼容性验证（实践）

HTTP方法感知路由要求框架能区分 GET、POST、PUT 等动词并绑定不同处理器；而浏览器发起跨域非简单请求时，会先发送 OPTIONS 预检请求，需服务端显式响应 Access-Control-Allow-Methods 等头。

CORS中间件的介入时机至关重要

• 若路由匹配早于CORS中间件，OPTIONS 可能被业务路由捕获而未触发预检响应
• 正确顺序：CORS → 路由 → 业务处理器

// Express示例：CORS中间件必须前置
app.use(cors({ origin: 'https://example.com', credentials: true }));
app.options('/api/data', (req, res) => res.sendStatus(200)); // 显式预检端点
app.put('/api/data', (req, res) => res.json({ ok: true }));

此代码确保：① cors() 拦截所有预检请求并注入标准响应头；② 显式 app.options() 提供细粒度控制；③ credentials: true 启用 Cookie 透传，需配套 Access-Control-Allow-Credentials: true。

兼容性验证关键检查项

• ✅ 预检响应含 Access-Control-Allow-Methods: PUT, OPTIONS
• ✅ 实际请求响应含 Vary: Origin
• ❌ 避免在路由内重复设置 CORS 头导致冲突

阶段	响应头示例	说明
预检响应	Access-Control-Allow-Methods: PUT	告知浏览器允许的动词
实际请求响应	Access-Control-Allow-Credentials: true	支持认证信息跨域传递

2.5 路由注册时序对Handler覆盖的影响（理论）与动态路由热加载模拟测试（实践）

路由注册的时序敏感性

当多个中间件或路由处理器以不同顺序注册时，后注册的 HandlerFunc 会覆盖同路径前注册的处理器（若未显式链式调用）。Go 的 http.ServeMux 不支持路径覆盖警告，属静默替换。

模拟热加载冲突场景

// 启动时注册基础路由
mux.HandleFunc("/api/user", legacyHandler) // ① 先注册

// 热加载新版本（无锁、无校验）
mux.HandleFunc("/api/user", newHandler) // ② 后注册 → 完全覆盖①

逻辑分析：ServeMux 内部使用 map[string]muxEntry 存储，HandleFunc 调用等价于 Handle(pattern, HandlerFunc(f))，直接写入 map，无版本/优先级校验。参数 pattern 为精确匹配键，重复即覆盖。

关键影响维度对比

维度	静态注册	动态热加载
覆盖可预测性	高（编译期确定）	低（运行时竞态）
回滚能力	需重启	依赖快照还原

时序依赖流程示意

graph TD
    A[启动加载路由] --> B{是否启用热加载？}
    B -->|否| C[一次性注册完成]
    B -->|是| D[监听配置变更]
    D --> E[原子替换 mux 实例]
    E --> F[旧 handler 立即失效]

第三章：HandlerFunc与中间件链执行模型

3.1 函数式Handler的底层接口契约与类型转换原理（理论）与nil Handler panic溯源分析（实践）

Go 的 http.Handler 接口定义极简却关键：

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

该契约强制所有处理器实现统一调用协议，是函数式 http.HandlerFunc 类型转换的基础。

http.HandlerFunc 本质是函数类型别名：

type HandlerFunc func(ResponseWriter, *Request)

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r) // 直接调用原函数 —— 类型擦除后还原为接口实现
}

此处 f(w, r) 完成闭包捕获与参数透传，HandlerFunc 通过方法集隐式满足 Handler 接口。

当传入 nil 的 HandlerFunc 并注册时（如 http.Handle("/path", nil)），运行时在 ServeHTTP 调用链中触发 panic: nil pointer dereference。根本原因在于：nil 值无方法集，(*nil).ServeHTTP 非法。

场景	是否 panic	原因
http.Handle("/x", nil)	✅ 是	nil 不满足 Handler 接口（无有效方法集）
http.HandleFunc("/x", nil)	✅ 是	nil 转 HandlerFunc 后仍为 nil，调用时解引用失败

graph TD
    A[注册 nil Handler] --> B[http.ServeHTTP 调用]
    B --> C[检测 Handler 非 nil？]
    C -->|否| D[panic: nil pointer dereference]

3.2 中间件链的洋葱模型与defer/return控制流穿透机制（理论）与超时中断与恢复流程可视化追踪（实践）

中间件链本质是嵌套函数调用形成的双向执行路径：请求向内“剥洋葱”，响应向外“回弹”。

洋葱模型核心逻辑

func Middleware(next Handler) Handler {
    return func(c *Context) {
        // ✅ 请求阶段：外→内（前置）
        log.Println("→ enter")
        defer func() {
            // ✅ 响应阶段：内→外（后置，panic安全）
            log.Println("← exit")
        }()
        next(c) // 调用下一层
    }
}

defer 在函数返回前统一触发，实现“对称收尾”；next(c) 的执行位置决定控制流穿透点。

超时中断与恢复可视化

阶段	触发条件	行为
请求进入	ctx.WithTimeout	注入截止时间
中间件阻塞	select{case <-ctx.Done()}	立即返回错误并跳过后续中间件
恢复追踪	trace.Span	自动标注中断节点

graph TD
    A[Client] --> B[Auth]
    B --> C[RateLimit]
    C --> D[TimeoutGuard]
    D --> E[Handler]
    D -. timeout → B
    D -. timeout → A

3.3 中间件状态共享的三种范式：闭包、结构体字段与context.Value（理论）与内存逃逸与GC压力实测（实践）

三种共享范式对比

• 闭包捕获：轻量、零分配，但生命周期绑定 handler 函数，无法跨中间件复用
• 结构体字段：类型安全、易测试，但需显式传递 *Middleware 实例，耦合 handler 签名
• context.Value：松耦合、动态键值，但无类型检查、易引发 panic，且触发堆分配

内存逃逸关键实测（Go 1.22，基准测试 go test -bench=.）

范式	分配次数/req	平均分配字节数	GC 压力
闭包	0	0	无
结构体字段	0	0	无
context.Value	1	48	显著

func WithUserID(ctx context.Context, id uint64) context.Context {
    return context.WithValue(ctx, userKey{}, id) // userKey{} 是空结构体，但 context.WithValue 总是 new(interface{}) → 堆逃逸
}

context.WithValue 内部将 id 装箱为 interface{}，强制逃逸至堆；即使 id 是 uint64（栈变量），仍触发一次堆分配与后续 GC 扫描。

数据同步机制

graph TD
    A[HTTP Request] --> B{Middleware Chain}
    B --> C[闭包：state := userID<br>handler(w, r.WithContext(ctx))}
    B --> D[结构体：m.state = userID<br>m.ServeHTTP(w, r)]
    B --> E[context.Value：<br>ctx = context.WithValue(r.Context(), key, userID)]
    C --> F[栈上直接访问，零逃逸]
    D --> F
    E --> G[heap alloc → interface{} → GC trace]

第四章：context在HTTP生命周期中的超时传递与取消传播

4.1 context.Context接口的零值语义与Deadline/Cancel的底层信号同步机制（理论）与channel阻塞点性能剖析（实践）

零值语义：context.Context 的 nil 安全性

context.Context 是接口类型，其零值为 nil。Go 标准库中所有 context.With* 函数返回非 nil 值，但 select 中对 nil channel 的操作会永久阻塞——这被 context 巧妙规避：ctx.Done() 在零值 Context 下返回 nil channel，使 select { case <-ctx.Done(): } 直接跳过该分支。

底层信号同步机制

cancelCtx 和 timerCtx 通过 closed chan struct{} 实现广播通知，其关闭动作是原子的、无锁的 OS 级事件唤醒。

// cancelCtx.cancel 方法核心片段（简化）
func (c *cancelCtx) cancel(removeFromParent bool, err error) {
    if err == nil {
        panic("context: internal error: missing cancel error")
    }
    c.mu.Lock()
    if c.err != nil {
        c.mu.Unlock()
        return // 已取消
    }
    c.err = err
    close(c.done) // 关键：单次关闭，触发所有监听者唤醒
    c.mu.Unlock()
}

close(c.done) 是唯一同步原语：它使所有阻塞在 <-c.done 的 goroutine 立即就绪，无需轮询或锁竞争；c.done 是 chan struct{}，零内存开销，仅作信号载体。

channel 阻塞点性能对比

场景	平均延迟（ns）	唤醒抖动	是否可扩展
<-ctx.Done()（已取消）	~25	极低	✅
<-time.After(d)	~85	高	❌（新建 timer）
sync.Mutex + flag	~120	中	❌（需锁）

取消传播的链式唤醒

graph TD
    A[Root Context] -->|WithCancel| B[Child1]
    A -->|WithTimeout| C[Child2]
    B -->|WithValue| D[Grandchild]
    C -->|cancel| E[Close C.done]
    E --> F[All <-C.Done() readers unblock]
    B -.->|propagates cancel| A

Done() channel 的阻塞点性能优势源于 Go runtime 对 closed channel 的 O(1) 唤醒优化——这是 context 高吞吐调度的基石。

4.2 Request.Context()的继承链与Server超时配置的优先级覆盖关系（理论）与ReadHeaderTimeout与IdleTimeout干扰实验（实践）

http.Request.Context() 并非独立创建，而是由 Server 的 BaseContext 或默认 context.Background() 派生，再经 net/http 内部层层 WithCancel/WithValue 封装：

// Server 启动时隐式注入 root context
srv := &http.Server{
    BaseContext: func(_ net.Listener) context.Context {
        return context.WithValue(context.Background(), "server", "prod")
    },
    ReadHeaderTimeout: 2 * time.Second,
    IdleTimeout:       30 * time.Second,
}

BaseContext 提供根上下文；Request.Context() 在每次连接 Accept 后派生，不继承 ReadHeaderTimeout 或 IdleTimeout——二者作用于连接生命周期，而非请求上下文。

超时优先级本质

• ReadHeaderTimeout：限制从 Accept 到 ParseRequestLine 完成的时长（TCP 层）
• IdleTimeout：控制 Keep-Alive 连接空闲期（连接级）
• Request.Context().Done()：仅响应 WriteTimeout（已弃用）、显式取消或 Handler 主动 cancel

干扰实验关键发现

配置组合	实际生效超时	原因
ReadHeaderTimeout=1s, IdleTimeout=10s	请求头读取超时1s触发	ReadHeaderTimeout 优先阻断连接初始化
IdleTimeout=1s, 大量短轮询	连接频繁重建	IdleTimeout 终止空闲连接，与 Context 无关

graph TD
    A[Listener.Accept] --> B{ReadHeaderTimeout?}
    B -->|yes| C[Conn.Close]
    B -->|no| D[Parse Request Header]
    D --> E[Create Request.Context]
    E --> F[Handler.ServeHTTP]
    F --> G{IdleTimeout expired?}
    G -->|yes| H[Close Keep-Alive Conn]

4.3 子context派生的cancel传播延迟与goroutine泄漏防护（理论）与pprof goroutine堆栈诊断实战（实践）

cancel传播的非即时性本质

context.WithCancel(parent) 返回的 child 并不立即响应父context取消——它依赖父级 cancelFunc 显式调用，且需等待子goroutine主动轮询 ctx.Done()。若子goroutine阻塞在无超时的 I/O 或 channel receive 上，cancel信号将被延迟甚至丢失。

goroutine泄漏的典型诱因

• 忘记调用 cancel()
• select 中未监听 ctx.Done()
• 使用 context.Background() 替代派生子context

ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel() // ✅ 必须确保执行

go func() {
    select {
    case <-time.After(5 * time.Second):
        fmt.Println("work done")
    case <-ctx.Done(): // 🔑 响应cancel的关键路径
        fmt.Println("canceled:", ctx.Err())
    }
}()

逻辑分析：ctx.Done() 是只读 channel，关闭后立即可读；time.After 不受 context 控制，若未在 select 中监听 ctx.Done()，goroutine 将永久存活。cancel() 必须在 defer 中调用，否则可能因 panic 被跳过。

pprof 快速定位泄漏

启动时启用：

go run -gcflags="-m" main.go &
curl http://localhost:6060/debug/pprof/goroutine?debug=2

指标	含义	健康阈值
runtime.gopark	阻塞等待中	≤ 10% 总goroutine数
selectgo	卡在 select	需结合 ctx.Done() 检查

graph TD
    A[main goroutine] --> B[启动 worker]
    B --> C{select on ctx.Done?}
    C -->|Yes| D[及时退出]
    C -->|No| E[goroutine leak]
    E --> F[pprof /goroutine?debug=2]

4.4 自定义context键类型的类型安全实践与value竞态检测（理论）与go vet + race detector联合验证（实践）

类型安全的键设计原则

使用未导出的空结构体作为键类型，杜绝字符串键的类型擦除风险：

type userIDKey struct{} // 零内存占用，不可比较，强制类型约束
func WithUserID(ctx context.Context, id int64) context.Context {
    return context.WithValue(ctx, userIDKey{}, id)
}

userIDKey{} 无法被外部构造或误用，context.WithValue 的 key 参数类型即为编译期校验锚点；id 作为 int64 值传入，避免 interface{} 引发的运行时类型断言失败。

竞态检测协同验证流程

工具	检测目标	触发条件
go vet	context.WithValue 键非指针/非比较类型	静态分析键字面量合法性
go run -race	并发读写同一 context.Value	多 goroutine 共享 ctx 且未同步

验证流程图

graph TD
    A[编写带自定义键的 context 传递逻辑] --> B[go vet 检查键类型合规性]
    B --> C{通过？}
    C -->|否| D[报错：key must be comparable]
    C -->|是| E[go run -race 运行测试]
    E --> F[发现 Write at ... by goroutine X<br>Previous read at ... by goroutine Y]

第五章：Go HTTP服务根基能力的演进边界与工程化启示

Go 标准库 net/http 自 2009 年诞生以来，始终以“小而稳”为设计信条。但随着云原生架构普及、微服务粒度持续细化、可观测性要求指数级增长，其原始接口在真实工程场景中正不断遭遇显性张力。以下通过两个典型生产案例揭示其能力边界的具象表现。

请求生命周期管理的隐式耦合

在某金融风控网关中，团队需对每个 HTTP 请求注入统一的审计日志、超时熔断、上下文传播逻辑。标准 http.Handler 接口仅暴露 (http.ResponseWriter, *http.Request)，迫使开发者在每个 handler 函数内重复调用 ctx.WithTimeout()、span.Start()、log.WithFields() 等操作。这种模式导致中间件链难以复用，且错误处理路径分散（如超时后未及时关闭响应体流）。实际压测发现，当并发请求达 8K+ 时，因 ResponseWriter 缺乏 CloseNotify() 替代方案（该方法已在 Go 1.22 中被标记为废弃），大量 goroutine 卡在 writeHeader 阻塞点，内存泄漏率达 3.7%/h。

连接复用与资源隔离的失配

下表对比了不同连接管理策略在高并发长连接场景下的表现（测试环境：4c8g 容器，HTTP/1.1，Keep-Alive=30s）：

策略	平均延迟(ms)	连接复用率	内存占用(MB)	意外断连率
默认 http.DefaultTransport	42.6	68%	142	0.9%
自定义 Transport（MaxIdleConns=50）	28.1	89%	116	0.3%
按租户分 Transport 实例	22.4	94%	187	0.02%

数据表明：标准 Transport 的全局连接池在多租户场景下成为性能瓶颈，而手动分实例又引发 GC 压力——Go runtime 无法感知 Transport 级别连接生命周期，导致 net.Conn 对象长期驻留堆中。

流式响应的底层约束

某实时指标推送服务需通过 SSE（Server-Sent Events）向前端持续发送 JSON 数据流。标准 http.ResponseWriter 不提供非阻塞写入能力，开发者被迫使用 flusher, ok := w.(http.Flusher) 类型断言，并在每次 Write() 后调用 Flush()。但实测发现，在 Linux kernel 5.10+ 环境下，当网络拥塞时 Flush() 调用会阻塞整个 goroutine，且无超时控制机制。最终采用 io.Copy + 自定义 io.Writer 包装器，在 Write() 方法中嵌入 select { case <-time.After(5*time.Second): return 0, context.DeadlineExceeded } 实现硬性超时，才规避了 goroutine 泄漏风险。

// 关键修复代码：带超时的响应写入器
type TimeoutWriter struct {
    w       http.ResponseWriter
    timeout time.Duration
}

func (tw *TimeoutWriter) Write(p []byte) (n int, err error) {
    done := make(chan int, 1)
    go func() {
        n, err = tw.w.Write(p)
        done <- 1
    }()
    select {
    case <-done:
        return n, err
    case <-time.After(tw.timeout):
        return 0, fmt.Errorf("write timeout after %v", tw.timeout)
    }
}

错误传播的语义鸿沟

当 HTTP 处理函数内部触发 panic 时，http.Server 默认仅记录 http: panic serving ...，丢失完整调用栈与业务上下文。某电商订单服务因此在灰度发布时未能捕获 redis.Nil 误判为业务异常的深层逻辑缺陷。最终通过 recover() + runtime.Stack() 构建自定义 PanicHandler，并将 panic 信息注入 OpenTelemetry span 的 exception.* 属性，才实现错误根因的分钟级定位。

flowchart LR
A[HTTP Request] --> B{Handler 执行}
B --> C[panic 触发]
C --> D[recover 捕获]
D --> E[获取 stack trace]
E --> F[注入 OTel span]
F --> G[上报至 Loki + Grafana]