【Go语言请求重试黄金法则】：20年SRE亲授生产级重试策略与5大避坑指南

第一章：Go语言请求重试的核心原理与设计哲学

Go语言中请求重试并非简单地循环调用HTTP客户端，而是围绕“失败可恢复性”与“系统韧性”构建的一套协同机制。其底层哲学强调显式控制优于隐式行为——标准库net/http本身不提供重试逻辑，迫使开发者主动建模错误类型、退避策略与终止条件，从而避免盲目重试加剧下游压力或掩盖真实故障。

重试的触发边界需精确识别

并非所有错误都适合重试。典型可重试场景包括：

• 网络层临时中断（net.OpError，如i/o timeout、connection refused）
• HTTP 5xx服务端错误（如502 Bad Gateway、503 Service Unavailable）
• 特定4xx错误（如429 Too Many Requests，配合Retry-After头）
  而400 Bad Request、401 Unauthorized等客户端语义错误应立即终止。

指数退避是默认实践准则

线性重试易引发雪崩，Go生态普遍采用带抖动的指数退避。以下代码演示使用backoff.Retry实现安全重试：

import (
    "net/http"
    "time"
    "github.com/cenkalti/backoff/v4"
)

func fetchWithBackoff(url string) error {
    operation := func() error {
        resp, err := http.Get(url)
        if err != nil {
            // 仅对网络错误重试
            if netErr, ok := err.(*net.OpError); ok && netErr.Err != nil {
                return backoff.Permanent(err) // 标记为不可重试
            }
            return err // 其他错误交由backoff判断
        }
        defer resp.Body.Close()
        if resp.StatusCode >= 500 || resp.StatusCode == 429 {
            return fmt.Errorf("server error: %d", resp.StatusCode)
        }
        return nil // 成功则退出
    }

    // 配置指数退避：初始100ms，最大2s，最多5次
    b := backoff.NewExponentialBackOff()
    b.MaxElapsedTime = 10 * time.Second
    return backoff.Retry(operation, b)
}

上下文与超时必须全程贯穿

每次重试尝试都应绑定独立上下文，防止单次请求阻塞全局重试周期。标准做法是为每次http.Do传入带超时的context.WithTimeout，而非依赖外层长生命周期上下文。

组件	推荐实践
错误分类	使用errors.Is()匹配net.ErrClosed等标准错误变量
重试计数	通过闭包或结构体字段显式跟踪，避免状态泄漏
日志记录	每次重试前记录attempt=1/5, error="timeout"

第二章：构建生产级重试机制的五大支柱

2.1 指数退避+抖动策略：理论推导与go-net/http实战封装

当 HTTP 客户端遭遇 429 或连接超时，朴素重试会引发雪崩。指数退避（Exponential Backoff）将重试间隔按 $t_n = \min(\text{base} \times 2^n, \text{max})$ 增长，但固定节奏仍易导致同步重试风暴——抖动（Jitter）通过随机化打破周期性。

核心思想

• 指数增长抑制重试频次
• 均匀/全抖动注入随机性，降低集群共振概率

Go 实战封装示例

func WithJitterBackoff(base time.Duration, max time.Duration, jitter float64) func(int) time.Duration {
    return func(attempt int) time.Duration {
        if attempt == 0 {
            return 0
        }
        backoff := math.Min(float64(max), float64(base)*math.Pow(2, float64(attempt-1)))
        // 全抖动：[0, backoff) 均匀随机
        return time.Duration(backoff * rand.Float64() * jitter)
    }
}

base 是首次退避基准（如 100ms），max 防止无限增长（如 3s），jitter=1.0 启用全抖动。rand.Float64() 引入 [0,1) 随机因子，使各实例退避时间呈离散分布。

退避策略对比

策略	同步风险	实现复杂度	适用场景
固定间隔	高	低	调试/单点测试
纯指数退避	中	中	低并发内部服务
指数+全抖动	低	中	生产级 HTTP 客户端

graph TD
    A[请求失败] --> B{attempt < maxRetries?}
    B -->|是| C[计算 jittered delay]
    C --> D[time.Sleep]
    D --> E[重试请求]
    E --> A
    B -->|否| F[返回错误]

2.2 上下文超时协同：Context Deadline/Cancel 与重试生命周期的精准对齐

在分布式调用中，超时必须贯穿整个重试链路，而非仅作用于单次请求。

为什么单次超时不够？

• 重试会累积耗时，易突破业务 SLA；
• context.WithTimeout 创建的 deadline 是绝对时间点，天然支持跨轮次校验；
• context.CancelFunc 可在任意重试失败后主动终止后续尝试。

重试生命周期与 Context 协同模型

func doWithRetry(ctx context.Context, req *Request) (*Response, error) {
    var lastErr error
    for i := 0; i < 3; i++ {
        select {
        case <-ctx.Done(): // 全局 deadline 触发或手动 cancel
            return nil, ctx.Err() // 返回 context.Canceled 或 context.DeadlineExceeded
        default:
        }
        resp, err := callAPI(ctx, req) // 传入同一 ctx，所有子调用共享 deadline
        if err == nil {
            return resp, nil
        }
        lastErr = err
        time.Sleep(backoff(i))
    }
    return nil, lastErr
}

逻辑分析：ctx 在首次创建时绑定 deadline（如 context.WithDeadline(parent, time.Now().Add(2*time.Second))），每次 callAPI 内部若使用 http.NewRequestWithContext(ctx, ...)，其底层 TCP 连接、TLS 握手、读写均受该 deadline 约束。重试循环中的 select 实时感知上下文状态，避免无效轮次。

超时阶段对齐示意

阶段	是否受 ctx 控制	说明
重试决策间隔	否	time.Sleep() 独立执行
单次 HTTP 请求	是	http.Client.Timeout 可省略，由 ctx 统一兜底
错误传播路径	是	ctx.Err() 优先于具体错误返回

graph TD
    A[启动重试] --> B{ctx.Done?}
    B -->|是| C[立即返回 ctx.Err]
    B -->|否| D[执行第i次调用]
    D --> E{成功?}
    E -->|是| F[返回响应]
    E -->|否| G[计算退避延迟]
    G --> H[递增i并循环]

2.3 错误分类决策模型：可重试错误识别（如503/timeout/ConnReset）与go-errors包定制判别器

在分布式调用中，盲目重试会加剧雪崩。需基于语义精准识别可重试错误。

核心判别维度

• HTTP 状态码：503, 429, 500（部分场景）
• 底层连接错误：net.OpError 中含 i/o timeout 或 connection reset by peer
• 上下文信号：context.DeadlineExceeded、context.Canceled

go-errors 自定义判别器示例

func IsRetryable(err error) bool {
    var e *errors.Error
    if errors.As(err, &e) {
        return e.Code == "SERVICE_UNAVAILABLE" || e.Code == "RATE_LIMITED"
    }
    var netErr net.Error
    if errors.As(err, &netErr) {
        return netErr.Timeout() || netErr.Temporary()
    }
    return strings.Contains(err.Error(), "connection reset") ||
           strings.Contains(err.Error(), "i/o timeout")
}

该函数优先匹配结构化错误码，再降级检测底层网络错误；Timeout() 判定瞬时超时，Temporary() 捕获临时性连接中断，避免对永久性错误（如 404）误判。

可重试错误类型对照表

错误类型	是否可重试	典型原因
503 Service Unavailable	✅	后端过载或维护中
i/o timeout	✅	网络抖动或服务响应慢
connection reset	✅	连接被中间设备强制关闭
404 Not Found	❌	资源不存在，重试无意义

graph TD
    A[原始错误] --> B{是否为结构化错误？}
    B -->|是| C[检查错误码]
    B -->|否| D[尝试类型断言 net.Error]
    C --> E[匹配 SERVICE_UNAVAILABLE / RATE_LIMITED]
    D --> F[调用 Timeout\(\) / Temporary\(\)]
    E --> G[返回 true]
    F --> G

2.4 重试状态持久化：内存限流器（rate.Limiter）与分布式场景下Redis-backed重试计数器实现

在单机服务中，golang.org/x/time/rate.Limiter 提供轻量级令牌桶限流，但其状态驻留内存，重启即丢失，无法支撑重试次数的跨请求/跨实例一致性追踪。

内存限流器的局限性

• ✅ 低延迟、零依赖
• ❌ 不支持重试计数持久化
• ❌ 无法感知其他实例的重试行为

Redis-backed 重试计数器实现

func IncrRetryCount(ctx context.Context, key string, maxRetries int, ttl time.Duration) (int, error) {
    script := redis.NewScript(`
        local count = redis.call("INCR", KEYS[1])
        if count == 1 then
            redis.call("EXPIRE", KEYS[1], ARGV[1])
        end
        return count
    `)
    result, err := script.Run(ctx, rdb, []string{key}, ttl.Seconds()).Int()
    if err != nil {
        return 0, err
    }
    if result > maxRetries {
        return result, errors.New("retry limit exceeded")
    }
    return result, nil
}

逻辑分析：使用 Lua 脚本保证 INCR + EXPIRE 原子性；KEYS[1] 为唯一重试键（如 "retry:order:123"）；ARGV[1] 是 TTL 秒数，避免脏数据累积。首次递增时设置过期，后续仅计数。

对比：两种方案核心维度

维度	rate.Limiter	Redis-backed 计数器
状态持久性	❌ 内存易失	✅ 自动过期+原子写入
分布式一致性	❌ 无共享状态	✅ 全局唯一键保障
延迟开销	~100ns	~1–5ms（网络 RTT）

graph TD
    A[客户端发起重试] --> B{是否超过最大重试次数？}
    B -->|否| C[执行业务逻辑]
    B -->|是| D[返回 429 Too Many Requests]
    C --> E[成功/失败]
    E -->|失败| F[调用 IncrRetryCount]
    F --> B

2.5 并发安全重试控制器：sync.Once + atomic.Value在高并发HTTP客户端中的无锁状态管理

核心设计思想

避免锁竞争，将「重试策略初始化」与「运行时状态读写」分离：sync.Once 保障单次初始化，atomic.Value 零开销承载不可变重试配置。

状态模型对比

方案	初始化线程安全	运行时读性能	内存分配	适用场景
sync.RWMutex	✅	❌（读需Acquire）	低	动态可变配置
sync.Once + atomic.Value	✅	✅（纯指针加载）	一次	静态重试策略

关键实现代码

type RetryController struct {
    once sync.Once
    cfg  atomic.Value // 存储 *retryConfig，不可变
}

func (rc *RetryController) Init(cfg retryConfig) {
    rc.once.Do(func() {
        rc.cfg.Store(&cfg) // 仅执行一次，后续所有goroutine看到同一地址
    })
}

func (rc *RetryController) GetMaxRetries() int {
    return *(rc.cfg.Load().(*retryConfig)).MaxRetries // 原子加载 + 解引用
}

逻辑分析：atomic.Value.Store() 要求传入指针，确保 Load() 返回的始终是同一内存地址；retryConfig 定义为值类型，初始化后禁止修改，天然线程安全。GetMaxRetries 无锁路径耗时 50k 的 HTTP 客户端。

执行流程（mermaid）

graph TD
    A[Client发起请求] --> B{是否需要重试？}
    B -->|是| C[调用 GetMaxRetries]
    C --> D[atomic.Load → 直接读指针]
    D --> E[返回预设重试次数]
    B -->|否| F[正常响应]

第三章：Go标准库与主流生态工具深度解析

3.1 net/http Transport层重试盲区剖析与RoundTripper自定义实践

net/http 默认 Transport 不自动重试任何请求——包括连接超时、TLS握手失败、或临时性 502/503 响应。这是被广泛误解的“重试盲区”。

为什么默认不重试？

• HTTP 方法幂等性语义由上层控制（如仅对 GET/HEAD 安全重试）；
• 连接层错误（如 net.OpError）未被 http.Transport 捕获重试逻辑；
• RoundTrip 返回错误即终止，无重试钩子。

自定义 RoundTripper 实践

type RetryRoundTripper struct {
    Base http.RoundTripper
    MaxRetries int
}

func (r *RetryRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
    var resp *http.Response
    var err error
    for i := 0; i <= r.MaxRetries; i++ {
        resp, err = r.Base.RoundTrip(req)
        if err == nil && resp.StatusCode < 500 { // 非服务端错误则退出
            return resp, nil
        }
        if i == r.MaxRetries {
            break
        }
        time.Sleep(time.Second * time.Duration(1<<uint(i))) // 指数退避
    }
    return resp, err
}

该实现拦截所有 RoundTrip 调用，在发生网络错误或服务端错误时执行指数退避重试；Base 可复用默认 http.DefaultTransport，确保连接池、Keep-Alive 等机制不受影响。

错误类型	是否重试	原因
net/http: request canceled	否	用户主动取消，不可重入
i/o timeout	是	临时网络抖动，可恢复
503 Service Unavailable	是	服务瞬时过载，典型重试场景

graph TD
    A[发起请求] --> B{RoundTrip}
    B --> C[成功响应]
    B --> D[错误]
    D --> E{是否可重试？}
    E -->|是| F[休眠+重试]
    E -->|否| G[返回错误]
    F --> B

3.2 github.com/hashicorp/go-retryablehttp源码级拆解与企业级增强改造

go-retryablehttp 的核心在于将标准 net/http.Client 封装为具备指数退避、状态码重试判定与上下文感知能力的健壮客户端。其 Client.Do() 实际委托给内部 http.Client，但前置执行 c.CheckRetry(resp, err) 判定是否重试。

关键增强点

• 支持自定义 CheckRetry 函数，可基于 HTTP 状态码、错误类型、响应头（如 Retry-After）动态决策
• 透明集成 Backoff 策略，支持 Linear, Exponential, Polly-style 插件化扩展
• 企业级需求驱动的增强：熔断注入、请求标签透传、全链路 trace ID 注入

核心重试判定逻辑（简化版）

// 自定义 CheckRetry 示例：跳过 401/403，对 5xx + 429 启用退避
func enterpriseRetryPolicy(ctx context.Context, resp *http.Response, err error) (bool, error) {
    if err != nil { return true, nil } // 连接层错误一律重试
    if resp.StatusCode >= 500 || resp.StatusCode == 429 {
        return true, nil // 触发退避重试
    }
    if resp.StatusCode == 401 || resp.StatusCode == 403 {
        return false, errors.New("auth failure: no retry") // 显式拒绝
    }
    return false, nil
}

该函数在每次请求后被调用，返回 (shouldRetry, retryErr)；若 retryErr != nil，则终止重试并透出该错误，便于上层做差异化错误处理。

增强维度	原生能力	企业级扩展
重试判定	✅	✅ 支持 Header/Body 检查
超时继承	✅	✅ Context deadline 透传
指标埋点	❌	✅ Prometheus Counter/Gauge 自动注册

graph TD
    A[Do(req)] --> B{CheckRetry?}
    B -->|true| C[Backoff Wait]
    C --> D[Clone Request]
    D --> E[Transport.RoundTrip]
    E --> B
    B -->|false| F[Return Response/Error]

3.3 Go 1.22+ httpclient.WithRetry扩展提案前瞻与本地polyfill实现

Go 官方尚未在 net/http 中内置重试机制，但社区已就 httpclient.WithRetry 提案展开 RFC 讨论（golang/go#62789），目标是为 http.Client 构建可组合、上下文感知的重试策略。

核心设计原则

• 非侵入式：不修改现有 http.Client 接口
• 可组合：支持与 WithTimeout、WithHeader 等其他选项链式叠加
• 可观测：暴露重试次数、失败原因等诊断字段

本地 polyfill 实现（带指数退避）

type RetryOption func(*retryConfig)

type retryConfig struct {
    maxRetries int
    baseDelay  time.Duration
}

func WithRetry(max int, base time.Duration) RetryOption {
    return func(c *retryConfig) {
        c.maxRetries = max
        c.baseDelay = base
    }
}

// 使用示例（需包装 RoundTripper）
func NewRetryClient(opts ...RetryOption) *http.Client {
    cfg := &retryConfig{maxRetries: 3, baseDelay: 100 * time.Millisecond}
    for _, opt := range opts {
        opt(cfg)
    }
    return &http.Client{
        Transport: &retryTransport{
            base:   http.DefaultTransport,
            config: cfg,
        },
    }
}

逻辑分析：该 polyfill 将重试逻辑封装在自定义 RoundTripper 中。retryTransport.RoundTrip 捕获 url.Error 或 context.DeadlineExceeded，按 cfg.maxRetries 循环重试，每次延迟为 baseDelay * 2^attempt。关键参数：maxRetries 控制上限（避免雪崩），baseDelay 决定初始退避粒度（建议 ≥100ms 防止高频冲击）。

当前提案 vs polyfill 对比

维度	官方提案（草案）	本地 polyfill
配置方式	httpclient.WithRetry(3, httpclient.ExponentialBackoff)	自定义函数式选项
上下文传播	✅ 自动继承请求 context	✅ 手动传递（req.Context()）
错误分类策略	内置 HTTP 429/5xx + 网络错误	需手动扩展判断逻辑

graph TD
    A[发起 HTTP 请求] --> B{是否失败？}
    B -- 是 --> C[检查是否可重试<br/>（状态码/错误类型）]
    C -- 否 --> D[返回原始错误]
    C -- 是 --> E[计算退避延迟]
    E --> F[等待后重试]
    F --> B
    B -- 否 --> G[返回响应]

第四章：SRE视角下的重试可观测性与治理闭环

4.1 Prometheus指标埋点：重试次数、延迟分布、失败原因标签化（Go pprof + custom metrics）

核心指标设计原则

• 重试次数：counter 类型，按 endpoint 和 reason（如 timeout/5xx）双维度打标
• 延迟分布：histogram，分桶 [10ms, 50ms, 200ms, 1s, 5s]，标签含 status_code
• 失败原因：gauge + label_values，动态捕获错误码（err_network, err_validation）

自定义指标注册示例

// 定义指标
var (
    httpRetryCount = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "http_client_retries_total",
            Help: "Total number of HTTP client retries",
        },
        []string{"endpoint", "reason"}, // 关键标签维度
    )
    httpRequestDuration = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "http_request_duration_seconds",
            Help:    "HTTP request latency distribution",
            Buckets: []float64{0.01, 0.05, 0.2, 1.0, 5.0},
        },
        []string{"endpoint", "status_code"},
    )
)

func init() {
    prometheus.MustRegister(httpRetryCount, httpRequestDuration)
}

逻辑分析：CounterVec 支持多维计数，reason 标签使重试归因可下钻；HistogramVec 的 Buckets 设置需覆盖业务 P99 延迟，避免桶过密（影响 cardinality）或过疏（丢失精度）。MustRegister 确保启动时校验唯一性。

指标采集与 pprof 协同

场景	Prometheus 指标	pprof 关联点
高重试率 + 高延迟	http_client_retries_total{reason="timeout"} ↑	goroutine / mutex profile 分析阻塞根源
失败突增	http_client_retries_total{reason="5xx"} ↑	trace profile 定位下游异常调用链

graph TD
    A[HTTP 请求] --> B{成功？}
    B -->|否| C[记录 retry_count + reason 标签]
    B -->|是| D[记录 duration + status_code]
    C & D --> E[Prometheus Exporter]
    E --> F[pprof /debug/pprof/heap]
    F --> G[关联分析内存泄漏与重试放大效应]

4.2 分布式链路追踪集成：OpenTelemetry Span中注入重试事件与重试层级标记

在高可用服务中，重试逻辑常导致链路失真。OpenTelemetry 允许通过 addEvent() 显式记录重试行为，并利用 Span.setAttribute() 标记重试层级。

重试事件注入示例

span.addEvent("retry_attempt", Attributes.builder()
    .put("retry.attempt", attemptCount)        // 当前重试次数（如 1, 2, 3）
    .put("retry.reason", "UNAVAILABLE")        // 触发原因（gRPC 状态码映射）
    .put("retry.backoff_ms", backoffMs)        // 指数退避毫秒值
    .build());

该事件将作为时间点快照嵌入 Span 生命周期，确保可观测性不丢失上下文；attemptCount 由业务重试器维护，backoffMs 需与实际 sleep 时长一致以保障时序可信。

重试层级语义标记

属性名	类型	说明
retry.level	string	"primary" / "fallback"
retry.parent_span_id	string	上层重试 Span ID（可选）

graph TD
    A[初始请求 Span] --> B[第一次重试 Span]
    B --> C[降级兜底 Span]
    C --> D[最终成功]
    B -.->|retry.level=“primary”| A
    C -.->|retry.level=“fallback”| B

4.3 告警熔断联动：基于重试失败率动态降级与go-gin中间件自动fallback策略

当核心依赖服务连续失败，传统固定阈值熔断易误触发。我们采用滑动窗口统计最近60秒内重试失败率（failures / (successes + failures)），超45%即触发降级。

动态熔断状态机

// 熔断器核心判断逻辑
func (c *CircuitBreaker) ShouldTrip() bool {
    window := c.metrics.GetRollingWindow(60 * time.Second)
    if window.Total() == 0 { return false }
    failRate := float64(window.Failures()) / float64(window.Total())
    return failRate > 0.45 // 可热更新配置
}

逻辑分析：基于 go-kit/metrics 滚动窗口，避免瞬时抖动；failRate 计算剔除超时未返回请求，仅统计明确失败/成功响应；阈值支持运行时通过 etcd 动态下发。

Gin 中间件自动 fallback 流程

graph TD
    A[HTTP 请求] --> B{熔断器状态}
    B -- Closed --> C[调用原服务]
    B -- Open --> D[执行 fallback 函数]
    C -- 成功 --> E[更新指标]
    C -- 失败 --> F[更新指标并检查 ShouldTrip]
    D --> G[返回兜底 JSON]

fallback 策略配置表

场景	原接口响应	Fallback 行为
用户查询失败	503 + error msg	返回缓存中 5 分钟内旧数据
订单创建超时	504	返回预生成的离线订单号+提示

4.4 重试配置中心化治理：Viper+etcd热加载重试策略（最大次数/退避基数/错误白名单）

配置结构设计

重试策略以 YAML 形式定义，支持动态覆盖：

retry:
  max_attempts: 3
  base_delay_ms: 100
  jitter_ratio: 0.3
  error_whitelist:
    - "rpc error: code = Unavailable"
    - "i/o timeout"

max_attempts 控制总重试次数（含首次调用）；base_delay_ms 为指数退避初始值；jitter_ratio 引入随机扰动防雪崩；白名单仅对匹配正则的错误触发重试。

热加载机制

Viper 监听 etcd 路径 /config/retry-policy 变更，自动更新内存策略实例。

策略生效流程

graph TD
  A[etcd配置变更] --> B[Viper Watch触发]
  B --> C[解析YAML到RetryConfig结构]
  C --> D[原子替换全局策略指针]
  D --> E[后续HTTP/gRPC调用立即生效]

错误白名单匹配逻辑

字段	类型	说明
error_whitelist	[]string	支持子串匹配，非正则全量编译，兼顾性能与表达力

第五章：重试不是银弹——架构师必须直面的边界与替代方案

在某电商大促系统中，支付网关调用失败率突增至12%，团队第一反应是将重试次数从2次提升至5次、超时从800ms延长至3s。结果订单重复扣款激增47%，下游财务对账系统日志暴涨3TB，最终触发熔断导致32分钟支付不可用。这不是个别现象——2023年CNCF故障报告指出，31%的级联雪崩始于不加约束的重试策略。

重试失效的典型场景

• 幂等性缺失的服务调用：调用银行转账接口时，重试导致同一笔资金被划转三次；
• 状态依赖型操作：库存扣减后立即重试“查询剩余库存”，但缓存未及时更新，返回脏数据；
• 下游已执行副作用：短信网关收到请求后发送短信，但因网络抖动未返回ACK，上游重试造成用户收到6条相同验证码；
• 资源竞争加剧：Kubernetes集群中Pod启动失败时高频重试探针，引发etcd写入风暴，CPU使用率持续98%。

量化重试成本的三维度模型

维度	计算公式	生产案例（某物流调度系统）
网络开销	重试次数 × 单次请求字节数 × QPS	单次请求2.1KB，QPS 1200 → 日增流量1.8TB
下游压力	重试率 × 原始TPS × 平均处理耗时	重试率23%，TPS 850 → 等效负载增加195TPS
业务风险系数	重试次数 × 非幂等操作概率 × 损失单价	每次重试导致0.7%重复发货，单件损失¥128

替代方案的工程落地路径

采用Saga模式重构订单履约链路：将“创建订单→扣库存→发短信→通知物流”拆分为可补偿事务。当库存服务返回INSUFFICIENT_STOCK时，自动触发CancelOrder补偿动作，而非重试扣减。该方案上线后，订单异常率下降89%，平均恢复时间从4.2分钟缩短至17秒。

flowchart LR
    A[下单请求] --> B{库存服务}
    B -->|成功| C[生成订单]
    B -->|失败| D[触发Saga补偿]
    D --> E[回滚预占库存]
    D --> F[取消订单记录]
    D --> G[通知用户失败]

监控驱动的重试治理实践

在Service Mesh层植入重试黄金指标看板：

• retry_rate_by_upstream：按调用方统计重试率（阈值>5%告警）
• retry_success_ratio：重试后最终成功的比例（低于60%需优化）
• retry_cost_ms：重试带来的额外延迟（P95 > 1200ms触发降级）

某金融平台通过该看板发现，对核心风控服务的重试成功率仅34%，遂将同步调用改为异步事件驱动，用Kafka重放机制替代HTTP重试，消息积压量下降92%。

重试策略必须嵌入全链路可观测体系，任何脱离监控的重试配置都是技术债务的加速器。