@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
74 lines (68 loc) • 3.54 kB
text/typescript
/**
* Runtime owner for the opt-in usage-ledger size limit (#5063).
*
* The compactor in `src/usage/ledger-retention.ts` knows how to publish a smaller ledger safely.
* This is the part that decides when, and -- the half #5063 was missing -- what has to be
* discarded afterwards.
*
* Deleting rows from usage.jsonl invalidates three readers that do not watch the file: the
* 2,000-entry Logs ring, which otherwise keeps serving rows the ledger no longer has; the
* retained usage aggregate and failure projection, whose checkpoints now point past a boundary
* that moved; and the request-history index, whose source identity has changed. A compaction
* that skips any of them makes the dashboard disagree with the ledger, which is the disagreement
* this batch exists to remove.
*/
import { currentUsageLogRevision, setUsageLedgerAppendHook } from "../usage/log";
import { enforceUsageLedgerSizeLimit } from "../usage/ledger-retention";
import { discardRetainedFailureProjection } from "../usage/failure-projection-cache";
import { rehydrateRequestLogsAfterLedgerReplacement } from "./request-log";
import type { UsageLedgerRetentionStatus } from "../usage/retention-contract";
let configuredMaxBytes: number | undefined;
let enforcing = false;
function invalidateLedgerReaders(): void {
// Ordered cheapest-first, and each guarded on its own: a projection that fails to discard
// must not stop the ring from being rebuilt, because the ring is the surface an operator is
// looking at while this happens.
try { discardRetainedFailureProjection(); } catch { /* rebuildable by construction */ }
void (async () => {
try {
const { discardRetainedUsageAggregate } = await import("./management/usage-aggregate-cache");
discardRetainedUsageAggregate();
} catch { /* rebuildable by construction */ }
try {
const { closeRequestHistoryIndex } = await import("../routing/history/indexer");
closeRequestHistoryIndex();
} catch { /* the index rebuilds from its own source-identity contract */ }
})();
try { rehydrateRequestLogsAfterLedgerReplacement(); } catch { /* the ring refills as rows arrive */ }
}
function enforceNow(): void {
// Re-entrancy guard, not a lock. The compaction itself runs inside the append call stack, and
// its own publication writes nothing through appendUsageEntry -- this exists so a future
// caller on that path cannot start a second pass over a file the first one is replacing.
if (enforcing) return;
enforcing = true;
try {
const result = enforceUsageLedgerSizeLimit(configuredMaxBytes);
if (result.kind === "replaced") invalidateLedgerReaders();
} catch (error) {
// Never fail a request because history could not be trimmed. The limit is not enforced and
// says so; the next append tries again from a fresh revision.
console.warn(
`[usage-retention] could not enforce the usage ledger size limit: ${error instanceof Error ? error.message : String(error)}`,
);
} finally {
enforcing = false;
}
}
/** Install or update the policy. `undefined` removes the hook entirely. */
export function setUsageLedgerRetention(maxBytes: number | undefined): void {
configuredMaxBytes = maxBytes;
setUsageLedgerAppendHook(maxBytes === undefined ? null : enforceNow);
}
export function usageLedgerRetentionStatus(): UsageLedgerRetentionStatus {
return {
...(configuredMaxBytes !== undefined ? { maxBytes: configuredMaxBytes } : {}),
currentBytes: currentUsageLogRevision()?.size ?? 0,
};
}