Golang可观测性基建缺失代价：一次panic未捕获导致日志丢失37小时——SRE团队紧急回滚方案

第一章：Golang可观测性基建缺失的代价反思

当一个高并发订单服务在凌晨三点突然响应延迟飙升至2.8秒，SRE团队却只能盯着 top 和 netstat 手动排查——这并非虚构场景，而是某电商中台因长期忽视可观测性基建付出的真实代价。Golang 本身轻量、高效，但其默认运行时几乎不暴露关键指标（如 Goroutine 阻塞分布、GC 暂停毛刺、HTTP handler 级别延迟直方图），若未主动集成可观测性组件，系统将退化为“黑盒”。

常见缺失环节及其后果

• 无结构化日志：log.Printf("user %d paid %f") 导致无法按用户ID快速过滤或聚合支付金额；应改用 zerolog 或 zap 输出 JSON 日志，并注入 request_id、service_name 等上下文字段
• 零指标采集：runtime.NumGoroutine() 等基础指标未通过 Prometheus Client 暴露，导致无法建立 Goroutine 泄漏告警
• 无分布式追踪：HTTP 请求跨服务调用时丢失 trace context，使一次超时无法定位是 auth 服务鉴权慢，还是 inventory 服务锁表

立即补救的最小可行实践

1. 引入 prometheus/client_golang 并注册运行时指标：

   
   import (
   "github.com/prometheus/client_golang/prometheus"
   "github.com/prometheus/client_golang/prometheus/promhttp"
   )

func init() { // 自动注册 Go 运行时指标（goroutines, GC, memory） prometheus.MustRegister(prometheus.NewGoCollector()) prometheus.MustRegister(prometheus.NewProcessCollector( prometheus.ProcessCollectorOpts{}, // 默认选项即可 )) } // 在 HTTP 路由中暴露 /metrics http.Handle(“/metrics”, promhttp.Handler())

2. 为每个 HTTP handler 添加延迟直方图：  
```go
// 定义指标（需在包级声明）
var httpDuration = prometheus.NewHistogramVec(
    prometheus.HistogramOpts{
        Name:    "http_request_duration_seconds",
        Help:    "HTTP request duration in seconds",
        Buckets: prometheus.ExponentialBuckets(0.01, 2, 10), // 10ms ~ 5s
    },
    []string{"method", "path", "status"},
)
prometheus.MustRegister(httpDuration)

// 在 middleware 中记录
func metricsMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        rw := &responseWriter{ResponseWriter: w, statusCode: 200}
        next.ServeHTTP(rw, r)
        httpDuration.WithLabelValues(
            r.Method,
            r.URL.Path,
            strconv.Itoa(rw.statusCode),
        ).Observe(time.Since(start).Seconds())
    })
}

缺失维度	生产事故典型表现	排查耗时（平均）
日志无结构	用户投诉“下单失败”但日志无 error 关键字	47 分钟
无指标监控	内存缓慢增长直至 OOM	3.2 小时
无链路追踪	支付回调超时，无法确认卡点	6+ 小时

第二章：Go panic机制与错误处理的深度实践

2.1 Go运行时panic触发原理与栈展开机制剖析

当 panic 被调用，Go 运行时立即终止当前 goroutine 的正常执行流，并启动栈展开（stack unwinding）过程。

panic 的底层入口

// runtime/panic.go 中简化逻辑
func gopanic(e interface{}) {
    gp := getg()                 // 获取当前 goroutine
    gp._panic = &panic{arg: e}   // 创建 panic 结构并链入 goroutine
    for {                        // 循环查找 defer 链
        d := gp._defer
        if d == nil { break }    // 无 defer 则跳过恢复
        calldefer(d)             // 执行 defer 函数
        gp._defer = d.link       // 移至下一个 defer
    }
    fatalpanic(gp._panic)        // 无 recover → 触发 fatal error
}

gopanic 不直接崩溃，而是先遍历 _defer 链表（LIFO），按注册逆序执行 defer；calldefer 会保存寄存器状态并跳转到 defer 函数。

栈展开关键阶段

• 每帧函数检查是否有 defer 记录
• 若遇 recover()，清空当前 panic 并恢复执行
• 否则逐帧弹出，释放栈内存，直至 goroutine 栈耗尽

panic 状态流转示意

graph TD
    A[panic(e)] --> B[挂起当前 goroutine]
    B --> C[遍历 _defer 链表]
    C --> D{遇到 recover?}
    D -->|是| E[清除 panic, 恢复执行]
    D -->|否| F[执行 defer]
    F --> G[弹出栈帧]
    G --> C

阶段	关键数据结构	是否可中断
panic 触发	gp._panic	否
defer 执行	gp._defer 链表	是（recover）
栈帧释放	g0.stack 范围	否

2.2 defer-recover模式在HTTP服务中的工程化封装实践

统一错误拦截层

将 defer-recover 提炼为中间件，避免每个 handler 重复编写：

func Recovery() gin.HandlerFunc {
    return func(c *gin.Context) {
        defer func() {
            if err := recover(); err != nil {
                // 捕获 panic 并转为 500 响应
                c.AbortWithStatusJSON(http.StatusInternalServerError,
                    map[string]string{"error": "internal server error"})
                log.Printf("PANIC: %v", err)
            }
        }()
        c.Next()
    }
}

逻辑分析：defer 确保在 handler 执行完毕（无论是否 panic）后执行；recover() 仅在 goroutine 的 panic 阶段有效；c.Next() 触发后续 handler 链。参数 c *gin.Context 提供响应控制与日志上下文。

封装增强策略对比

特性	基础 defer-recover	工程化封装版本
错误分类响应	❌ 固定 500	✅ 支持 panic 类型路由
日志结构化	❌ 原始字符串	✅ 带 traceID、path 字段
可配置开关	❌ 硬编码	✅ WithDisableLog() 选项

panic 分类处理流程

graph TD
    A[HTTP Request] --> B[Recovery Middleware]
    B --> C{panic occurred?}
    C -->|Yes| D[Inspect panic value]
    D --> E[Error type == UserError?]
    E -->|Yes| F[Return 400 + message]
    E -->|No| G[Return 500 + log]
    C -->|No| H[Normal response]

2.3 全局panic捕获中间件设计：从net/http到gin/echo的适配方案

核心挑战

Go 的 panic 默认终止 HTTP 连接，需在框架抽象层统一拦截并转化为 500 响应。

统一中间件接口抽象

不同框架的中间件签名差异大：

框架	中间件签名	panic 捕获位置
net/http	func(http.Handler) http.Handler	ServeHTTP 包装器内
Gin	gin.HandlerFunc（*gin.Context）	c.Next() 前后
Echo	echo.MiddlewareFunc（echo.Context）	next() 调用包裹

通用 panic 捕获逻辑（Gin 示例）

func Recovery() gin.HandlerFunc {
    return func(c *gin.Context) {
        defer func() {
            if err := recover(); err != nil {
                c.AbortWithStatusJSON(500, gin.H{"error": "internal server error"})
                // 记录 panic 堆栈（生产环境建议用 zap.Error）
                log.Printf("PANIC: %v\n%s", err, debug.Stack())
            }
        }()
        c.Next()
    }
}

逻辑分析：defer 在 c.Next() 执行后触发，确保所有 handler 链执行完毕；c.AbortWithStatusJSON 立即终止后续中间件并返回 JSON；debug.Stack() 提供完整调用链便于定位。

适配演进路径

• 基础：net/http 的 HandlerFunc 包装器 →
• 抽象：定义 RecoveryMiddleware 接口（func(http.Handler) http.Handler + func(echo.Context) error）→
• 泛化：通过函数选项模式注入日志、监控、响应格式策略。

2.4 panic上下文增强：融合goroutine ID、traceID与调用链快照

Go原生panic仅输出堆栈，缺乏可观测性关键维度。增强需在recover捕获瞬间注入上下文。

核心上下文字段

• goroutine ID：通过runtime.Stack解析获取（非官方API，但稳定可用）
• traceID：从context.Context中提取（如OpenTelemetry trace.SpanFromContext）
• callstack snapshot：截取当前goroutine完整调用链（含文件/行号/函数名）

上下文注入示例

func enhancedPanicHandler() {
    if r := recover(); r != nil {
        buf := make([]byte, 4096)
        n := runtime.Stack(buf, false) // false: 当前goroutine only
        stack := string(buf[:n])

        // 提取 goroutine ID (e.g., "goroutine 123 [running]:")
        goid := extractGoroutineID(stack)

        // 假设 ctx 来自 HTTP middleware 透传
        traceID := getTraceIDFromContext(ctx)

        log.Error("panic captured", 
            "goid", goid, 
            "trace_id", traceID, 
            "stack", stack)
    }
}

runtime.Stack(buf, false) 仅捕获当前goroutine，避免全局扫描开销；extractGoroutineID需正则匹配首行，健壮性依赖Go运行时输出格式稳定性。

上下文字段对比表

字段	获取方式	是否必需	传播机制
goroutine ID	runtime.Stack 解析	✅	运行时内置
traceID	ctx.Value(traceKey)	⚠️（若启用分布式追踪）	Context 透传
调用链快照	runtime.Caller() + runtime.FuncForPC	✅	即时采集

graph TD
    A[panic发生] --> B[recover捕获]
    B --> C[获取goroutine ID]
    B --> D[提取traceID]
    B --> E[采集调用链]
    C & D & E --> F[结构化日志输出]

2.5 生产环境panic日志标准化：结构化字段、采样策略与SLO对齐

panic日志不是调试副产品，而是SLO可观测性的关键信标。需强制注入结构化上下文，避免自由文本解析陷阱。

核心字段规范

必需字段包括：service_name、panic_id（UUIDv4）、stack_hash（SHA-256前16字节）、slo_tier（”critical”/”degraded”）、trace_id、timestamp_ns。

采样策略与SLO对齐

SLO Tier	采样率	触发条件
critical	100%	panic in P99 latency path
degraded	5%	non-critical goroutine panic

func logPanic(ctx context.Context, err error) {
    fields := logrus.Fields{
        "service_name": os.Getenv("SERVICE_NAME"),
        "panic_id":     uuid.NewString(),
        "stack_hash":   hashStack(debug.Stack()),
        "slo_tier":     classifyBySLO(ctx), // 基于context中携带的latency budget metadata
        "trace_id":     trace.SpanFromContext(ctx).SpanContext().TraceID().String(),
        "timestamp_ns": time.Now().UnixNano(),
    }
    log.WithFields(fields).Fatal("panic captured")
}

该函数确保每条panic日志携带可聚合、可告警、可归因的元数据；classifyBySLO依据请求SLA预算动态判定tier，使采样逻辑与业务可靠性目标实时对齐。

数据同步机制

graph TD
    A[panic occurrence] --> B{SLO tier?}
    B -->|critical| C[send to ES + alerting]
    B -->|degraded| D[send to Kafka → sampled sink]

第三章：日志丢失根因分析与Go日志生命周期治理

3.1 Go标准库log与第三方日志库（zap/logrus）的缓冲区行为对比实验

Go 标准库 log 默认无内存缓冲，每条日志直接写入 Writer（如 os.Stderr），同步阻塞；而 logrus 默认使用 io.MultiWriter + os.Stderr，亦无内置缓冲；zap（尤其是 zap.NewProduction()）则启用 ring buffer + 异步 worker goroutine，批量刷盘。

数据同步机制

• log: 同步写，无缓冲 → 高延迟、低吞吐
• logrus: 可通过 logrus.SetOutput(ioutil.Discard) + 自定义 io.Writer 注入缓冲，但非默认行为
• zap: 内置 zapcore.LockingBuffer + zapcore.WriteSyncer 封装，支持 BufferCore 批量提交

性能关键参数对比

库	默认缓冲	同步模式	可配置缓冲大小
log	❌	✅（强制）	❌
logrus	❌	✅	✅（需自定义 Writer）
zap	✅（16KB ring）	⚠️（异步+sync.Pool）	✅（zapcore.NewLockingBuffer）

// zap 自定义缓冲区示例（128KB ring buffer）
buf := zapcore.NewLockingBuffer(zapcore.AddSync(os.Stdout), 128*1024)
core := zapcore.NewCore(zapcore.JSONEncoder{}, buf, zapcore.InfoLevel)
logger := zap.New(core)

该代码显式构造带容量的 LockingBuffer，避免默认 16KB 限制；AddSync 确保线程安全写入，128*1024 指定环形缓冲区字节上限，超限时触发 flush 并阻塞生产者。

3.2 日志异步刷盘失效场景复现：os.Stderr关闭、容器SIGTERM截断、stdout重定向陷阱

数据同步机制

Go 标准日志默认使用 os.Stderr，其底层 file.Write() 在文件描述符关闭后静默失败，异步 goroutine 无法感知。

// 模拟 stderr 被意外关闭
func simulateStderrClose() {
    os.Stderr.Close() // 关闭后 Write() 返回 nil error，但数据丢失
    log.Print("this will vanish silently") // 实际未写入任何介质
}

os.Stderr.Close() 使对应 fd=2 失效；log.Print 调用 write(2, ...) 返回 字节（Linux syscall 行为），标准库不校验写入长度，导致日志“蒸发”。

容器生命周期陷阱

场景	SIGTERM 响应行为	刷盘风险
无信号处理	进程立即终止	pending buffer 全丢
仅 defer close	无时间 flush 异步队列	缓冲区残留未落盘

重定向链路断裂

# 危险重定向：覆盖 stdout 后 stderr 仍指向原终端，但父进程可能已销毁
./app 1>/dev/null 2>&1 &

此时 os.Stderr 的 fd 指向 /dev/null，但 log.SetOutput() 若未显式绑定，仍依赖原始 stderr —— 容器 init 进程退出时该 fd 可被内核回收。

graph TD A[应用启动] –> B[日志写入stderr缓冲区] B –> C{stderr fd 是否有效？} C –>|关闭/重定向| D[Write 返回0, 无错误] C –>|有效| E[内核排队刷盘] D –> F[日志永久丢失]

3.3 日志生命周期全链路保障：从log.Print到syslog/rsyslog/loki的端到端可靠性验证

日志不可丢、不可乱、不可延——这是生产级可观测性的铁律。从 Go 原生 log.Print 出发，需经缓冲控制、协议封装、传输加固、落盘持久化、集中索引五大关卡。

数据同步机制

Go 应用通过 syslog.Writer 将日志转发至 rsyslog：

// 使用 UDP+重试+本地缓冲确保基础可达性
w, _ := syslog.Dial("udp", "10.0.1.5:514", syslog.LOG_INFO, "myapp")
log.SetOutput(w)

Dial 中 "udp" 表示无连接传输；"10.0.1.5:514" 为 rsyslog 接收地址；LOG_INFO 设定默认优先级；"myapp" 成为 facility 标识，影响 rsyslog 的 $programname 过滤规则。

可靠性增强对比

组件	丢包容忍	时序保证	持久化能力
log.Print	❌	❌	❌
rsyslog (UDP)	⚠️（需配置$ActionQueue）	⚠️（需$ActionExecOnlyWhenPreviousIsSuspended off）	✅（磁盘队列）
Loki (via Promtail)	✅（内置 WAL + 重试）	✅（__timestamp__ 显式注入）	✅（分块压缩存储）

全链路验证流程

graph TD
    A[log.Print] --> B[syscall.Syslog / UDP/TCP]
    B --> C[rsyslog: 队列→过滤→转发]
    C --> D[Loki: Promtail采集→HTTP批量推送到 /loki/api/v1/push]
    D --> E[Query: LogQL 检索 + 跨租户隔离]

第四章：SRE驱动的Go可观测性基建重建方案

4.1 基于OpenTelemetry的Go服务自动埋点与panic事件关联追踪

Go服务中，panic常导致链路断裂。OpenTelemetry通过recover钩子与span.SetStatus()联动，实现异常上下文自动注入。

panic捕获与Span标注

func wrapHandler(h http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        span := trace.SpanFromContext(ctx)
        defer func() {
            if err := recover(); err != nil {
                span.RecordError(fmt.Errorf("panic: %v", err))
                span.SetStatus(codes.Error, "panic occurred")
                span.SetAttributes(attribute.String("panic.value", fmt.Sprintf("%v", err)))
            }
        }()
        h.ServeHTTP(w, r)
    })
}

该中间件在HTTP handler入口注册defer recover()，捕获panic后调用RecordError和SetStatus，确保错误属性写入当前Span，并透传至后端（如Jaeger/Tempo）。

关键属性映射表

属性名	类型	说明
exception.type	string	panic类型（如runtime.error）
exception.message	string	panic值字符串表示
exception.stacktrace	string	可选：手动注入堆栈

追踪链路增强流程

graph TD
    A[HTTP请求] --> B[otelhttp middleware]
    B --> C[业务handler]
    C --> D{panic?}
    D -->|Yes| E[recover + span.RecordError]
    D -->|No| F[正常返回]
    E --> G[Span携带error.status=true]
    G --> H[后端聚合展示panic链路]

4.2 可观测性三支柱协同：panic事件→指标突增告警→日志上下文回溯的闭环设计

当 Go 服务触发 panic，需瞬时联动指标、日志与链路：

panic 捕获与指标上报

func recoverPanic() {
    defer func() {
        if r := recover(); r != nil {
            // 上报 panic 计数 + 栈帧深度（关键维度）
            panicCounter.WithLabelValues(
                runtime.Version(), // Go 版本
                getServiceName(),  // 服务标识
            ).Inc()
            log.Error("panic recovered", "stack", debug.Stack())
        }
    }()
}

该函数在 HTTP handler 入口统一注入，WithLabelValues 支持按版本/服务多维下钻；debug.Stack() 提供原始栈用于日志关联。

三支柱闭环流程

graph TD
    A[panic 发生] --> B[metrics: panic_total++]
    B --> C{告警引擎检测突增}
    C -->|触发| D[查询最近5min error logs]
    D --> E[提取 trace_id / request_id]
    E --> F[关联分布式追踪 span]

关键协同参数对照表

维度	指标侧字段	日志侧字段	追踪侧字段
唯一标识	service_name	service	service.name
时间精度	timestamp_ms	@timestamp	start_time
上下文锚点	trace_id label	trace_id field	trace_id

4.3 紧急回滚中的可观测性降级策略：轻量级panic捕获器与内存日志缓冲区兜底

当系统进入紧急回滚路径时，完整可观测链路（如分布式追踪、指标上报、远程日志）往往因资源枯竭或依赖不可用而失效。此时需启用降级策略，保障关键故障信号不丢失。

轻量级 panic 捕获器

func init() {
    // 替换默认 panic 处理器，避免 runtime 崩溃时日志丢失
    debug.SetPanicOnFault(true)
    http.DefaultServeMux.HandleFunc("/_panic", handlePanicReport)
}

func handlePanicReport(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(200)
    io.WriteString(w, "panic captured: " + atomic.LoadString(&lastPanicMsg))
}

该捕获器绕过标准 recover() 链路，直接监听 runtime 级异常信号；lastPanicMsg 为原子写入的全局字符串，规避锁竞争与内存分配——适用于 CPU/内存双高压场景。

内存日志缓冲区兜底机制

缓冲区类型	容量	刷盘触发条件	丢弃策略
RingBuffer	16KB	满或 5s 定时	LRU 覆盖旧条目
EmergencyLog	4KB	panic 发生瞬间	不覆盖，仅追加

graph TD
    A[panic 触发] --> B[原子写入 lastPanicMsg]
    B --> C[RingBuffer 追加结构化错误帧]
    C --> D{是否启用了 emergency flush?}
    D -->|是| E[同步刷入 /dev/shm/log.emg]
    D -->|否| F[等待下一次健康检查周期]

4.4 Go Module依赖树可观测性：识别log/zap/opentelemetry等关键组件版本兼容性风险

Go 模块依赖树中，log、zap 与 opentelemetry-go 的版本组合常引发静默兼容性问题——例如 otelprometheus v0.40+ 要求 otel/sdk v1.22+，而旧版 zapotel v1.3 仅适配 otel/sdk v1.17。

依赖冲突诊断命令

# 展示 zap 与 otel 的直接/间接依赖路径
go mod graph | grep -E "(zap|otel)" | head -10

该命令输出模块间引用边，可快速定位 go.uber.org/zap 是否经由 go.opentelemetry.io/contrib/instrumentation/github.com/uber-go/zap 间接引入不匹配的 otel 版本。

兼容性矩阵（关键组合）

zap 版本	otel/sdk 版本	opentelemetry-go 贡献包	状态
v1.25+	v1.22+	v0.40+	✅ 安全
v1.21	v1.17	v0.34	⚠️ 边界

自动化检测流程

graph TD
  A[go list -m all] --> B{匹配 zap/otel 模块}
  B --> C[提取语义化版本]
  C --> D[查表校验兼容性]
  D --> E[输出风险节点]

第五章：从事故中沉淀的Go工程化认知升级

一次因time.AfterFunc导致的内存泄漏事故

某支付对账服务在上线两周后出现持续内存增长，PProf堆采样显示大量runtime.goroutine和timer对象堆积。根因定位到一段看似无害的代码：

func scheduleRetry(orderID string, delay time.Duration) {
    time.AfterFunc(delay, func() {
        processOrder(orderID) // 可能失败，但未做重试控制
    })
}

问题在于：当processOrder因网络超时反复失败时，每次调用都注册新定时器，而旧定时器未被显式Stop()，导致goroutine与timer对象无法GC。修复方案采用*time.Timer并统一管理生命周期：

var retryTimers sync.Map // map[string]*time.Timer

func scheduleRetry(orderID string, delay time.Duration) {
    if t, loaded := retryTimers.Load(orderID); loaded {
        t.(*time.Timer).Stop()
    }
    t := time.NewTimer(delay)
    retryTimers.Store(orderID, t)
    go func() {
        <-t.C
        retryTimers.Delete(orderID)
        processOrder(orderID)
    }()
}

日志上下文透传失效引发的链路断裂

在微服务调用链中，OpenTelemetry SpanContext未能跨goroutine传递，导致下游服务日志丢失traceID。根本原因在于使用了logrus.WithField()而非logrus.WithContext(ctx)，且未在go func()中显式传入context：

// 错误写法
go func() {
    log.WithField("order_id", id).Info("start processing") // ctx丢失
}()

// 正确写法
go func(ctx context.Context) {
    log.WithContext(ctx).WithField("order_id", id).Info("start processing")
}(req.Context())

并发安全的配置热更新实践

某网关服务通过HTTP接口动态更新路由规则，早期采用全局map[string]Route直接赋值，引发fatal error: concurrent map writes。重构后引入原子指针切换与读写锁组合：

方案	读性能	写开销	实现复杂度	适用场景
sync.RWMutex + map	高（读不阻塞）	中（写需锁全表）	低	QPS
atomic.Value + immutable struct	极高（无锁读）	高（每次全量拷贝）	中	配置变更
sharded map + sync.Map	中（分片降低竞争）	低（局部锁）	高	大规模动态路由

最终选择atomic.Value方案，将路由表封装为不可变结构体，更新时构造新实例并原子替换：

type RouteTable struct {
    byPath  map[string]Route
    byHost  map[string][]Route
    version uint64
}

var routeTable atomic.Value // 存储*RouteTable

func updateRoutes(newRoutes []Route) {
    t := &RouteTable{
        byPath:  make(map[string]Route),
        byHost:  make(map[string][]Route),
        version: atomic.AddUint64(&globalVersion, 1),
    }
    // ... 构建映射关系
    routeTable.Store(t)
}

panic恢复机制的边界条件验证

某RPC框架在recover()中尝试记录panic堆栈，但未处理runtime.Goexit()触发的伪panic，导致goroutine静默退出。通过runtime.Caller()逐帧检查函数名，过滤掉runtime.goexit及testing.tRunner等测试框架调用栈：

func safeRecover() {
    if r := recover(); r != nil {
        pc, _, _, ok := runtime.Caller(1)
        if !ok {
            log.Error("failed to get caller info during recover")
            return
        }
        fn := runtime.FuncForPC(pc)
        if fn != nil && strings.Contains(fn.Name(), "runtime.goexit") {
            return // 忽略Goexit引发的recover
        }
        log.Panic("goroutine panicked", "error", r, "stack", debug.Stack())
    }
}

熔断器状态持久化缺失的连锁反应

熔断器状态仅保存在内存中，K8s滚动更新后所有实例重置为CLOSED状态，瞬间涌入大量请求击穿下游。改造为基于Redis的分布式状态存储，并增加本地缓存层降低RT：

graph LR
    A[HTTP Request] --> B{Circuit Breaker}
    B -->|State=OPEN| C[Return 503]
    B -->|State=HALF_OPEN| D[Allow 1% traffic]
    B -->|State=CLOSED| E[Forward to upstream]
    D --> F[Record success/failure in Redis]
    F --> G[Update local state via pub/sub]