全栈视角下的请求重试：从前端退避抖动到后端重试预算

interface RetryConfig {
  maxRetries?: number;
  baseDelayMs?: number;
  maxDelayMs?: number;
}

const defaultRetryConfig: Required<RetryConfig> = {
  maxRetries: 3,
  baseDelayMs: 300,
  maxDelayMs: 3000,
};

// 计算带有 Full Jitter 的退避时间
function getJitterDelay(attempt: number, base: number, cap: number): number {
  const exponential = base * Math.pow(2, attempt);
  const maxWait = Math.min(cap, exponential);
  // 在 0 到 maxWait 之间随机取值
  return Math.random() * maxWait;
}

// 判断当前错误是否具备重试价值
function isRetryableError(error: any): boolean {
  if (!error.response) {
    // 网络中断、超时等无响应情况，可以重试
    return true;
  }
  const status = error.response.status;
  // 5xx 服务端错误可以重试，但 4xx 业务错误重试没有意义
  return status >= 500 && status < 600;
}

export async function requestWithRetry<T>(
  requestFn: () => Promise<T>,
  config?: RetryConfig
): Promise<T> {
  const { maxRetries, baseDelayMs, maxDelayMs } = {
    ...defaultRetryConfig,
    ...config,
  };

  let attempt = 0;

  while (true) {
    try {
      return await requestFn();
    } catch (error) {
      attempt++;
      if (attempt > maxRetries || !isRetryableError(error)) {
        throw error;
      }

      const delay = getJitterDelay(attempt, baseDelayMs, maxDelayMs);
      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }
}

// 简化的服务端重试预算控制器
export class RetryBudget {
  private normalRequests = 0;
  private retryRequests = 0;
  private readonly budgetRatio: number; // 允许的重试比例，例如 0.1 表示 10%
  private windowResetTimer: NodeJS.Timeout;

  constructor(budgetRatio = 0.1, windowMs = 10000) {
    this.budgetRatio = budgetRatio;
    
    // 定时重置统计窗口
    this.windowResetTimer = setInterval(() => {
      this.normalRequests = 0;
      this.retryRequests = 0;
    }, windowMs);
  }

  // 记录一次普通请求
  public recordNormalRequest(): void {
    this.normalRequests++;
  }

  // 校验当前重试请求是否在预算内
  public canAcceptRetry(): boolean {
    const allowedRetries = Math.floor(this.normalRequests * this.budgetRatio);

    if (this.retryRequests < allowedRetries) {
      this.retryRequests++;
      return true;
    }

    // 超出预算，拒绝重试
    return false;
  }
}

// 模拟 Express / Koa 中间件
const budget = new RetryBudget(0.1, 5000);

export function retryBudgetMiddleware(req: any, res: any, next: () => void) {
  // 依靠客户端透传的 Header 识别是否是重试流量
  const isRetry = req.headers['x-is-retry'] === 'true';

  if (!isRetry) {
    budget.recordNormalRequest();
    return next();
  }

  if (budget.canAcceptRetry()) {
    return next();
  }

  // 超出预算，快速失败，告知客户端当前负载过高
  res.setHeader('Retry-After', '5');
  return res.status(429).json({
    code: 'RETRY_BUDGET_EXCEEDED',
    message: 'System is experiencing load, retry is temporarily throttled.',
  });
}