Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
108 changes: 108 additions & 0 deletions packages/api-client/src/fetch.test.ts
Original file line number Diff line number Diff line change
@@ -1,6 +1,13 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { APIError, apiFetch } from "./fetch";

function rateLimitResponse(retryAfter: string | null = "0") {
return new Response("rate limited", {
status: 429,
headers: retryAfter === null ? undefined : { "retry-after": retryAfter },
});
}

describe("apiFetch", () => {
afterEach(() => {
vi.useRealTimers();
Expand Down Expand Up @@ -57,6 +64,107 @@ describe("apiFetch", () => {
expect(fetchMock).toHaveBeenCalledTimes(1);
});

it("retries rate limits after Retry-After plus jitter", async () => {
vi.useFakeTimers();
vi.spyOn(Math, "random").mockReturnValue(0.1);
const fetchMock = vi
.fn()
.mockResolvedValueOnce(rateLimitResponse("2"))
.mockResolvedValueOnce(new Response("{}", { status: 200 }));

const responsePromise = apiFetch(
new Request("https://api.argos-ci.test/builds"),
{
fetch: fetchMock as unknown as typeof fetch,
minTimeout: 0,
},
);

await vi.advanceTimersByTimeAsync(2_499);
expect(fetchMock).toHaveBeenCalledTimes(1);

await vi.advanceTimersByTimeAsync(1);
const response = await responsePromise;
expect(response.status).toBe(200);
expect(fetchMock).toHaveBeenCalledTimes(2);
});

it.each([
["missing", null, 60_000],
["invalid", "later", 60_000],
["too large", "600", 300_000],
])(
"bounds the retry delay when Retry-After is %s",
async (_case, retryAfter, expectedDelay) => {
vi.useFakeTimers();
vi.spyOn(Math, "random").mockReturnValue(0);
const fetchMock = vi
.fn()
.mockResolvedValueOnce(rateLimitResponse(retryAfter))
.mockResolvedValueOnce(new Response("{}", { status: 200 }));

const responsePromise = apiFetch(
new Request("https://api.argos-ci.test/builds"),
{
fetch: fetchMock as unknown as typeof fetch,
minTimeout: 0,
},
);

await vi.advanceTimersByTimeAsync(expectedDelay - 1);
expect(fetchMock).toHaveBeenCalledTimes(1);

await vi.advanceTimersByTimeAsync(1);
await expect(responsePromise).resolves.toMatchObject({ status: 200 });
expect(fetchMock).toHaveBeenCalledTimes(2);
},
);

it("returns the final rate limit response after retries are exhausted", async () => {
vi.useFakeTimers();
vi.spyOn(Math, "random").mockReturnValue(0);
const fetchMock = vi.fn(async () => rateLimitResponse());

const responsePromise = apiFetch(
new Request("https://api.argos-ci.test/builds"),
{
fetch: fetchMock as unknown as typeof fetch,
minTimeout: 0,
retries: 2,
},
);

await vi.runAllTimersAsync();
const response = await responsePromise;
expect(response.status).toBe(429);
await expect(response.text()).resolves.toBe("rate limited");
expect(fetchMock).toHaveBeenCalledTimes(3);
});

it("preserves caller cancellation during a rate limit delay", async () => {
vi.useFakeTimers();
vi.spyOn(Math, "random").mockReturnValue(0);
const controller = new AbortController();
const reason = new Error("cancelled by caller");
const fetchMock = vi.fn(async () => rateLimitResponse("60"));

const promise = apiFetch(
new Request("https://api.argos-ci.test/builds", {
signal: controller.signal,
}),
{
fetch: fetchMock as unknown as typeof fetch,
minTimeout: 0,
},
);

await vi.advanceTimersByTimeAsync(0);
controller.abort(reason);

await expect(promise).rejects.toBe(reason);
expect(fetchMock).toHaveBeenCalledTimes(1);
});

it("throws APIError after server error retries are exhausted", async () => {
const fetchMock = vi.fn(async () => new Response("{}", { status: 503 }));

Expand Down
40 changes: 39 additions & 1 deletion packages/api-client/src/fetch.ts
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,9 @@ import pRetry from "p-retry";
import { debug } from "./debug";

const DEFAULT_TIMEOUT = 30_000;
const DEFAULT_RETRY_AFTER_MS = 60_000;
const MAX_RETRY_AFTER_MS = 300_000;
const MAX_RETRY_JITTER_MS = 5_000;

export class APIError extends Error {
/**
Expand Down Expand Up @@ -36,6 +39,30 @@ interface APIFetchOptions {
timeout?: number;
}

function getRetryAfterMs(response: Response) {
const header = response.headers.get("retry-after");
const seconds = header === null ? Number.NaN : Number(header);
const retryAfterMs = Number.isFinite(seconds)
? Math.max(seconds, 0) * 1_000
: DEFAULT_RETRY_AFTER_MS;
return Math.min(retryAfterMs, MAX_RETRY_AFTER_MS);
}

function waitForRetry(ms: number, signal: AbortSignal) {
signal.throwIfAborted();
return new Promise<void>((resolve, reject) => {
const onAbort = () => {
clearTimeout(timeout);
reject(signal.reason);
};
const timeout = setTimeout(() => {
signal.removeEventListener("abort", onAbort);
resolve();
}, ms);
signal.addEventListener("abort", onAbort, { once: true });
});
}

async function createRequestFactory(request: Request, timeout: number) {
// Snapshot the body once so retries do not clone/tee the original Request.
const body = request.body ? await request.arrayBuffer() : undefined;
Expand Down Expand Up @@ -73,18 +100,29 @@ export async function apiFetch(input: Request, options: APIFetchOptions = {}) {
input,
options.timeout ?? DEFAULT_TIMEOUT,
);
const retries = options.retries ?? 3;

return pRetry(
async (attemptNumber) => {
const response = await fetchImpl(createRequest(attemptNumber - 1));
if (response.status === 429 && attemptNumber <= retries) {
const retryDelayMs =
getRetryAfterMs(response) + Math.random() * MAX_RETRY_JITTER_MS;
debug(
`API request rate limited, waiting ${Math.ceil(retryDelayMs / 1_000)}s before retry`,
);
await response.body?.cancel();
await waitForRetry(retryDelayMs, input.signal);
throw new APIError("Too Many Requests (429)", { status: 429 });
}
if (response.status >= 500) {
throw new APIError(`Internal Server Error (${response.status})`);
}
return response;
},
{
minTimeout: options.minTimeout,
retries: options.retries ?? 3,
retries,
shouldRetry: () => !input.signal.aborted,
onFailedAttempt: (context) => {
debug("API request failed", context.error.message);
Expand Down