fix: unify riot refresh rate gating

This commit is contained in:
dahyeon committed 2026-06-07 11:11:12 -07:00
1 parent 25f3ccad57
commit de8bc87940
6 files changed
+359 -123

No files matched your search

@@ -3,63 +3,156 @@ import { RiotRateLimiterService } from './riot-rate-limiter.service';
function makeService(sendCommand = jest.fn().mockResolvedValue(0)) {
const garnet = {
getString: jest.fn().mockResolvedValue(null),
raw: jest.fn().mockReturnValue({ sendCommand }),
} as unknown as GarnetService;
setString: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<GarnetService>;
return {
service: new RiotRateLimiterService(garnet),
garnet,
sendCommand,
};
}
describe('RiotRateLimiterService background limiter', () => {
function observedState(params: {
count120: number;
limit120?: number;
observedAt: number;
windowStartAt: number;
}) {
return JSON.stringify({
count120: params.count120,
limit120: params.limit120 ?? 100,
observedAt: params.observedAt,
windowStartAt: params.windowStartAt,
});
}
describe('RiotRateLimiterService', () => {
afterEach(() => {
jest.restoreAllMocks();
});
it('uses the background key namespace and passes cost to the Lua script', async () => {
it('uses global app rate keys and passes cost to the Lua script', async () => {
jest.spyOn(Date, 'now').mockReturnValue(1_000);
const { service, sendCommand } = makeService();
await service.acquireBackground(8);
await service.acquire('asia', 3);
expect(sendCommand).toHaveBeenCalledTimes(1);
const command = sendCommand.mock.calls[0][0] as string[];
expect(command[0]).toBe('EVAL');
expect(command[2]).toBe('2');
expect(command[3]).toBe('riot:bg:rl:1000');
expect(command[4]).toBe('riot:bg:rl:120000');
expect(command[3]).toBe('riot:rl:app:1000');
expect(command[4]).toBe('riot:rl:app:120000');
expect(command[5]).toBe('1000');
expect(command[7]).toBe('8');
expect(command[7]).toBe('3');
});
it('reads cleaned background usage for both windows', async () => {
jest.spyOn(Date, 'now').mockReturnValue(200_000);
const sendCommand = jest
.fn()
.mockImplementation(async (command: string[]) => {
if (command[0] === 'ZREMRANGEBYSCORE') return 0;
if (command[1] === 'riot:bg:rl:1000') return 3;
if (command[1] === 'riot:bg:rl:120000') return 24;
return 0;
});
const { service } = makeService(sendCommand);
it('records the 120 second app rate observation from Riot headers', async () => {
jest.spyOn(Date, 'now').mockReturnValue(1_000_000);
const { service, garnet } = makeService();
await expect(service.getBackgroundUsage()).resolves.toEqual({
used1s: 3,
used2m: 24,
await service.recordAppRateLimitObservation('47:120,3:1', '100:120,20:1');
expect(garnet.setString).toHaveBeenCalledTimes(1);
const [key, raw, ttl] = garnet.setString.mock.calls[0];
expect(key).toBe('riot:app:rl:observed');
expect(ttl).toBe(300);
expect(JSON.parse(raw)).toEqual({
count120: 47,
limit120: 100,
observedAt: 1_000_000,
windowStartAt: 1_000_000,
});
});
it('resets the inferred window when Riot count decreases or observation is stale', async () => {
const { service, garnet } = makeService();
jest.spyOn(Date, 'now').mockReturnValue(1_060_000);
garnet.getString.mockResolvedValueOnce(
observedState({
count120: 80,
observedAt: 1_050_000,
windowStartAt: 1_000_000,
}),
);
await service.recordAppRateLimitObservation('2:120', null);
expect(JSON.parse(garnet.setString.mock.calls[0][1])).toMatchObject({
count120: 2,
windowStartAt: 1_060_000,
});
expect(sendCommand).toHaveBeenCalledWith([
'ZREMRANGEBYSCORE',
'riot:bg:rl:1000',
'-inf',
'199000',
]);
expect(sendCommand).toHaveBeenCalledWith([
'ZREMRANGEBYSCORE',
'riot:bg:rl:120000',
'-inf',
'80000',
]);
jest.spyOn(Date, 'now').mockReturnValue(1_240_000);
garnet.getString.mockResolvedValueOnce(
observedState({
count120: 20,
observedAt: 1_120_000,
windowStartAt: 1_000_000,
}),
);
await service.recordAppRateLimitObservation('25:120', null);
expect(JSON.parse(garnet.setString.mock.calls[1][1])).toMatchObject({
count120: 25,
windowStartAt: 1_240_000,
});
});
it('opens the refresh gate when there is no active observation', async () => {
const { service, garnet } = makeService();
await expect(service.isRefreshWindowOpen(0.5)).resolves.toBe(true);
garnet.getString.mockResolvedValueOnce(
observedState({
count120: 90,
observedAt: 1_000_000,
windowStartAt: 900_000,
}),
);
jest.spyOn(Date, 'now').mockReturnValue(1_120_000);
await expect(service.isRefreshWindowOpen(0.5)).resolves.toBe(true);
});
it.each([
{ ratio: 0.5, count120: 49, expected: true },
{ ratio: 0.5, count120: 50, expected: false },
{ ratio: 0.8, count120: 79, expected: true },
{ ratio: 0.8, count120: 80, expected: false },
])(
'checks tail headroom for refresh gate ratio=$ratio count=$count120',
async ({ ratio, count120, expected }) => {
jest.spyOn(Date, 'now').mockReturnValue(1_070_000);
const { service, garnet } = makeService();
garnet.getString.mockResolvedValue(
observedState({
count120,
observedAt: 1_069_000,
windowStartAt: 1_000_000,
}),
);
await expect(service.isRefreshWindowOpen(ratio)).resolves.toBe(expected);
},
);
it('keeps the refresh gate closed before the 120 second window tail', async () => {
jest.spyOn(Date, 'now').mockReturnValue(1_050_000);
const { service, garnet } = makeService();
garnet.getString.mockResolvedValue(
observedState({
count120: 10,
observedAt: 1_049_000,
windowStartAt: 1_000_000,
}),
);
await expect(service.isRefreshWindowOpen(0.8)).resolves.toBe(false);
});
});
@@ -7,11 +7,19 @@ const APP_LIMITS = [
{ windowMs: 120_000, max: 90 },
] as const;
const BACKGROUND_LIMITS = [
{ windowMs: 1_000, max: 6 },
{ windowMs: 120_000, max: 36 },
] as const;
const BACKGROUND_KEY_PREFIX = 'riot:bg:rl';
const APP_KEY_PREFIX = 'riot:rl:app';
const APP_WINDOW_MS = 120_000;
const TAIL_MS = 60_000;
const APP_OBSERVED_KEY = 'riot:app:rl:observed';
const APP_OBSERVED_TTL_SECONDS = 300;
const DEFAULT_APP_LIMIT_120 = 100;
interface AppRateObservation {
count120: number;
limit120: number;
observedAt: number;
windowStartAt: number;
}
const ACQUIRE_SCRIPT = `
local now = tonumber(ARGV[1])
@@ -81,85 +89,78 @@ export class RiotRateLimiterService {
public async acquire(
route: RiotRegionalRoute | RiotPlatformRoute,
cost = 1,
): Promise<void> {
for (;;) {
const now = Date.now();
const waitMs = await this.checkAndAdd(route, now, 1);
if (waitMs <= 0) return;
if (waitMs >= 100) {
this.logger.warn(
`Riot API throttle waiting ${waitMs}ms for route=${route}.`,
);
}
await sleep(waitMs);
}
}
public async acquireBackground(cost = 1): Promise<void> {
const normalizedCost = normalizeCost(cost);
for (;;) {
const now = Date.now();
const waitMs = await this.checkAndAddBackground(now, normalizedCost);
const waitMs = await this.checkAndAdd(now, normalizedCost);
if (waitMs <= 0) return;
if (waitMs >= 100) {
this.logger.warn(
`Background Riot throttle waiting ${waitMs}ms (cost=${normalizedCost}).`,
`Riot API throttle waiting ${waitMs}ms for route=${route} cost=${normalizedCost}.`,
);
}
await sleep(waitMs);
}
}
public async getBackgroundUsage(): Promise<{
used1s: number;
used2m: number;
}> {
const client = this.garnet.raw();
const now = Date.now();
const usages = await Promise.all(
BACKGROUND_LIMITS.map(async (limit) => {
const key = `${BACKGROUND_KEY_PREFIX}:${limit.windowMs}`;
await client.sendCommand([
'ZREMRANGEBYSCORE',
key,
'-inf',
String(now - limit.windowMs),
]);
const response = await client.sendCommand(['ZCARD', key]);
const count = Number(response ?? 0);
return Number.isFinite(count) && count > 0 ? count : 0;
}),
);
public async recordAppRateLimitObservation(
countHeader: string | null,
limitHeader?: string | null,
): Promise<void> {
const count120 = parseRateLimitHeader(countHeader, 120);
if (count120 === null) return;
return {
used1s: usages[0] ?? 0,
used2m: usages[1] ?? 0,
const limit120 =
parseRateLimitHeader(limitHeader ?? null, 120) ?? DEFAULT_APP_LIMIT_120;
const now = Date.now();
const previous = await this.getAppRateObservation();
const windowStartAt =
!previous ||
now - previous.observedAt >= APP_WINDOW_MS ||
count120 < previous.count120
? now
: previous.windowStartAt;
const observation: AppRateObservation = {
count120,
limit120,
observedAt: now,
windowStartAt,
};
// Concurrent responses can race here. This observation is advisory, so
// last-writer-wins is acceptable and self-corrects on the next Riot header.
await this.garnet.setString(
APP_OBSERVED_KEY,
JSON.stringify(observation),
APP_OBSERVED_TTL_SECONDS,
);
}
private async checkAndAdd(
route: RiotRegionalRoute | RiotPlatformRoute,
now: number,
cost: number,
): Promise<number> {
public async isRefreshWindowOpen(
usageRatio: number,
now = Date.now(),
): Promise<boolean> {
const observation = await this.getAppRateObservation();
if (!observation) return true;
if (now - observation.observedAt >= APP_WINDOW_MS) return true;
const ratio = Number.isFinite(usageRatio) ? usageRatio : 0;
const headroomOk = observation.count120 < observation.limit120 * ratio;
const inTail = now >= observation.windowStartAt + APP_WINDOW_MS - TAIL_MS;
return headroomOk && inTail;
}
private async checkAndAdd(now: number, cost: number): Promise<number> {
const keys = APP_LIMITS.map(
(limit) => `riot:rl:${route}:${limit.windowMs}`,
(limit) => `${APP_KEY_PREFIX}:${limit.windowMs}`,
);
return this.checkAndAddWithLimits(keys, APP_LIMITS, now, cost);
}
private async checkAndAddBackground(
now: number,
cost: number,
): Promise<number> {
const keys = BACKGROUND_LIMITS.map(
(limit) => `${BACKGROUND_KEY_PREFIX}:${limit.windowMs}`,
);
return this.checkAndAddWithLimits(keys, BACKGROUND_LIMITS, now, cost);
}
private async checkAndAddWithLimits(
keys: string[],
limits: ReadonlyArray<{ windowMs: number; max: number }>,
@@ -187,6 +188,32 @@ export class RiotRateLimiterService {
if (!Number.isFinite(waitMs) || waitMs < 0) return 0;
return waitMs;
}
private async getAppRateObservation(): Promise<AppRateObservation | null> {
const raw = await this.garnet.getString(APP_OBSERVED_KEY);
if (!raw) return null;
try {
const parsed = JSON.parse(raw) as Partial<AppRateObservation>;
if (
typeof parsed.count120 !== 'number' ||
typeof parsed.limit120 !== 'number' ||
typeof parsed.observedAt !== 'number' ||
typeof parsed.windowStartAt !== 'number'
) {
return null;
}
return {
count120: parsed.count120,
limit120: parsed.limit120,
observedAt: parsed.observedAt,
windowStartAt: parsed.windowStartAt,
};
} catch {
return null;
}
}
}
function normalizeCost(cost: number): number {
@@ -194,6 +221,24 @@ function normalizeCost(cost: number): number {
return Math.max(1, Math.floor(cost));
}
function parseRateLimitHeader(
header: string | null,
windowSeconds: number,
): number | null {
if (!header) return null;
for (const rawEntry of header.split(',')) {
const [rawCount, rawWindow] = rawEntry.trim().split(':');
const count = Number(rawCount);
const window = Number(rawWindow);
if (window === windowSeconds && Number.isFinite(count) && count >= 0) {
return count;
}
}
return null;
}
function sleep(ms: number): Promise<void> {
return new Promise((resolve) => setTimeout(resolve, ms));
}
@@ -0,0 +1,43 @@
import { SecretService } from '../global/secret/secret.service';
import { RiotClientService } from './riot.client.service';
import { RiotRateLimiterService } from './riot-rate-limiter.service';
describe('RiotClientService', () => {
const originalFetch = global.fetch;
afterEach(() => {
global.fetch = originalFetch;
jest.restoreAllMocks();
});
it('records Riot app rate limit headers after a response', async () => {
const secretService = {
get: jest.fn().mockResolvedValue('riot-key'),
} as unknown as jest.Mocked<SecretService>;
const rateLimiter = {
acquire: jest.fn().mockResolvedValue(undefined),
recordAppRateLimitObservation: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<RiotRateLimiterService>;
global.fetch = jest.fn().mockResolvedValue({
headers: {
get: jest.fn((name: string) => {
if (name === 'X-App-Rate-Limit-Count') return '47:120,3:1';
if (name === 'X-App-Rate-Limit') return '100:120,20:1';
return null;
}),
},
json: jest.fn().mockResolvedValue({ ok: true }),
ok: true,
status: 200,
} as unknown as Response);
const service = new RiotClientService(secretService, rateLimiter);
await service.get('/lol/status/v4/platform-data', { platform: 'kr' });
expect(rateLimiter.acquire).toHaveBeenCalledWith('kr');
expect(rateLimiter.recordAppRateLimitObservation).toHaveBeenCalledWith(
'47:120,3:1',
'100:120,20:1',
);
});
});
@@ -140,16 +140,18 @@ export class RiotClientService {
});
const appRateLimitCount = response.headers.get('X-App-Rate-Limit-Count');
const appRateLimit = response.headers.get('X-App-Rate-Limit');
void this.rateLimiter.recordAppRateLimitObservation(
appRateLimitCount,
appRateLimit,
);
if (appRateLimitCount && Math.random() < 0.05) {
this.logger.debug(`Riot rate usage ${routeKey}: ${appRateLimitCount}`);
}
if (!response.ok) {
const error = await this.createApiError(response, url);
if (
error.status === 429 &&
attempt === 0
) {
if (error.status === 429 && attempt === 0) {
await sleep((error.retryAfterSeconds ?? 1) * 1000);
return this.fetchWithRetry(
url,