OpenAI 429 RateLimit 재시도·백오프 구현 가이드

import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY! });

type RetryOptions = {
  maxAttempts: number;        // 전체 시도 횟수(최초 1회 포함)
  baseDelayMs: number;        // 예: 250
  maxDelayMs: number;         // 예: 8000
  maxTotalSleepMs: number;    // 예: 30000
};

function sleep(ms: number) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function parseRetryAfterMs(err: any): number | null {
  // SDK/HTTP 클라이언트에 따라 위치가 달라질 수 있음
  const ra = err?.response?.headers?.["retry-after"] ?? err?.headers?.["retry-after"];
  if (!ra) return null;

  // retry-after는 초 단위 숫자이거나 HTTP-date일 수 있음
  const seconds = Number(ra);
  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000);

  const dateMs = Date.parse(ra);
  if (!Number.isNaN(dateMs)) return Math.max(0, dateMs - Date.now());

  return null;
}

function isRetryable(err: any): boolean {
  const status = err?.status ?? err?.response?.status;
  if (status === 429) return true;
  if (status >= 500 && status <= 599) return true;

  // 네트워크 계층 오류(라이브러리별 상이)
  const code = err?.code;
  if (code === "ETIMEDOUT" || code === "ECONNRESET" || code === "EAI_AGAIN") return true;

  return false;
}

function computeFullJitterDelayMs(baseDelayMs: number, maxDelayMs: number, attemptIndex: number) {
  // attemptIndex: 0부터 시작(첫 재시도는 0)
  const cap = Math.min(maxDelayMs, baseDelayMs * Math.pow(2, attemptIndex));
  return Math.floor(Math.random() * cap);
}

export async function callWithRetry<T>(
  fn: () => Promise<T>,
  opt: RetryOptions
): Promise<T> {
  let totalSleep = 0;

  for (let attempt = 1; attempt <= opt.maxAttempts; attempt++) {
    try {
      return await fn();
    } catch (err: any) {
      const retryable = isRetryable(err);
      const isLast = attempt === opt.maxAttempts;

      if (!retryable || isLast) {
        throw err;
      }

      const retryAfterMs = parseRetryAfterMs(err);
      const backoffMs = computeFullJitterDelayMs(opt.baseDelayMs, opt.maxDelayMs, attempt - 1);
      const sleepMs = retryAfterMs ?? backoffMs;

      if (totalSleep + sleepMs > opt.maxTotalSleepMs) {
        throw err;
      }

      totalSleep += sleepMs;
      await sleep(sleepMs);
    }
  }

  // 도달 불가
  throw new Error("unexpected");
}

// 사용 예시
export async function createChatCompletion(prompt: string) {
  return callWithRetry(
    async () => {
      return client.responses.create({
        model: "gpt-4.1-mini",
        input: prompt,
      });
    },
    {
      maxAttempts: 5,
      baseDelayMs: 250,
      maxDelayMs: 8000,
      maxTotalSleepMs: 30000,
    }
  );
}

class Semaphore {
  private available: number;
  private queue: Array<() => void> = [];

  constructor(count: number) {
    this.available = count;
  }

  async acquire() {
    if (this.available > 0) {
      this.available -= 1;
      return;
    }
    await new Promise<void>((resolve) => this.queue.push(resolve));
  }

  release() {
    const next = this.queue.shift();
    if (next) {
      next();
      return;
    }
    this.available += 1;
  }
}

const openAiSemaphore = new Semaphore(10); // 프로세스당 동시 10개 제한

export async function guardedOpenAiCall(prompt: string) {
  await openAiSemaphore.acquire();
  try {
    return await createChatCompletion(prompt);
  } finally {
    openAiSemaphore.release();
  }
}

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatusCode;
import org.springframework.web.client.RestClient;
import org.springframework.web.client.RestClientResponseException;

import java.time.Duration;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.ThreadLocalRandom;

public class OpenAiRetryingClient {

  private final RestClient restClient;

  public OpenAiRetryingClient(RestClient restClient) {
    this.restClient = restClient;
  }

  public String callWithRetry(String url, String bodyJson) {
    int maxAttempts = 5;
    long baseDelayMs = 250;
    long maxDelayMs = 8000;
    long maxTotalSleepMs = 30000;

    long totalSleep = 0;

    for (int attempt = 1; attempt <= maxAttempts; attempt++) {
      try {
        return restClient.post()
            .uri(url)
            .header("Content-Type", "application/json")
            .body(bodyJson)
            .retrieve()
            .body(String.class);
      } catch (RestClientResponseException ex) {
        int status = ex.getStatusCode().value();
        boolean retryable = status == 429 || (status >= 500 && status <= 599);
        boolean last = attempt == maxAttempts;

        if (!retryable || last) {
          throw ex;
        }

        Long retryAfterMs = parseRetryAfterMs(ex);
        long backoffMs = fullJitterBackoff(baseDelayMs, maxDelayMs, attempt - 1);
        long sleepMs = retryAfterMs != null ? retryAfterMs : backoffMs;

        if (totalSleep + sleepMs > maxTotalSleepMs) {
          throw ex;
        }

        totalSleep += sleepMs;
        try {
          Thread.sleep(sleepMs);
        } catch (InterruptedException ie) {
          Thread.currentThread().interrupt();
          throw new RuntimeException(ie);
        }
      }
    }

    throw new IllegalStateException("unexpected");
  }

  private long fullJitterBackoff(long baseDelayMs, long maxDelayMs, int attemptIndex) {
    long cap = Math.min(maxDelayMs, (long) (baseDelayMs * Math.pow(2, attemptIndex)));
    return ThreadLocalRandom.current().nextLong(0, Math.max(1, cap + 1));
  }

  private Long parseRetryAfterMs(RestClientResponseException ex) {
    String ra = ex.getResponseHeaders() != null ? ex.getResponseHeaders().getFirst("Retry-After") : null;
    if (ra == null || ra.isBlank()) return null;

    // seconds
    try {
      long seconds = Long.parseLong(ra.trim());
      return Math.max(0, seconds * 1000);
    } catch (NumberFormatException ignore) {
    }

    // HTTP-date
    try {
      ZonedDateTime dt = ZonedDateTime.parse(ra.trim(), DateTimeFormatter.RFC_1123_DATE_TIME);
      long diff = Duration.between(ZonedDateTime.now(dt.getZone()), dt).toMillis();
      return Math.max(0, diff);
    } catch (Exception ignore) {
      return null;
    }
  }
}