Go实战包Context取消传播链断裂事故复盘：从http.Request.Context()到database/sql.Tx的12层cancel信号丢失根因分析

第一章：Context取消传播链断裂事故全景概览

当 Go 程序中多个 goroutine 协同处理一个请求时，context.Context 是传递取消信号、超时控制与请求范围值的核心机制。然而，一旦 Context 取消传播链在某处意外中断——例如显式创建了未继承父 Context 的新 Context、或错误地将 context.Background()/context.TODO() 注入中间层——整个下游调用树将对上游取消信号“失聪”，导致资源泄漏、goroutine 积压与响应延迟雪崩。

典型断裂场景包括：

• 在 HTTP 中间件中调用 context.WithTimeout(context.Background(), ...) 而非 req.Context()；
• 使用 sql.DB.QueryContext() 时传入硬编码的 context.Background()；
• 将 context.WithValue() 后的新 Context 遗忘传递给关键子协程；
• 第三方库内部未遵循 Context 传播约定（如某些旧版 Redis 客户端驱动）。

以下代码片段直观展示了传播链断裂的隐患：

func handleRequest(w http.ResponseWriter, r *http.Request) {
    // ✅ 正确：从请求中继承 context
    ctx := r.Context()

    // ❌ 危险：此处人为切断传播链
    dbCtx := context.WithTimeout(context.Background(), 5*time.Second) // ← 错误！应为 context.WithTimeout(ctx, ...)

    rows, err := db.QueryContext(dbCtx, "SELECT * FROM users WHERE id = $1", 123)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer rows.Close()

    // 即使 r.Context() 已被 cancel，db.QueryContext 仍会执行满 5 秒
}

该问题在高并发服务中常表现为：	现象	根本原因	监控线索
持续增长的 goroutine 数	下游协程无法响应上游取消	runtime.NumGoroutine() 持续上升
P99 响应时间突增	超时 Context 未与请求生命周期对齐	HTTP 服务端 http_server_duration_seconds 分位数异常
数据库连接池耗尽	大量查询因 Context 断裂而阻塞等待	pg_stat_activity 中 state = 'active' 且 backend_start 久远

定位断裂点的关键方法是：在关键路径插入 ctx.Err() 日志，并结合 runtime/debug.Stack() 捕获未响应取消的 goroutine 堆栈；同时启用 GODEBUG=gctrace=1 辅助观察内存与 goroutine 生命周期异常。

第二章：Go Context机制的底层原理与常见误用模式

2.1 Context接口设计与cancelCtx结构体内存布局剖析

Context 接口定义了超时、取消与值传递的契约，其核心在于不可变性与树形传播：

type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key interface{}) interface{}
}

cancelCtx 是实现可取消语义的关键结构体，内存布局紧凑且无指针逃逸：

字段	类型	说明
Context	Context	嵌入父上下文（非指针）
mu	sync.Mutex	保护 done 和 children
done	chan struct{}	只读关闭通道，零分配
children	map[canceler]struct{}	弱引用子节点，避免循环引用

cancelCtx 内存对齐分析

sync.Mutex 占 24 字节（含 padding），done 为 8 字节指针；字段顺序经编译器优化，确保 mu 与 done 高频访问局部性。

graph TD
    A[Root Context] --> B[cancelCtx]
    B --> C[timeoutCtx]
    B --> D[valueCtx]
    C --> E[grandchild cancelCtx]

cancelCtx.cancel() 触发广播：先 close(done)，再遍历 children 递归 cancel —— 此过程严格线性化，依赖 mu 全局锁。

2.2 http.Request.Context()的生命周期绑定与goroutine泄漏风险验证

http.Request.Context() 绑定于 HTTP 连接生命周期，随请求进入而创建、随响应写出或连接关闭而取消。若在 Handler 中启动子 goroutine 且未监听该 Context 的 Done 通道，将导致 goroutine 泄漏。

Context 取消时机对照表

场景	Context 是否取消	常见误用示例
正常响应完成	✅ 是	go process(ctx) 未 select
客户端提前断开（如超时）	✅ 是	忽略 <-ctx.Done()
Handler panic 后	✅ 是	defer 中未清理长时 goroutine

典型泄漏代码示例

func handler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    go func() { // ❌ 危险：未监听 ctx.Done()
        time.Sleep(10 * time.Second)
        log.Println("task done") // 可能永远不执行，或延迟执行导致泄漏
    }()
}

逻辑分析：该 goroutine 启动后完全脱离 Context 生命周期控制；r.Context() 在连接关闭时自动 Cancel，但此处未通过 select { case <-ctx.Done(): return } 响应取消信号，导致 goroutine 持续占用栈内存与调度资源。

泄漏验证流程

graph TD
    A[HTTP 请求到达] --> B[r.Context() 创建]
    B --> C[Handler 执行]
    C --> D{子 goroutine 启动？}
    D -->|未监听 Done| E[连接关闭 → Context 取消]
    E --> F[goroutine 仍运行 → 泄漏]
    D -->|select <-ctx.Done()| G[及时退出]

2.3 database/sql.Tx对Context的被动忽略：源码级跟踪与测试复现

database/sql.Tx 的 Commit() 和 Rollback() 方法签名中完全不接收 context.Context 参数，与 DB.BeginTx() 形成鲜明对比：

// 源码节选（src/database/sql/sql.go）
func (tx *Tx) Commit() error { /* ... */ }
func (tx *Tx) Rollback() error { /* ... */ }

逻辑分析：Tx 对象在 BeginTx(ctx, opts) 中已消费 ctx 完成初始连接获取与事务启动，但后续提交/回滚阶段彻底丢失上下文绑定——无法响应取消、超时或截止时间。

关键行为差异对比

方法	接收 Context	可中断性	超时传播
DB.BeginTx	✅	✅	✅
Tx.Commit	❌	❌	❌
Tx.Rollback	❌	❌	❌

复现实例要点

• 构造一个长阻塞的 COMMIT（如 PostgreSQL 中触发慢函数）
• 在 Tx 创建后立即 cancel context
• 观察 Commit() 仍会阻塞直至完成，无视 cancel signal

graph TD
    A[BeginTx ctx] --> B[Acquire conn + START TRANSACTION]
    B --> C[Tx object created]
    C --> D[Commit\Rollback]
    D --> E[无 ctx 参数 → 无法感知取消]

2.4 12层调用链中cancel信号衰减的可观测性实验（pprof+trace+自定义Context wrapper）

在深度调用链中，context.WithCancel 的 cancel 信号可能因未显式传递、漏检 ctx.Err() 或 goroutine 泄漏而发生“衰减”——即下游未及时终止。

实验设计

• 使用 net/http 构建 12 层嵌套 handler 链
• 每层注入 tracing.ContextWrapper（封装 Value/Done/Err 并打点）
• 同时启用 runtime/pprof CPU profile 与 go.opentelemetry.io/otel/trace

关键代码片段

type TracedCtx struct {
    context.Context
    layer int
}
func (t *TracedCtx) Done() <-chan struct{} {
    log.Printf("layer-%d: entering Done()", t.layer) // 埋点日志
    return t.Context.Done()
}

该 wrapper 在每次 Done() 调用时记录层级与时间戳，用于比对 cancel 传播延迟；layer 字段使 trace span 可关联调用深度。

观测结果对比（前5层）

层级	Cancel 传播延迟(ms)	是否响应 Done()
1	0.2	✅
3	1.7	✅
5	8.9	⚠️（偶发阻塞）

graph TD
    A[Client Cancel] --> B[Handler L1]
    B --> C[L2: wrapped ctx]
    C --> D[L3: select{ctx.Done()}]
    D -->|delayed| E[L5: goroutine still running]

2.5 标准库中Context传播断点清单：net/http、database/sql、sqlx、gorm、redis-go等实证对比

Context传播的“隐式断点”本质

Context在跨组件传递时，若下游库未显式接收并透传context.Context参数，则传播链断裂。关键断点不在API签名缺失，而在调用路径中未注入上下文。

各库Context支持实证对比

库名	Context入参支持	默认超时继承	中断典型场景
net/http	✅ ServeHTTP隐式无，但Client.Do(req)需手动构造带ctx的*http.Request	❌ 需显式设置req = req.WithContext(ctx)	忘记req.WithContext()
database/sql	✅ QueryContext, ExecContext等专用方法	✅ DB.SetConnMaxLifetime不影响，但Stmt需复用ctx	误用Query()而非QueryContext()
sqlx	✅ 全方法均提供XXXContext变体	✅ 完全兼容database/sql语义	调用db.Get()而非db.GetContext()
gorm	✅ v2+ 默认所有方法接受WithContext(ctx)链式调用	✅ Session(&Session{Context: ctx})	v1.x未升级或忽略.WithContext()调用
redis-go (github.com/redis/go-redis/v9)	✅ 所有命令方法签名含ctx context.Context	✅ 客户端级WithContext可覆盖	使用v8（无ctx）混入v9代码库

关键代码断点示例

// ❌ 断点：sqlx未用Context变体 → 超时/取消不生效
err := db.Get(&user, "SELECT * FROM users WHERE id = $1", 123)

// ✅ 正确：显式透传ctx，触发cancel/timeout传播
err := db.GetContext(ctx, &user, "SELECT * FROM users WHERE id = $1", 123)

db.GetContext内部将ctx绑定至底层sql.DB.QueryRowContext，确保连接获取、网络IO、结果扫描全程响应取消信号；而db.Get仅使用默认context.Background()，彻底脱离父生命周期控制。

传播链断裂可视化

graph TD
    A[HTTP Handler ctx] --> B[http.Request.WithContext]
    B --> C[sqlx.GetContext]
    C --> D[database/sql.QueryRowContext]
    D --> E[driver.Conn.PrepareContext]
    E -. broken .-> F[redis-go v8: Do(cmd) // 无ctx]
    C -. broken .-> G[sqlx.Get // 无Context后缀]

第三章：取消信号丢失的根因分类与典型场景建模

3.1 非阻塞操作导致的Context监听失效（如非select通道接收、defer延迟执行）

Context取消信号的监听时机陷阱

context.Context 的 Done() 通道仅在取消触发时一次性关闭。若在非阻塞路径中（如 select 缺失或 defer 延迟注册）监听，将错过该信号。

典型失效场景对比

场景	是否可靠监听	原因
select { case <-ctx.Done(): ... }	✅	主动轮询，及时响应关闭
go func() { <-ctx.Done() }()	❌	goroutine 启动后才监听，可能跳过已关闭的通道
defer cancel(); <-ctx.Done()	❌	defer 在函数返回时执行，此时 ctx 可能早已取消

func badExample(ctx context.Context) {
    done := ctx.Done()
    defer func() {
        // ⚠️ 此处 done 已关闭，但 <-done 将立即返回（零值），无法感知取消原因
        <-done // 错误：未在活跃goroutine中持续监听
    }()
}

逻辑分析：done 是只读通道引用，<-done 在通道关闭后立即返回零值（struct{}），不阻塞也不报错，导致取消事件“静默丢失”。应始终在 select 中配合 default 或 timeout 构建可响应的监听循环。

graph TD
    A[Context.Cancel] --> B[Done channel closed]
    B --> C{监听方式}
    C -->|select + case| D[实时捕获]
    C -->|defer + 单次<-| E[错过信号]

3.2 中间件/Wrapper未透传Context的隐式截断（middleware.ContextWithTimeout封装陷阱）

当使用 middleware.ContextWithTimeout 封装 handler 时，若中间件未显式将父 context 传递给子调用，会导致 timeout 提前触发且上游取消信号丢失。

常见错误封装模式

func BadTimeoutMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
        defer cancel()
        // ❌ 错误：未将 ctx 注入新 *http.Request
        next.ServeHTTP(w, r) // 仍使用原始 r.Context()
    })
}

逻辑分析：r.Context() 未被替换，ctx 完全被丢弃；cancel() 调用仅释放本地资源，不传播取消信号。参数 r 是不可变副本，必须用 r.WithContext(ctx) 构造新请求。

正确透传方式

func GoodTimeoutMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
        defer cancel()
        // ✅ 正确：注入新 Context
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

问题类型	表现	影响范围
隐式截断	子goroutine 不响应上游 cancel	跨服务链路超时失效
上下文泄漏	ctx.Done() 无法触发清理	连接/资源长期滞留

graph TD
    A[Client Request] --> B[Middleware: WithTimeout]
    B -->|❌ 未透传| C[Handler 使用原始 ctx]
    B -->|✅ r.WithContext| D[Handler 响应 ctx.Done]
    D --> E[级联取消下游调用]

3.3 基于time.AfterFunc或ticker的伪取消逻辑绕过Context控制流

当开发者误用 time.AfterFunc 或 time.Ticker 而忽略 context.Context 的生命周期，便可能形成“伪取消”——定时器照常触发，但业务逻辑已失效或产生竞态。

问题场景示例

func startLegacyTimer(ctx context.Context, delay time.Duration) {
    time.AfterFunc(delay, func() {
        // ⚠️ ctx.Done() 未被监听！此处可能在 ctx 已取消后仍执行
        fmt.Println("Task executed despite cancellation")
    })
}

该函数未检查 ctx.Err()，也未调用 Stop()，导致无法响应取消信号。

正确实践对比

方式	是否响应 Context 取消	是否可显式停止	安全性
time.AfterFunc	❌（需手动封装）	❌	低
time.NewTicker	✅（配合 select）	✅（需 Stop）	中→高

安全替代方案

func startSafeTimer(ctx context.Context, delay time.Duration) {
    timer := time.NewTimer(delay)
    defer timer.Stop() // 防止资源泄漏
    select {
    case <-timer.C:
        fmt.Println("Timer fired")
    case <-ctx.Done():
        fmt.Println("Canceled:", ctx.Err())
        return
    }
}

此实现通过 select 多路复用，使 ctx.Done() 与定时器通道平等竞争，真正实现取消感知。defer timer.Stop() 确保无论哪条路径退出，定时器资源均被释放。

第四章：高可靠性Context传播工程实践方案

4.1 Context-aware Tx封装：sql.Tx的WithContext方法安全扩展与panic防护

Go 1.23 引入 sql.Tx.WithContext，但原生实现不处理已关闭事务或上下文取消竞态，直接调用可能 panic。

安全封装原则

• 检查 tx 是否为 nil 或已 Closed()
• 在 ctx.Done() 触发前完成状态快照
• 所有方法调用前原子校验事务活性

核心防护代码

func (t *SafeTx) WithContext(ctx context.Context) *SafeTx {
    if t.tx == nil || t.closed.Load() {
        return &SafeTx{tx: nil, closed: atomic.Bool{}}
    }
    // 原子捕获当前 ctx + tx 状态，避免后续竞态
    return &SafeTx{
        tx:     t.tx.WithContext(ctx),
        closed: t.closed,
    }
}

closed.Load() 提供无锁状态读取；返回新实例而非复用，杜绝上下文污染。t.tx.WithContext(ctx) 仅在事务有效时委托，规避 nil pointer dereference。

风险场景	封装后行为
已 Commit/Rollback	返回空 SafeTx，方法静默失败
ctx.Cancelled	后续 Query 返回 context.Canceled
并发 Close + WithContext	原子标志确保一致性

4.2 自动化Context继承检测工具开发（AST分析+go vet插件实战）

核心检测逻辑

利用 golang.org/x/tools/go/analysis 构建静态检查器，遍历函数调用链，识别 context.With* 调用是否源自非参数传入的 ctx（即非 func(ctx context.Context) 的形参）。

AST遍历关键节点

• *ast.CallExpr：匹配 context.WithCancel、WithTimeout 等调用
• *ast.Ident：追溯 ctx 变量定义位置（局部声明 vs 参数）
• *ast.AssignStmt：捕获 ctx := context.Background() 类误用

示例检测代码

func handler(w http.ResponseWriter, r *http.Request) {
    ctx := context.Background() // ❌ 非继承自r.Context()
    child, _ := context.WithTimeout(ctx, time.Second) // → 触发告警
}

逻辑分析：工具通过 pass.TypesInfo.TypeOf(call.Fun) 判定调用目标为 context.WithTimeout；再沿 call.Args[0] 向上解析 ctx 的 types.Object，若其 Pos() 不在函数参数列表中，则标记为“非继承上下文”。

检测结果分类表

问题类型	触发条件	修复建议
静态Context创建	context.Background()/TODO() 直接调用	改用 r.Context() 或传入参数
上游Context丢失	形参未传递至下游 With* 调用	补全 ctx 参数链传递

工具集成流程

graph TD
    A[go vet -vettool=ctxcheck] --> B[Analysis Pass]
    B --> C{AST遍历}
    C --> D[识别With*调用]
    C --> E[溯源ctx变量定义]
    D & E --> F[判定继承关系]
    F --> G[输出诊断信息]

4.3 分布式链路中Cancel信号跨服务保真传递：gRPC metadata + context.WithValue增强策略

在长链路微服务调用中，原生 context.Cancel 无法穿透 gRPC 网络边界——下游服务无法感知上游的取消意图。单纯依赖 context.WithCancel 会导致 cancel 信号在序列化/反序列化过程中丢失。

核心增强策略

• 将 cancel 触发时间戳与唯一 trace-cancel-id 注入 gRPC metadata.MD
• 在 server 拦截器中重建带超时的 context，并用 context.WithValue 注入可审计的取消元数据

// 客户端注入 cancel 元数据（毫秒级精度）
md := metadata.Pairs(
    "x-cancel-timestamp", strconv.FormatInt(time.Now().UnixMilli(), 10),
    "x-cancel-id", uuid.NewString(),
)
ctx = metadata.AppendToOutgoingContext(ctx, md...)

此处 timestamp 用于下游判断 cancel 是否已过期（防重放），x-cancel-id 支持全链路 cancel 审计溯源；gRPC metadata 自动透传，无需修改业务逻辑。

服务端拦截器还原逻辑

func cancelInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
    md, ok := metadata.FromIncomingContext(ctx)
    if !ok || len(md["x-cancel-timestamp"]) == 0 { return handler(ctx, req) }
    ts, _ := strconv.ParseInt(md["x-cancel-timestamp"][0], 10, 64)
    cancelCtx, cancel := context.WithTimeout(ctx, time.Until(time.UnixMilli(ts)))
    defer cancel()
    // 注入可被业务层读取的 cancel 上下文键
    ctx = context.WithValue(cancelCtx, CancelKey, &CancelMeta{ID: md["x-cancel-id"][0], Timestamp: ts})
    return handler(ctx, req)
}

context.WithTimeout 将远端 cancel 时间映射为本地 deadline；CancelKey 是自定义 context.Key 类型，确保业务层可通过 ctx.Value(CancelKey) 安全提取 cancel 元信息。

维度	原生 context	增强方案
跨进程可见性	❌（仅内存有效）	✅（通过 metadata 透传）
可审计性	❌	✅（cancel-id + timestamp）
时效保真度	⚠️（网络延迟导致偏差）	✅（基于绝对时间戳重算 deadline）

graph TD
    A[Client: ctx.WithCancel] --> B[Inject x-cancel-timestamp/x-cancel-id into metadata]
    B --> C[gRPC wire transmission]
    C --> D[Server interceptor: parse metadata]
    D --> E[Rebuild context.WithTimeout using timestamp]
    E --> F[Attach CancelMeta via context.WithValue]
    F --> G[Business handler reads ctx.ValueCancelKey]

4.4 生产环境Context健康度监控体系：cancel latency metric + cancel miss告警规则

Context取消链路的健康度直接决定分布式事务的确定性与资源回收时效。核心指标包含两项：

• cancel_latency_ms：从Cancel信号发出到Context实际终止的P95耗时（单位毫秒）
• cancel_miss_count：1分钟内未被任何CancelHandler捕获的Cancel事件数

数据同步机制

Metric通过OpenTelemetry SDK异步上报至Prometheus，采样率100%（关键路径不降采样）：

# context_cancel_observer.py
from opentelemetry.metrics import get_meter
meter = get_meter("context.lifecycle")
cancel_latency = meter.create_histogram(
    "context.cancel.latency.ms",
    unit="ms",
    description="P95 latency from cancel signal to context termination"
)
# 注：histogram自动聚合为sum/count/bucket，供PromQL计算分位数

告警规则设计

告警项	PromQL表达式	触发阈值
Cancel延迟突增	histogram_quantile(0.95, sum(rate(context_cancel_latency_ms_bucket[5m])) by (le))	> 200ms
Cancel丢失	sum(increase(context_cancel_miss_count[5m]))	> 0

graph TD
    A[Cancel Signal] --> B{Context State}
    B -->|RUNNING| C[CancelHandler invoked]
    B -->|TERMINATED| D[Latency recorded]
    B -->|STALE/MISSING| E[Increment cancel_miss_count]

第五章：从事故到范式——Go系统稳定性建设的再思考

一次凌晨三点的P99毛刺溯源

2023年Q4，某电商订单履约服务在大促前压测中突发P99延迟从80ms跃升至1.2s。日志显示无ERROR，但pprof火焰图暴露出sync.Pool.Get调用栈中存在大量runtime.mallocgc竞争。根本原因是团队为提升JSON序列化性能，将*bytes.Buffer注入全局sync.Pool，却未重置其内部buf切片长度——每次Get后直接WriteString，导致底层底层数组持续扩容，GC压力激增。修复方案仅需两行：b.Reset() + b.Grow(1024)，但暴露了Pool使用范式的缺失。

熔断器不是开关而是调节阀

我们弃用了简单阈值型熔断（如连续5次失败即开启），转而采用Netflix Hystrix风格的滑动窗口统计。以下为生产环境真实配置片段：

breaker := circuit.NewBreaker(circuit.Config{
    Name:        "payment-service",
    FailureRate: 0.3,     // 连续100次请求中失败超30%触发半开
    Timeout:     60 * time.Second,
    ReadyToTrip: func(counts circuit.Counts) bool {
        return counts.Total >= 100 && float64(counts.Failure)/float64(counts.Total) > 0.3
    },
})

该配置使支付下游故障恢复时间从平均8分钟缩短至47秒，关键在于半开状态下的试探请求数动态控制（初始2个，每成功1次+1，上限10）。

SLO驱动的告警降噪实践

过去告警风暴源于“CPU>80%”“GC pause>100ms”等静态阈值。重构后，所有告警绑定SLO指标：

SLO目标	计算方式	告警触发条件	平均降噪率
订单创建P99≤200ms	Prometheus histogram_quantile(0.99, sum(rate(http_request_duration_seconds_bucket{job="order-api"}[1h])) by (le))	连续3个周期偏离目标±15%	63%
库存扣减成功率≥99.95%	1 - rate(order_deduct_failure_total[4h]) / rate(order_deduct_total[4h])	持续15分钟低于99.92%	71%

故障注入常态化机制

在CI/CD流水线中嵌入Chaos Mesh实验：

graph LR
A[代码提交] --> B[自动部署到预发集群]
B --> C{Chaos Experiment}
C -->|网络延迟| D[注入200ms jitter]
C -->|Pod终止| E[随机kill 1个worker]
D --> F[运行30分钟稳定性测试]
E --> F
F -->|通过| G[允许合并到主干]
F -->|失败| H[阻断发布并生成根因报告]

过去半年，该机制提前捕获3类生产环境未暴露问题：etcd leader选举超时导致的配置同步中断、gRPC Keepalive参数不当引发的连接雪崩、Prometheus remote_write队列堆积触发OOMKilled。

可观测性不是日志堆砌而是信号提炼

我们将OpenTelemetry Collector配置为三通道分流：

• 黄金信号通道：仅采集http.status_code、http.duration、rpc.system等5个核心字段，写入专用ClickHouse集群（查询延迟
• 诊断通道：全量trace span，但采样率动态调整（正常期0.1%，异常期自动升至10%）
• 审计通道：记录所有/admin/*接口调用，保留180天

上线后，P1级故障平均定位时间从22分钟压缩至6分17秒，关键改进在于将trace_id与request_id强绑定，并在所有中间件中透传X-B3-TraceId。

架构决策必须附带稳定性契约

每个新组件引入需签署《稳定性契约》，例如引入Redis Cluster替代单点Redis时，明确约定：

• 客户端必须启用ReadOnly模式处理ASK/MOVED重定向
• 所有SET命令强制添加EX 300过期策略
• SCAN操作必须配合COUNT 100且超时中断逻辑
• 每日03:00执行redis-cli --cluster check校验

该契约写入GitLab MR模板，未签署则禁止合并。