Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

fix(auth): keep usage counted while a shutdown flush awaits a write

Yudhi Armyndharis2fd2661d90f1
diff --git a/src/modules/auth/api-key-usage-tracker.service.ts b/src/modules/auth/api-key-usage-tracker.service.ts
index 8ba372fe6..dfebb3cd7 100644
--- a/src/modules/auth/api-key-usage-tracker.service.ts
+++ b/src/modules/auth/api-key-usage-tracker.service.ts
@@ -106,19 +106,22 @@ export class ApiKeyUsageTracker {
}
}
- /** Persist every accumulated delta with an atomic increment; entries that fail stay pending. */
+ /**
+ * Persist every accumulated delta with an atomic increment; entries that fail go back to pending. The batch
+ * is taken out of the map before the first write: a use recorded while a write is awaited then starts a
+ * fresh count, instead of being deleted along with the one just written or written a second time.
+ */
private async flushPending(): Promise<void> {
- for (const [keyId, delta] of [...this.pending.entries()]) {
- if (delta <= 0) {
- this.pending.delete(keyId);
- continue;
- }
+ const batch = [...this.pending.entries()];
+ this.pending.clear();
+ for (const [keyId, delta] of batch) {
+ if (delta <= 0) continue;
try {
// Atomic UPDATE ... SET usageCount = usageCount + delta — no read-modify-write race with a
// concurrent windowed save, unlike reloading the row and saving it back.
await this.apiKeyRepository.increment({ id: keyId }, 'usageCount', delta);
- this.pending.delete(keyId);
} catch (error) {
+ this.pending.set(keyId, (this.pending.get(keyId) ?? 0) + delta);
this.logger.warn('Usage-stat flush failed for a key; delta kept pending', {
keyId,
error: error instanceof Error ? error.message : String(error),
diff --git a/src/modules/auth/api-key-usage-tracker.spec.ts b/src/modules/auth/api-key-usage-tracker.spec.ts
new file mode 100644
index 000000000..397cf3b3b
--- /dev/null
+++ b/src/modules/auth/api-key-usage-tracker.spec.ts
@@ -0,0 +1,130 @@
+import { ApiKeyUsageTracker } from './api-key-usage-tracker.service';
+import { ApiKey, ApiKeyRole } from './entities/api-key.entity';
+
+const key = (overrides: Partial<ApiKey> = {}): ApiKey =>
+ ({
+ id: 'key-1',
+ role: ApiKeyRole.OPERATOR,
+ lastUsedAt: new Date(),
+ usageCount: 0,
+ ...overrides,
+ }) as ApiKey;
+
+/**
+ * A repository that only counts what reaches the database: `increment` can be held open, and the
+ * windowed `update` is read back from its `"usageCount" + N` expression.
+ */
+function makeRepository() {
+ const written: number[] = [];
+ let gate: Promise<void> = Promise.resolve();
+ let failNext = false;
+ const repository = {
+ increment: jest.fn(async (_criteria: unknown, _column: string, delta: number) => {
+ await gate;
+ if (failNext) {
+ failNext = false;
+ throw new Error('database write failed');
+ }
+ written.push(delta);
+ }),
+ update: jest.fn((_criteria: unknown, patch: { usageCount: () => string }) => {
+ written.push(Number(/\+ (\d+)$/.exec(patch.usageCount())?.[1]));
+ return Promise.resolve();
+ }),
+ };
+ return {
+ repository,
+ total: () => written.reduce((sum, delta) => sum + delta, 0),
+ hold: () => {
+ let release!: () => void;
+ gate = new Promise<void>(resolve => (release = resolve));
+ return release;
+ },
+ failNextIncrement: () => {
+ failNext = true;
+ },
+ };
+}
+
+describe('ApiKeyUsageTracker shutdown flush', () => {
+ it('keeps a use recorded while the flush awaits its write', async () => {
+ const db = makeRepository();
+ const tracker = new ApiKeyUsageTracker(db.repository as never);
+ await tracker.record(key());
+ await tracker.record(key());
+
+ const release = db.hold();
+ const flush = tracker.flushOnShutdown();
+ await tracker.record(key());
+ release();
+ await flush;
+ await tracker.flushOnShutdown();
+
+ expect(db.total()).toBe(3);
+ });
+
+ it('does not write a use twice when the window closes while the flush awaits', async () => {
+ const db = makeRepository();
+ const tracker = new ApiKeyUsageTracker(db.repository as never);
+ await tracker.record(key());
+ await tracker.record(key());
+
+ const release = db.hold();
+ const flush = tracker.flushOnShutdown();
+ await tracker.record(key({ lastUsedAt: new Date(Date.now() - 120_000) }));
+ release();
+ await flush;
+ await tracker.flushOnShutdown();
+
+ expect(db.total()).toBe(3);
+ });
+
+ it('keeps the failed batch and a use recorded meanwhile for the next flush', async () => {
+ const db = makeRepository();
+ const tracker = new ApiKeyUsageTracker(db.repository as never);
+ await tracker.record(key());
+ await tracker.record(key());
+
+ const release = db.hold();
+ db.failNextIncrement();
+ const flush = tracker.flushOnShutdown();
+ await tracker.record(key());
+ release();
+ await flush;
+ await tracker.flushOnShutdown();
+
+ expect(db.total()).toBe(3);
+ });
+
+ it('writes a batch once when two shutdown flushes overlap', async () => {
+ const db = makeRepository();
+ const tracker = new ApiKeyUsageTracker(db.repository as never);
+ await tracker.record(key());
+ await tracker.record(key());
+
+ const release = db.hold();
+ const first = tracker.flushOnShutdown();
+ const second = tracker.flushOnShutdown();
+ release();
+ await Promise.all([first, second]);
+
+ expect(db.total()).toBe(2);
+ expect(db.repository.increment).toHaveBeenCalledTimes(1);
+ });
+
+ it('keeps a later key use while an earlier key of the batch awaits its write', async () => {
+ const db = makeRepository();
+ const tracker = new ApiKeyUsageTracker(db.repository as never);
+ await tracker.record(key({ id: 'first' }));
+ await tracker.record(key({ id: 'second' }));
+
+ const release = db.hold();
+ const flush = tracker.flushOnShutdown();
+ await tracker.record(key({ id: 'second' }));
+ release();
+ await flush;
+ await tracker.flushOnShutdown();
+
+ expect(db.total()).toBe(3);
+ });
+});