第一章：Go语言Context取消机制失效的7种隐藏场景（郭宏志线上事故复盘文档节选·脱敏版）
Context取消机制并非“设了就生效”的银弹。在高并发、长生命周期或跨组件协作场景中，以下七类隐藏问题极易导致 cancel 信号丢失、goroutine 泄漏或超时失控。
Context未随调用链向下传递
显式创建子Context后，若未将其注入下游函数参数（尤其是中间件、封装层、回调注册点），则下游无法感知取消信号。常见于日志装饰器、指标埋点、异步任务提交等场景。
✅ 正确做法：
// 错误：ctx 被忽略
func handleRequest(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
go processAsync() // processAsync 内部未接收 ctx，无法响应取消
}
// 正确：显式透传
func handleRequest(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
go processAsync(ctx) // 必须将 ctx 作为参数传入
}WithCancel/WithTimeout 返回的 cancel 函数未被调用
父Context派生子Context后，若忘记调用返回的 cancel 函数（尤其在 defer 中遗漏），会导致子Context永不结束，其关联的 timer、goroutine 持续驻留。
select 中 default 分支吞噬 cancel 信号
当 select 包含 default 分支且无休眠逻辑时，会持续非阻塞轮询，使
HTTP Handler 中 context.WithTimeout 覆盖 request.Context
手动基于 request.Context 创建新 timeout Context 并赋值给局部变量，却未在后续 I/O 操作中使用该新 Context（如 database/sql 查询、HTTP client Do），导致超时控制形同虚设。
Context 值被意外重置为 context.Background()
在中间件或 SDK 封装中，因错误地调用 context.WithValue(context.Background(), ...) 覆盖原始请求上下文，切断取消链路。
Go runtime 启动 goroutine 时未携带 Context
如 http.Server 的 Serve 方法内部启动的连接 goroutine，默认继承 listener Context；但自定义连接池、WebSocket 升级后新建 goroutine 若未显式传入 Context，则脱离管控。
多层嵌套 Context 取消时机错位
父Context已 cancel，但子Context（如 WithDeadline）因 deadline 尚未到达而未触发 Done，造成“假存活”——此时应统一监听最外层 Done 通道，而非依赖子 Context 状态。
第二章：Context取消失效的底层原理与典型误用模式
2.1 Context值传递丢失导致cancel信号无法传播的实践验证
复现问题的最小示例
func badHandler(w http.ResponseWriter, r *http.Request) {
ctx := r.Context() // 来自请求的原始ctx
go func() {
time.Sleep(2 * time.Second)
select {
case <-ctx.Done(): // ❌ ctx未随goroutine传递，Done()永不触发
fmt.Println("canceled")
default:
fmt.Println("still running")
}
}()
w.Write([]byte("started"))
}该代码中，ctx 未通过参数显式传入 goroutine，导致子协程无法感知父请求的 cancel 信号（如客户端断开）。
关键差异对比
| 场景 | Context 是否传递 | cancel 可否传播 | 原因 |
|---|---|---|---|
显式传参 go work(ctx) |
✅ | ✅ | 上下文链完整，Done() 监听有效 |
闭包捕获但未继承 r.Context() |
❌ | ❌ | goroutine 启动时 ctx 已脱离请求生命周期 |
正确修复方式
func goodHandler(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
go func(ctx context.Context) { // ✅ 显式接收ctx参数
time.Sleep(2 * time.Second)
select {
case <-ctx.Done(): // now works
fmt.Println("canceled:", ctx.Err())
}
}(ctx) // 传入当前有效ctx
w.Write([]byte("started"))
}逻辑分析：ctx 必须作为第一类参数传入新协程，否则 Go 运行时无法建立父子取消链；r.Context() 返回的是请求作用域绑定的上下文，脱离 HTTP handler 后若未显式传递，其 Done() channel 将永远阻塞。
2.2 WithCancel父子上下文生命周期错配引发的goroutine泄漏实验分析
实验场景构建
启动一个子goroutine监听父context.WithCancel，但父context提前结束而子goroutine未及时退出：
func leakDemo() {
parent, cancel := context.WithCancel(context.Background())
defer cancel() // ⚠️ 过早调用，父context立即失效
go func() {
<-parent.Done() // 永远阻塞：parent.Done() 已关闭，但无接收者
fmt.Println("clean up")
}()
}逻辑分析：
parent.Done()在cancel()调用后立即变为已关闭 channel，<-parent.Done()立即返回（非阻塞），但本例中因缺少后续逻辑，goroutine 实际未泄漏；真正泄漏发生在：子goroutine 持有对未关闭 channel 的select阻塞，且无超时/退出路径。
关键泄漏模式
- 子context未被显式取消，却依赖已销毁的父context状态
- goroutine 在
select { case <-ctx.Done(): ... }中等待，但 ctx 已不可达且无外部唤醒
对比验证表
| 场景 | 父context生命周期 | 子goroutine是否泄漏 | 原因 |
|---|---|---|---|
| 正常嵌套 | 父长于子 | 否 | 子可响应父 Done |
| 父提前 cancel | 父 | 是 | 子持续阻塞在已关闭但无消费的 Done channel |
graph TD
A[启动父context] --> B[WithCancel生成子ctx]
B --> C[子goroutine监听子ctx.Done]
A --> D[父cancel被调用]
D --> E[子ctx.Done关闭]
E --> F[子goroutine未检测到退出信号]
F --> G[goroutine永久驻留]2.3 select + context.Done()中default分支滥用导致取消被静默吞没的调试复现
问题场景还原
当 select 语句中错误添加 default 分支，且未处理 context.Done() 的关闭信号时，goroutine 可能持续空转，忽略取消通知。
典型错误代码
func badHandler(ctx context.Context) {
for {
select {
case <-ctx.Done():
fmt.Println("canceled")
return
default:
time.Sleep(100 * time.Millisecond) // 隐蔽阻塞点
}
}
}逻辑分析：
default分支使select永不阻塞，ctx.Done()通道即使已关闭也无法被及时轮询到；time.Sleep是伪阻塞，不响应上下文取消。参数100ms加剧响应延迟，掩盖取消传播。
正确模式对比
| 方式 | 是否响应 cancel | 是否空转 | 推荐度 |
|---|---|---|---|
select + default |
❌ | ✅ | 不推荐 |
select 无 default |
✅ | ❌ | ✅ |
select + case <-time.After(...) |
✅ | ❌ | ✅ |
修复方案
移除 default，改用带超时的 select 或显式检查 ctx.Err()。
2.4 HTTP Handler中未正确继承request.Context而使用background.Context的压测反例
问题现象
高并发压测时，服务出现大量 goroutine 泄漏与超时请求，pprof 显示大量阻塞在 select 等待 context.Done() 的协程。
根本原因
Handler 中错误地使用 context.Background() 替代 r.Context()，导致子任务无法响应客户端中断或超时。
func badHandler(w http.ResponseWriter, r *http.Request) {
ctx := context.Background() // ❌ 错误：丢失请求生命周期信号
dbQuery(ctx) // 即使客户端已断开，该查询仍持续执行
}
context.Background()是静态根上下文，不携带Done()通道的取消信号；而r.Context()继承自net/http请求生命周期，自动在超时、连接关闭时触发取消。
对比行为差异
| 场景 | r.Context() |
context.Background() |
|---|---|---|
| 客户端主动断开 | ✅ 立即收到 ctx.Err() |
❌ 永不取消 |
Timeout: 5s 设置 |
✅ 5s 后自动取消 | ❌ 无超时控制 |
修复方案
func goodHandler(w http.ResponseWriter, r *http.Request) {
ctx := r.Context() // ✅ 正确：绑定请求生命周期
if err := dbQuery(ctx); err != nil {
if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
http.Error(w, "request cancelled", http.StatusRequestTimeout)
return
}
}
}2.5 数据库驱动层忽略context超时参数导致连接池阻塞的真实链路追踪
问题复现场景
当应用层使用 context.WithTimeout(ctx, 500*time.Millisecond) 调用 db.QueryContext()，但底层 MySQL 驱动（如 go-sql-driver/mysql v1.6.0 之前）未透传该 timeout 至底层 TCP 连接建立阶段，导致连接池在 net.DialContext 阶段挂起，阻塞后续请求。
关键代码缺陷
// ❌ 驱动中未使用 ctx.Deadline()，硬编码 dial timeout
func (mc *mysqlConn) open(ctx context.Context, addr string) error {
// 缺失：select { case <-ctx.Done(): return ctx.Err() }
conn, err := net.Dial("tcp", addr, nil) // ← 忽略 context！
// ...
}逻辑分析：net.Dial 无上下文感知，若 DNS 解析慢或目标端口不可达，将阻塞长达默认 30s（系统级 TCP connect timeout），远超业务层设定的 500ms，使连接池中空闲连接无法及时释放或复用。
影响链路
graph TD
A[HTTP Handler] -->|ctx.WithTimeout| B[sql.DB.QueryContext]
B --> C[driver.OpenConnector]
C --> D[mysqlConn.open]
D --> E[net.Dial<br>← 无视ctx]
E -->|阻塞30s| F[连接池耗尽]修复对比（v1.7.0+）
| 版本 | Context 感知 | Dial 超时来源 | 连接池健康度 |
|---|---|---|---|
| ≤v1.6.0 | ❌ | 系统默认（30s） | 严重下降 |
| ≥v1.7.0 | ✅ | ctx.Deadline() |
可控恢复 |
第三章：高并发服务中Context失效的隐蔽触发条件
3.1 并发Map写入竞争下context.Value缓存污染引发的取消状态不一致
数据同步机制
当多个 goroutine 并发向 sync.Map 写入携带 context.WithCancel 衍生值的键时，若键相同但 context.Value 中缓存的 cancelFunc 指针被覆盖，将导致旧 context 的取消信号无法传播。
// 示例：危险的并发写入
var cache sync.Map
ctx, cancel := context.WithCancel(context.Background())
cache.Store("task-123", ctx) // 存入 ctxA
// ... 另一 goroutine 同时执行：
ctxB, cancelB := context.WithCancel(context.Background())
cache.Store("task-123", ctxB) // 覆盖为 ctxB → ctxA.cancel() 失效逻辑分析：
sync.Map.Store不保证 value 的原子性可见性；context.Value本身无并发安全语义，cancelFunc是闭包捕获的内部状态指针。覆盖后，原ctxA.Done()通道仍开放，但其cancel()已不可达。
关键风险点
context.WithCancel返回的cancel函数非幂等且不可重绑定sync.Map的 value 替换不触发旧 context 的清理钩子
| 场景 | 是否触发取消 | 原因 |
|---|---|---|
ctxA 被 ctxB 覆盖 |
❌ 否 | cancelA 引用丢失 |
ctxA 单独调用 cancelA() |
✅ 是 | 显式调用，通道立即关闭 |
graph TD
A[goroutine-1: Store ctxA] --> B[sync.Map.value = ctxA]
C[goroutine-2: Store ctxB] --> D[sync.Map.value = ctxB]
B --> E[ctxA.cancel lost]
D --> F[ctxB.cancel active]3.2 gRPC拦截器中错误重置context deadline导致流式调用取消失效
问题根源：拦截器中误覆写 context.Deadline
当在 unary 或 streaming 拦截器中调用 ctx, cancel := context.WithTimeout(ctx, 30*time.Second)，若原 ctx 已携带由客户端设定的 deadline（如 grpc.WaitForReady(true) + ctx, _ = context.WithDeadline(parent, t)），该操作将覆盖原始 deadline，使服务端无法感知客户端超时意图。
典型错误代码示例
func badUnaryInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
// ❌ 错误：无条件重设 deadline，抹除 client 传递的 Deadline
newCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
defer cancel()
return handler(newCtx, req) // 原始 deadline 丢失
}逻辑分析：
context.WithTimeout总是创建新 deadline（基于调用时刻），忽略ctx.Deadline()返回的已有截止时间。流式 RPC（如ClientStream.SendMsg）依赖此 deadline 触发context.Canceled，覆盖后导致 Cancel 信号无法传播，流挂起不终止。
正确做法对比
| 方式 | 是否保留原始 deadline | 是否安全用于 streaming |
|---|---|---|
context.WithTimeout(ctx, d) |
❌ 否 | ❌ 危险 |
ctx = ctx（透传） |
✅ 是 | ✅ 推荐 |
context.WithValue(ctx, key, val) |
✅ 是 | ✅ 安全 |
修复建议流程
graph TD
A[进入拦截器] --> B{ctx.Deadline() 有效？}
B -->|是| C[直接透传 ctx]
B -->|否| D[按需设置 fallback timeout]
C --> E[调用 handler]
D --> E3.3 中间件链中多个WithTimeout叠加造成cancel优先级反转的性能回归案例
问题现象
服务响应 P99 延迟从 120ms 突增至 850ms，日志高频出现 context deadline exceeded，但上游超时设置仅为 300ms。
根本原因
中间件链中嵌套了三层 WithTimeout（如鉴权、缓存、DB），形成嵌套 cancel：
ctx, _ = context.WithTimeout(ctx, 300*time.Millisecond) // 外层
ctx, _ = context.WithTimeout(ctx, 200*time.Millisecond) // 中层 → 先触发 cancel
ctx, _ = context.WithTimeout(ctx, 100*time.Millisecond) // 内层 → 实际应最先生效逻辑分析：Go 的 WithTimeout 返回新 Context，其 Done() 通道由最内层计时器控制；但 CancelFunc 调用会向上逐层传播。当内层 100ms 到期 cancel，中层 200ms 计时器仍运行，却因收到 cancel 信号提前终止——导致「短时限被长时限劫持」，违背预期优先级。
影响对比
| 场景 | 实际生效 timeout | 是否符合语义预期 |
|---|---|---|
| 单层 WithTimeout | 100ms | ✅ |
| 三层嵌套（内→外：100/200/300ms） | 200ms（中层 cancel 传播覆盖内层） | ❌ |
修复方案
统一由入口层注入单个 Context，各中间件通过 WithValue 传递元数据，避免 WithTimeout 嵌套。
第四章：生产环境Context治理的工程化解决方案
4.1 基于pprof+trace的Context生命周期可视化监控体系搭建
为精准追踪 context.Context 在高并发微服务中的传播路径与生命周期异常（如提前取消、泄漏），需融合 net/http/pprof 的运行时采样能力与 runtime/trace 的事件级时序能力。
集成埋点与启动配置
import _ "net/http/pprof"
import "runtime/trace"
func initTracing() {
f, _ := os.Create("trace.out")
trace.Start(f)
go func() {
http.ListenAndServe("localhost:6060", nil) // pprof endpoint
}()
}该代码启用标准 pprof HTTP 接口（/debug/pprof/）并启动低开销 trace 采集；trace.Start() 生成 .out 文件供 go tool trace 解析，关键参数：f 必须保持打开状态直至程序退出，否则 trace 数据截断。
Context 跟踪增强
使用 context.WithValue(ctx, key, val) 本身不触发 trace 事件，需手动注入：
func WithTraceID(ctx context.Context, id string) context.Context {
trace.Log(ctx, "context", "created_with_id:"+id)
return context.WithValue(ctx, traceIDKey, id)
}trace.Log() 将结构化日志写入 trace 事件流，使 ctx 创建/取消时刻与 goroutine 调度、网络 I/O 等事件对齐，实现跨组件生命周期归因。
| 监控维度 | pprof 贡献 | trace 贡献 |
|---|---|---|
| Goroutine 泄漏 | 协程数突增快照 | GoCreate/GoEnd 时序链 |
| Cancel 传播延迟 | 无 | context.WithCancel → ctx.Done() 事件差值 |
| Deadline 超时 | CPU 火焰图定位热点 | timerStart/timerFired 关联分析 |
graph TD
A[HTTP Handler] --> B[WithTraceID]
B --> C[DB Query with ctx]
C --> D[trace.Log cancel]
D --> E[pprof heap profile]
E --> F[go tool trace trace.out]4.2 自研contextlint静态检查工具识别7类高危模式的规则实现
contextlint 基于 Go 的 go/ast 和 golang.org/x/tools/go/analysis 框架构建，以 AST 遍历为核心，对 context.Context 的生命周期与传播行为进行语义级校验。
规则覆盖的7类高危模式
- 上下文未传递至下游调用（如
http.NewRequest忘传ctx） context.WithCancel/Timeout/Deadline后未调用defer cancel()context.Background()在非顶层函数中硬编码使用context.TODO()未被替换为语义明确上下文ctx.Value()存储非只读、非请求元数据（如结构体指针）select中遗漏ctx.Done()分支导致 goroutine 泄漏http.Handler中未从r.Context()提取上下文而新建
核心检测逻辑示例（WithCancel 漏 defer）
// 示例：检测 context.WithCancel 调用后是否紧跟 defer cancel()
func (v *cancelChecker) Visit(n ast.Node) ast.Visitor {
if call, ok := n.(*ast.CallExpr); ok {
if isWithContextCancel(call.Fun) {
// 向上查找最近的 *ast.BlockStmt，扫描其 Stmt 列表首条是否为 defer
if !hasDeferCancelInBlock(call, v.enclosingBlock) {
v.pass.Reportf(call.Pos(), "missing defer cancel() after context.WithCancel")
}
}
}
return v
}该逻辑通过 enclosingBlock 定位作用域块，在 AST 层确保 defer cancel() 位于 WithCancel 调用同级且紧邻后续位置，避免误报嵌套作用域或条件分支场景。isWithContextCancel 通过 types.Info 精确匹配函数签名，排除同名但非标准库的干扰。
检测能力对比表
| 模式类型 | 支持跨文件 | 依赖类型信息 | 误报率 |
|---|---|---|---|
| 未传 ctx 至 HTTP 请求 | ✅ | ✅ | |
| 缺失 defer cancel | ✅ | ✅ | |
| Background 硬编码 | ❌（仅当前包） | ❌ | ~5% |
graph TD
A[Parse Go source] --> B[Build AST + type info]
B --> C{Apply 7 rule visitors}
C --> D[Report diagnostic]
C --> E[Suppress false positives via control-flow analysis]4.3 微服务网关层统一注入可审计context的SDK封装与灰度发布策略
为保障全链路审计能力，网关需在请求入口处自动注入 AuditContext（含 traceId、userId、tenantId、grayTag 等字段），并透传至下游服务。
SDK核心封装逻辑
public class AuditContextInjector {
public static void inject(HttpServletRequest req) {
AuditContext ctx = AuditContext.builder()
.traceId(MDC.get("traceId")) // 来自Sleuth/Zipkin埋点
.userId(req.getHeader("X-User-ID")) // 认证中心注入
.tenantId(req.getHeader("X-Tenant-ID")) // 多租户标识
.grayTag(extractGrayTag(req)) // 灰度标签提取策略（见下表）
.build();
MDC.put("audit_ctx", JSON.toJSONString(ctx)); // 日志上下文绑定
}
}该方法在 Spring WebFilter 中前置执行，确保所有请求（含静态资源）均携带审计上下文；grayTag 优先级：请求头 > Cookie > 用户画像规则匹配。
灰度标签提取策略
| 来源 | 示例值 | 适用场景 |
|---|---|---|
X-Gray-Tag |
v2-canary |
运维手动标定 |
gray_id Cookie |
user_8821 |
AB测试用户分组 |
| 用户画像规则 | vip&&ios17 |
动态规则引擎实时计算 |
流量路由协同机制
graph TD
A[Gateway] -->|注入AuditContext| B[Auth Filter]
B --> C{grayTag存在？}
C -->|是| D[路由至v2-canary集群]
C -->|否| E[路由至stable集群]4.4 Context取消事件埋点与SLO关联告警的可观测性增强实践
数据同步机制
Context取消事件需实时同步至可观测性平台，采用context.WithCancel钩子注入埋点逻辑：
func WithCancelTrace(parent context.Context) (context.Context, context.CancelFunc) {
ctx, cancel := context.WithCancel(parent)
go func() {
<-ctx.Done()
// 上报取消原因与耗时（单位：ms）
metrics.ContextCancelEvent.Record(
ctx,
metric.WithAttributes(
attribute.String("reason", getCancelReason(ctx)),
attribute.Int64("duration_ms", time.Since(start).Milliseconds()),
),
)
}()
return ctx, cancel
}该函数在ctx.Done()触发后自动上报结构化事件，reason由errors.Is(ctx.Err(), context.Canceled)等规则推导，duration_ms反映请求生命周期。
SLO关联告警策略
将取消率（Cancel Rate）纳入SLO指标体系：
| SLO 指标 | 目标值 | 计算方式 | 告警阈值 |
|---|---|---|---|
| API可用性 | 99.95% | 1 - (canceled_reqs / total_reqs) |
|
| 平均取消延迟 | ≤200ms | sum(duration_ms)/count(canceled) |
>350ms |
告警闭环流程
graph TD
A[Context Cancel Event] --> B[OpenTelemetry Collector]
B --> C[Metrics Pipeline]
C --> D[SLO Evaluation Engine]
D --> E{Cancel Rate > 99.90%?}
E -->|Yes| F[Trigger PagerDuty Alert]
E -->|No| G[Archive for Root-Cause Analysis]第五章：从事故到范式——Go生态Context最佳实践共识演进
一次生产级超时雪崩的复盘
2021年某支付网关服务在大促期间出现级联超时，根因是http.Client未绑定context.WithTimeout，导致下游gRPC调用卡死30秒后才触发net/http默认Timeout，而上游已重试三次。火焰图显示runtime.gopark在select语句上堆积超2000 goroutine。修复后将context.WithTimeout(ctx, 800*time.Millisecond)作为HTTP客户端构造的强制前置步骤，并通过-gcflags="-m"验证逃逸分析中context未被意外捕获。
Context取消链的不可逆性陷阱
func handleRequest(w http.ResponseWriter, r *http.Request) {
// ❌ 错误：子context生命周期超出父context
parentCtx := r.Context()
childCtx, cancel := context.WithCancel(parentCtx)
defer cancel() // 危险！parentCtx可能已被cancel，cancel()无作用或panic
// ✅ 正确：使用WithTimeout/WithDeadline并确保defer仅在子ctx作用域内
ctx, _ := context.WithTimeout(parentCtx, 500*time.Millisecond)
dbQuery(ctx) // 传递给下游
}中间件中Context值的污染防控
| 场景 | 风险 | 推荐方案 |
|---|---|---|
JWT解析注入userID |
多中间件重复WithValue覆盖 |
使用context.WithValue(ctx, userIDKey, id) + userIDKey = &struct{}{}私有key类型 |
| 日志traceID透传 | log.Printf直接拼接导致日志乱序 |
统一使用log.WithContext(ctx).Info("msg")（zap/slog） |
| 数据库连接池复用 | context.WithValue(ctx, dbKey, conn)导致连接泄漏 |
永远不将资源句柄存入context，改用函数参数传递 |
gRPC流式场景的Context生命周期管理
在实时行情推送服务中，stream.Send()必须与ctx.Done()同步监听：
for {
select {
case <-ctx.Done():
return ctx.Err() // 立即返回，避免goroutine泄漏
case data := <-ticker.C:
if err := stream.Send(&pb.Quote{Data: data}); err != nil {
if status.Code(err) == codes.Canceled {
return nil // 客户端主动断连
}
return err
}
}
}监控数据显示，该模式将goroutine泄漏率从0.7%降至0.002%。
Context取消信号的跨协程可靠性保障
使用Mermaid流程图描述典型错误传播路径：
flowchart LR
A[HTTP Handler] --> B[启动goroutine处理异步任务]
B --> C[向Redis写入状态]
C --> D[等待Redis响应]
A -.-> E[客户端断开连接]
E --> F[context.Cancelled]
F -->|未监听| D
F -->|正确监听| G[立即关闭Redis连接]
G --> H[释放goroutine]标准化Context初始化模板
所有入口函数强制执行：
func (s *Service) Handle(ctx context.Context, req *pb.Request) (*pb.Response, error) {
// 1. 强制设置超时（业务SLA驱动）
ctx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
// 2. 注入traceID（若不存在）
if traceID := middleware.GetTraceID(ctx); traceID == "" {
ctx = middleware.WithTraceID(ctx, uuid.New().String())
}
// 3. 绑定请求ID用于日志追踪
ctx = log.WithRequestID(ctx, req.Id)
// 后续业务逻辑...
}生产环境Context健康度指标
context_cancel_rate：单位时间ctx.Done()触发次数 / 总请求数（基线context_deadline_exceeded_count：context.DeadlineExceeded错误计数（需关联P99延迟告警）goroutine_leak_by_context：通过pprof比对runtime.NumGoroutine()在ctx.Done()前后的差值
Go 1.22中Context的演进方向
新引入的context.WithCancelCause已落地于database/sql包，当sql.DB.QueryContext遇到context.Canceled时，可精确区分是用户主动取消还是网络中断。社区正在推动net/http默认启用WithContext构造器，消除历史遗留的无context裸调用。
