diff --git a/changelog.d/fixes/16276-usage-write-deferred-retry-on-lock.md b/changelog.d/fixes/16276-usage-write-deferred-retry-on-lock.md new file mode 100644 index 00000000000..8c247b67127 --- /dev/null +++ b/changelog.d/fixes/16276-usage-write-deferred-retry-on-lock.md @@ -0,0 +1 @@ +- **fix(usage):** a usage write blocked by a locked database is retried once after a short delay instead of being dropped; if the server stops during the wait the row is lost as before, on a best-effort basis ([#16276](https://github.com/diegosouzapw/OmniRoute/pull/16276)) — thanks @maxmad64bis (with thanks to @W25X80 for surfacing the SQLite write failures in #16176) diff --git a/src/lib/usage/usageHistory.ts b/src/lib/usage/usageHistory.ts index dc44d7602b2..ac6ffdbb307 100644 --- a/src/lib/usage/usageHistory.ts +++ b/src/lib/usage/usageHistory.ts @@ -8,13 +8,8 @@ */ import { getDbInstance } from "../db/core"; -import { resolveProviderId } from "@/shared/constants/providers"; import { normalizePayloadForLog, protectPayloadForLog } from "../logPayloads"; import { sanitizeErrorMessage } from "@omniroute/open-sse/utils/errorSanitization.ts"; -import { - resolveOrphanedUsageAccountIdentity, - resolveUsageAccountIdentity, -} from "./accountIdentity"; import { accumulateLatencySample, asRecord, @@ -36,14 +31,7 @@ import { getCompletedDetails, } from "./completedRequestDetails"; import { shouldPersistToDisk } from "./migrations"; -import { emitUsageRecorded } from "./usageEvents"; -import { - getLoggedInputTokens, - getLoggedOutputTokens, - getPromptCacheCreationTokens, - getPromptCacheReadTokens, - getReasoningTokens, -} from "./tokenAccounting"; +import { attemptWrite, isWriteLockError, scheduleWriteRetry } from "./usageWriteRetry"; export type PendingRequestMetadata = { clientEndpoint?: string | null; @@ -870,120 +858,18 @@ export interface UsageEntry { export async function saveRequestUsage(entry: UsageEntry) { if (!shouldPersistToDisk) return; + // Freeze the timestamp on the first attempt so the deferred retry replays + // the same value and the dedup guard keys both attempts identically. + const frozenEntry = { ...entry, timestamp: entry.timestamp || new Date().toISOString() }; + try { - const db = getDbInstance(); - const timestamp = entry.timestamp || new Date().toISOString(); - const serviceTier = normalizeServiceTier(entry.serviceTier ?? entry.service_tier); - - const tokensInput = getLoggedInputTokens(entry.tokens); - const tokensOutput = getLoggedOutputTokens(entry.tokens); - const connection = entry.connectionId - ? (db.prepare("SELECT * FROM provider_connections WHERE id = ?").get(entry.connectionId) as - Record | undefined) - : undefined; - const accountIdentity = connection - ? resolveUsageAccountIdentity(connection) - : resolveOrphanedUsageAccountIdentity(entry.provider, entry.connectionId); - - // Dedup guard: skip INSERT when an identical row already exists in the same - // second. This prevents double-counting when onRequestSuccess fires more - // than once (e.g. combo routing calling the callback from both the - // streaming and non-streaming paths for the same underlying request). - // Keyed on the natural identity of a request: timestamp + provider + model - // + connectionId + apiKeyId + token counts. If only the endpoint is missing - // on the existing row, fill it in rather than inserting a duplicate. - let inserted = false; - - db.transaction(() => { - const existing = db - .prepare( - `SELECT id, endpoint, cpa_auth_index FROM usage_history - WHERE timestamp = ? - AND COALESCE(provider, '') = COALESCE(?, '') - AND COALESCE(model, '') = COALESCE(?, '') - AND COALESCE(connection_id, '') = COALESCE(?, '') - AND COALESCE(api_key_id, '') = COALESCE(?, '') - AND tokens_input = ? - AND tokens_output = ? - ORDER BY id DESC LIMIT 1` - ) - .get( - timestamp, - entry.provider ? resolveProviderId(entry.provider) : null, - entry.model || null, - entry.connectionId || null, - entry.apiKeyId || null, - tokensInput, - tokensOutput - ) as { id: number; endpoint: string | null; cpa_auth_index: string | null } | undefined; - - if (existing) { - // Back-fill endpoint if the original row missed it. - if (!existing.endpoint && entry.endpoint) { - db.prepare(`UPDATE usage_history SET endpoint = ? WHERE id = ?`).run( - entry.endpoint, - existing.id - ); - } - // A later completed attempt can carry the trace the first write missed. - if (!existing.cpa_auth_index && entry.cpaAuthIndex) { - db.prepare(`UPDATE usage_history SET cpa_auth_index = ? WHERE id = ?`).run( - entry.cpaAuthIndex, - existing.id - ); - } - return; // duplicate — do not insert - } - - db.prepare( - ` - INSERT INTO usage_history (provider, model, connection_id, account_key, account_label, - account_label_priority, api_key_id, api_key_name, tokens_input, tokens_output, - tokens_cache_read, tokens_cache_creation, tokens_reasoning, service_tier, status, success, - latency_ms, ttft_ms, error_code, combo_strategy, endpoint, cpa_auth_index, timestamp) - VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) - ` - ).run( - entry.provider ? resolveProviderId(entry.provider) : null, - entry.model || null, - entry.connectionId || null, - accountIdentity.accountKey, - accountIdentity.accountLabel, - accountIdentity.accountLabelPriority, - entry.apiKeyId || null, - entry.apiKeyName || null, - tokensInput, - tokensOutput, - getPromptCacheReadTokens(entry.tokens), - getPromptCacheCreationTokens(entry.tokens), - getReasoningTokens(entry.tokens), - serviceTier, - entry.status || null, - entry.success === false ? 0 : 1, - Number.isFinite(Number(entry.latencyMs)) ? Number(entry.latencyMs) : 0, - Number.isFinite(Number(entry.timeToFirstTokenMs)) - ? Number(entry.timeToFirstTokenMs) - : Number.isFinite(Number(entry.latencyMs)) - ? Number(entry.latencyMs) - : 0, - entry.errorCode || null, - entry.comboStrategy || entry.combo_strategy || null, - entry.endpoint || null, - entry.cpaAuthIndex || null, - timestamp - ); - - inserted = true; - })(); - - // Decoupled via the event bus so usageHistory never imports providerLimits - // (which would pull the executors/translator graph into the type-check surface). - // Only emit when a row was actually inserted — not on dedup no-ops. - if (inserted) { - emitUsageRecorded(entry.provider, entry.connectionId); - } + attemptWrite(frozenEntry); } catch (error) { - console.error("Failed to save usage stats:", error); + if (!isWriteLockError(error)) { + console.error("Failed to save usage stats:", error); + return; + } + scheduleWriteRetry(frozenEntry); } } diff --git a/src/lib/usage/usageWriteRetry.ts b/src/lib/usage/usageWriteRetry.ts new file mode 100644 index 00000000000..09691351c52 --- /dev/null +++ b/src/lib/usage/usageWriteRetry.ts @@ -0,0 +1,251 @@ +/** + * Deferred retry for usage writes blocked by a locked database. + * + * The hot-path writers here are best-effort: the database caps a contended + * write at 2 s (`busy_timeout = 2000` in `src/lib/db/core.ts`) so a busy disk + * cannot freeze the event loop. When a write still meets a lock, the first + * failure is swallowed silently and the entry is attempted once more after a + * short delay, off the request path (`setTimeout`, never awaited). If the + * second attempt fails the existing log line is written and the row is + * dropped. Any other error keeps the current behaviour: logged at once, + * never retried. If the server stops during the wait the row is lost as + * before, on a best-effort basis (the timer never keeps the loop alive). + * + * @module lib/usage/usageWriteRetry + */ + +import { getDbInstance } from "../db/core"; +import { resolveProviderId } from "@/shared/constants/providers"; +import { + resolveOrphanedUsageAccountIdentity, + resolveUsageAccountIdentity, +} from "./accountIdentity"; +import { normalizeServiceTier } from "./usageHistory/helpers"; +import { emitUsageRecorded } from "./usageEvents"; +import { + getLoggedInputTokens, + getLoggedOutputTokens, + getPromptCacheCreationTokens, + getPromptCacheReadTokens, + getReasoningTokens, +} from "./tokenAccounting"; +import type { UsageEntry } from "./usageHistory"; + +/** Delay before the single deferred attempt. Internal, not user-facing. */ +const RETRY_DELAY_MS = 1000; + +/** + * True when the error is a database lock, in any shape the supported drivers + * report it. Restricted to locks: only a lock is expected to clear within the + * retry delay. Lock classification mirrors the lock subset of the probe + * classifier and the busy checker (drivers report plain "database is locked" + * while better-sqlite3 carries the name in `code` and node:sqlite the numeric + * primary code in `errcode`, extended codes in the high bits). + */ +export function isWriteLockError(error: unknown): boolean { + const details = error as { code?: unknown; errcode?: unknown; message?: unknown } | null; + const code = details?.code ?? details?.errcode; + if (typeof code === "string" && isLockCodeName(code)) return true; + if (typeof code === "number" && isLockCodeNumber(code)) return true; + const message = error instanceof Error ? error.message : String(details?.message ?? error); + return isLockMessage(message); +} + +function isLockCodeName(code: string): boolean { + return /^SQLITE_(BUSY|LOCKED)/.test(code); +} + +function isLockCodeNumber(code: number): boolean { + const primary = code & 0xff; + return primary === 5 || primary === 6; +} + +function isLockMessage(message: string): boolean { + return /database(?: table| schema)? is (?:locked|busy)|SQLITE_BUSY|SQLITE_LOCKED/i.test(message); +} + +/** + * Single write attempt. Throws on failure so the caller decides between a + * deferred retry (lock) and an immediate log (anything else). + */ +export function attemptWrite(entry: UsageEntry): void { + const db = getDbInstance(); + const prepared = prepareEntry(db, entry); + let inserted = false; + + db.transaction(() => { + inserted = insertUnlessDuplicate(db, prepared); + })(); + + // Decoupled via the event bus so usageHistory never imports providerLimits + // (which would pull the executors/translator graph into the type-check surface). + // Only emit when a row was actually inserted — not on dedup no-ops. + if (inserted) { + emitUsageRecorded(entry.provider, entry.connectionId); + } +} + +type PreparedEntry = { + entry: UsageEntry; + timestamp: string; + serviceTier: string; + tokensInput: number; + tokensOutput: number; + accountIdentity: { + accountKey: string | null; + accountLabel: string | null; + accountLabelPriority: number; + }; +}; + +function prepareEntry(db: ReturnType, entry: UsageEntry): PreparedEntry { + const timestamp = entry.timestamp || new Date().toISOString(); + const connection = entry.connectionId + ? (db.prepare("SELECT * FROM provider_connections WHERE id = ?").get(entry.connectionId) as + Record | undefined) + : undefined; + return { + entry, + timestamp, + serviceTier: normalizeServiceTier(entry.serviceTier ?? entry.service_tier), + tokensInput: getLoggedInputTokens(entry.tokens), + tokensOutput: getLoggedOutputTokens(entry.tokens), + accountIdentity: connection + ? resolveUsageAccountIdentity(connection) + : resolveOrphanedUsageAccountIdentity(entry.provider, entry.connectionId), + }; +} + +// Dedup guard: skip INSERT when an identical row already exists in the same +// second. This prevents double-counting when onRequestSuccess fires more +// than once (e.g. combo routing calling the callback from both the +// streaming and non-streaming paths for the same underlying request). +// Keyed on the natural identity of a request: timestamp + provider + model +// + connectionId + apiKeyId + token counts. If only the endpoint is missing +// on the existing row, fill it in rather than inserting a duplicate. +function insertUnlessDuplicate( + db: ReturnType, + prepared: PreparedEntry +): boolean { + const { entry, timestamp, tokensInput, tokensOutput } = prepared; + const existing = db + .prepare( + `SELECT id, endpoint, cpa_auth_index FROM usage_history + WHERE timestamp = ? + AND COALESCE(provider, '') = COALESCE(?, '') + AND COALESCE(model, '') = COALESCE(?, '') + AND COALESCE(connection_id, '') = COALESCE(?, '') + AND COALESCE(api_key_id, '') = COALESCE(?, '') + AND tokens_input = ? + AND tokens_output = ? + ORDER BY id DESC LIMIT 1` + ) + .get( + timestamp, + entry.provider ? resolveProviderId(entry.provider) : null, + entry.model || null, + entry.connectionId || null, + entry.apiKeyId || null, + tokensInput, + tokensOutput + ) as { id: number; endpoint: string | null; cpa_auth_index: string | null } | undefined; + + if (existing) { + backfillDuplicate(db, existing, entry); + return false; + } + + insertEntry(db, prepared); + return true; +} + +function backfillDuplicate( + db: ReturnType, + existing: { id: number; endpoint: string | null; cpa_auth_index: string | null }, + entry: UsageEntry +): void { + // Back-fill endpoint if the original row missed it. + if (!existing.endpoint && entry.endpoint) { + db.prepare(`UPDATE usage_history SET endpoint = ? WHERE id = ?`).run( + entry.endpoint, + existing.id + ); + } + // A later completed attempt can carry the trace the first write missed. + if (!existing.cpa_auth_index && entry.cpaAuthIndex) { + db.prepare(`UPDATE usage_history SET cpa_auth_index = ? WHERE id = ?`).run( + entry.cpaAuthIndex, + existing.id + ); + } +} + +function insertEntry(db: ReturnType, prepared: PreparedEntry): void { + const { entry, timestamp, serviceTier, tokensInput, tokensOutput, accountIdentity } = prepared; + db.prepare( + ` + INSERT INTO usage_history (provider, model, connection_id, account_key, account_label, + account_label_priority, api_key_id, api_key_name, tokens_input, tokens_output, + tokens_cache_read, tokens_cache_creation, tokens_reasoning, service_tier, status, success, + latency_ms, ttft_ms, error_code, combo_strategy, endpoint, cpa_auth_index, timestamp) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + ` + ).run( + entry.provider ? resolveProviderId(entry.provider) : null, + entry.model || null, + entry.connectionId || null, + accountIdentity.accountKey, + accountIdentity.accountLabel, + accountIdentity.accountLabelPriority, + entry.apiKeyId || null, + entry.apiKeyName || null, + tokensInput, + tokensOutput, + getPromptCacheReadTokens(entry.tokens), + getPromptCacheCreationTokens(entry.tokens), + getReasoningTokens(entry.tokens), + serviceTier, + entry.status || null, + entry.success === false ? 0 : 1, + toFinite(entry.latencyMs), + toFirstToken(entry), + entry.errorCode || null, + entry.comboStrategy || entry.combo_strategy || null, + entry.endpoint || null, + entry.cpaAuthIndex || null, + timestamp + ); +} + +function toFinite(value: unknown): number { + return Number.isFinite(Number(value)) ? Number(value) : 0; +} + +function toFirstToken(entry: UsageEntry): number { + if (Number.isFinite(Number(entry.timeToFirstTokenMs))) return Number(entry.timeToFirstTokenMs); + return toFinite(entry.latencyMs); +} + +/** + * Schedule the single deferred retry, off the request path. Never chained: + * the retry attempts the write once and, on failure, writes the existing log + * line and stops. + */ +export function scheduleWriteRetry(entry: UsageEntry): void { + const timer = setTimeout(() => { + try { + attemptWrite(entry); + } catch (retryError) { + console.error("Failed to save usage stats:", retryError); + } + }, RETRY_DELAY_MS); + // Allow Node.js to exit naturally even if the timer is still pending + // (avoids keeping the event loop alive for a stray retry). + detachTimer(timer); +} + +type DetachableTimer = { unref?: () => void }; + +function detachTimer(timer: DetachableTimer): void { + timer.unref?.(); +} diff --git a/tests/unit/usage/usageWriteRetry.test.ts b/tests/unit/usage/usageWriteRetry.test.ts new file mode 100644 index 00000000000..f38b2a9b32a --- /dev/null +++ b/tests/unit/usage/usageWriteRetry.test.ts @@ -0,0 +1,264 @@ +/** + * Gate tests for a usage write blocked by a locked database. + * + * A first attempt that meets a lock is deferred once, off the request path, + * and retried a single time. A second lock drops the row with the existing + * log line. Any other error keeps the current behaviour: logged at once, + * never retried. A first-attempt success never schedules a second write. + */ + +import { test } from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import Database from "better-sqlite3"; + +// Isolate the DB from other tests and from the real data dir. +const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-usage-write-retry-")); +process.env.DATA_DIR = TEST_DATA_DIR; + +// Dynamic imports so DATA_DIR is set before any module initialises the DB. +const core = await import("../../../src/lib/db/core.ts"); +const usageHistory = await import("../../../src/lib/usage/usageHistory.ts"); +const { saveRequestUsage } = usageHistory; + +// Cleanup: close DB handle and temp directory so the test runner doesn't hang. +test.after(() => { + core.resetDbInstance(); + fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }); +}); + +// ── helpers ────────────────────────────────────────────────────────────────── + +let entrySeq = 0; + +function makeEntry(overrides: Record = {}) { + entrySeq++; + const timestamp = new Date(Date.now() + entrySeq).toISOString(); + + return { + provider: "test-provider", + model: "test-model", + connectionId: `conn-retry-${entrySeq}`, + apiKeyId: null, + apiKeyName: null, + tokens: { input_tokens: 10, output_tokens: 20 }, + status: "success", + success: true, + latencyMs: 100, + timeToFirstTokenMs: 50, + errorCode: null, + comboStrategy: null, + endpoint: "/v1/chat/completions", + timestamp, + ...overrides, + }; +} + +function countRows(): number { + const db = core.getDbInstance(); + const row = db.prepare("SELECT COUNT(*) AS cnt FROM usage_history").get() as { cnt: number }; + return row.cnt; +} + +function countRowsFor(connectionId: string): number { + const db = core.getDbInstance(); + const row = db + .prepare("SELECT COUNT(*) AS cnt FROM usage_history WHERE connection_id = ?") + .get(connectionId) as { cnt: number }; + return row.cnt; +} + +/** Hold a write lock on the same SQLite file until released by the caller. */ +function holdWriteLock() { + const db = new Database(path.join(TEST_DATA_DIR, "storage.sqlite")); + db.exec("BEGIN IMMEDIATE"); + return db; +} + +function releaseWriteLock(db: ReturnType) { + try { + db.exec("ROLLBACK"); + } finally { + db.close(); + } +} + +/** Wait until `check()` is true, up to `timeoutMs`, polling every 50 ms. */ +async function waitFor(check: () => boolean, timeoutMs = 5000): Promise { + const deadline = Date.now() + timeoutMs; + for (;;) { + if (check()) return true; + if (Date.now() >= deadline) return false; + await new Promise((resolve) => setTimeout(resolve, 50)); + } +} + +// ── predicate ──────────────────────────────────────────────────────────────── + +test("write lock predicate accepts lock shapes and rejects other errors", async () => { + const { isWriteLockError } = await import("../../../src/lib/usage/usageWriteRetry.ts"); + assert.equal(isWriteLockError(new Error("database is locked")), true); + assert.equal(isWriteLockError(new Error("database table is locked")), true); + assert.equal(isWriteLockError(new Error("database schema is locked")), true); + assert.equal(isWriteLockError(new Error("database is busy")), true); + assert.equal(isWriteLockError({ code: "SQLITE_BUSY" }), true); + assert.equal(isWriteLockError({ code: "SQLITE_LOCKED" }), true); + assert.equal(isWriteLockError({ errcode: 5 }), true); + assert.equal(isWriteLockError({ errcode: 6 }), true); + assert.equal(isWriteLockError({ errcode: 0x0505 }), true); + assert.equal(isWriteLockError("database is locked"), true); + assert.equal(isWriteLockError(new Error("UNIQUE constraint failed: usage_history.id")), false); + assert.equal(isWriteLockError(new Error("no such table: usage_history")), false); +}); + +// ── gate 1: locked first, free second → one row ────────────────────────────── + +test("usage write locked on the first attempt is written once the lock clears", async () => { + const db = core.getDbInstance(); + const before = countRows(); + const errors: unknown[] = []; + const log = console.error; + console.error = (...args: unknown[]) => { + errors.push(args); + }; + const locker = holdWriteLock(); + const entry = makeEntry(); + try { + // Filled while the rival connection holds the lock: the row cannot land yet. + await saveRequestUsage(entry as never); + assert.equal(countRows(), before); + + // Free the base before the deferred attempt runs. + releaseWriteLock(locker); + + assert.equal(await waitFor(() => countRows() === before + 1), true); + assert.equal(countRows(), before + 1); + assert.equal(errors.length, 0); + void db; + } finally { + try { + if (locker.open) releaseWriteLock(locker); + } catch { + // Already released above. + } + console.error = log; + } +}); + +// ── gate 2: locked twice → dropped, logged, no third attempt ──────────────── + +test("usage write locked on both attempts is dropped with one log line", async () => { + const before = countRows(); + const errors: unknown[][] = []; + const log = console.error; + console.error = (...args: unknown[]) => { + errors.push(args); + }; + const locker = holdWriteLock(); + const entry = makeEntry(); + try { + await saveRequestUsage(entry as never); + + // Keep the lock held past the deferred attempt, then wait past any + // further attempt: a third try would need another full delay window. + assert.equal(await waitFor(() => errors.length > 0), true); + const logged = errors.length; + assert.equal(logged, 1); + assert.match(String(errors[0][0]), /Failed to save usage stats:/); + await new Promise((resolve) => setTimeout(resolve, 1500)); + assert.equal(errors.length, logged); + assert.equal(countRows(), before); + } finally { + try { + if (locker.open) releaseWriteLock(locker); + } catch { + // Already released above. + } + console.error = log; + } +}); + +// ── gate 3: non-lock error → current behaviour, no second attempt ──────────── + +test("usage write failing on another error is logged at once and never retried", async () => { + const before = countRows(); + const errors: unknown[][] = []; + const log = console.error; + console.error = (...args: unknown[]) => { + errors.push(args); + }; + try { + // A missing table is never a lock: the current path logs and stops. + const db = core.getDbInstance(); + db.exec("ALTER TABLE usage_history RENAME TO usage_history_backup"); + try { + await saveRequestUsage(makeEntry() as never); + } finally { + db.exec("ALTER TABLE usage_history_backup RENAME TO usage_history"); + } + + assert.equal(errors.length, 1); + assert.match(String(errors[0][0]), /Failed to save usage stats:/); + await new Promise((resolve) => setTimeout(resolve, 1500)); + assert.equal(errors.length, 1); + assert.equal(countRows(), before); + } finally { + console.error = log; + } +}); + +// ── frozen timestamp: first attempt and retry share one value ─────────────── + +test("usage write retry replays the first-attempt timestamp", async () => { + const log = console.error; + console.error = (..._args: unknown[]) => {}; + const locker = holdWriteLock(); + // No timestamp on the entry: the envelope freezes one at the first attempt. + const entry = makeEntry({ connectionId: "conn-retry-frozen-ts" }) as Record; + delete entry.timestamp; + try { + const t0 = new Date().toISOString(); + await saveRequestUsage(entry as never); + + // Free the base before the deferred attempt runs. + releaseWriteLock(locker); + + assert.equal(await waitFor(() => countRowsFor("conn-retry-frozen-ts") === 1), true); + const t1 = new Date().toISOString(); + const row = core + .getDbInstance() + .prepare("SELECT timestamp AS ts FROM usage_history WHERE connection_id = ?") + .get("conn-retry-frozen-ts") as { ts: string }; + // The retry replayed the frozen value, not one recomputed ~1 s later. + assert.ok(row.ts >= t0 && row.ts <= t1); + assert.ok(Date.parse(t1) - Date.parse(row.ts) >= 500); + } finally { + try { + if (locker.open) releaseWriteLock(locker); + } catch { + // Already released above. + } + console.error = log; + } +}); + +// ── gate 4: first-attempt success → no second attempt ──────────────────────── +test("usage write succeeding on the first attempt never writes twice", async () => { + const before = countRows(); + const errors: unknown[] = []; + const log = console.error; + console.error = (...args: unknown[]) => { + errors.push(args); + }; + try { + await saveRequestUsage(makeEntry() as never); + assert.equal(countRows(), before + 1); + await new Promise((resolve) => setTimeout(resolve, 1500)); + assert.equal(countRows(), before + 1); + assert.equal(errors.length, 0); + } finally { + console.error = log; + } +});