Skip to content

Commit 148612e

Browse files
fix(opencode): usage scans reuse unchanged rows and run off the event loop (pingdotgg#34897)
1 parent 9b6dde9 commit 148612e

2 files changed

Lines changed: 179 additions & 12 deletions

File tree

‎packages/provider-opencode/src/server/usage.test.ts‎

Lines changed: 93 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
import type * as NodeWorkerThreads from "node:worker_threads";
12
import * as NodeServices from "@effect/platform-node/NodeServices";
23
import { assert, describe, it } from "@effect/vitest";
34
import { DEFAULT_SERVER_SETTINGS, ProviderInstanceId } from "@t3tools/contracts";
@@ -13,6 +14,27 @@ import { vi } from "vite-plus/test";
1314

1415
import { openCodeUsageReader, readOpenCodeUsage } from "./usage.ts";
1516

17+
const readerWorkers = vi.hoisted(() => ({ started: 0, enabled: false }));
18+
19+
// Statement spies only see the main thread, so reader workers fail to start unless a test enables them.
20+
vi.mock("node:worker_threads", async (importOriginal) => {
21+
const actual = await importOriginal<typeof NodeWorkerThreads>();
22+
class ReaderWorker extends actual.Worker {
23+
constructor(...args: ConstructorParameters<typeof actual.Worker>) {
24+
super(
25+
...((readerWorkers.enabled
26+
? args
27+
: [
28+
"throw new Error('reader workers disabled');",
29+
{ eval: true },
30+
]) as ConstructorParameters<typeof actual.Worker>),
31+
);
32+
readerWorkers.started++;
33+
}
34+
}
35+
return { ...actual, Worker: ReaderWorker };
36+
});
37+
1638
const openDatabase = (filename: string) =>
1739
Layer.build(NodeSqliteClient.layer({ filename })).pipe(
1840
Effect.map(Context.get(SqlClient.SqlClient)),
@@ -141,6 +163,7 @@ describe("readOpenCodeUsage", () => {
141163
);
142164
}
143165
let statements = 0;
166+
let bodyReads = 0;
144167
const originalAll = NodeSqlite.StatementSync.prototype.all;
145168
yield* Effect.acquireRelease(
146169
Effect.sync(() =>
@@ -149,6 +172,7 @@ describe("readOpenCodeUsage", () => {
149172
...params
150173
) {
151174
statements++;
175+
if (this.sourceSQL.includes("data ->")) bodyReads++;
152176
return originalAll.apply(this, params);
153177
}),
154178
),
@@ -161,6 +185,51 @@ describe("readOpenCodeUsage", () => {
161185
["opencode:a", "opencode:b", "opencode:c"],
162186
);
163187
assert.isBelow(statements, 10);
188+
189+
bodyReads = 0;
190+
const repeated = yield* readOpenCodeUsage(dir, sinceMs);
191+
assert.deepStrictEqual(
192+
repeated.files.flatMap((file) => file.records).map((record) => record.dedupeKey),
193+
["opencode:a", "opencode:b", "opencode:c"],
194+
);
195+
// An unchanged database must not have its message bodies read and parsed again.
196+
assert.strictEqual(bodyReads, 0);
197+
}).pipe(Effect.provide(NodeServices.layer)),
198+
);
199+
200+
it.effect("does not reuse rows from a replaced or restored database file", () =>
201+
Effect.gen(function* () {
202+
const fileSystem = yield* FileSystem.FileSystem;
203+
const path = yield* Path.Path;
204+
const dir = yield* fileSystem.makeTempDirectoryScoped({ prefix: "usage-replaced-" });
205+
const write = (name: string, input: number) =>
206+
Effect.scoped(
207+
Effect.gen(function* () {
208+
const db = yield* openDatabase(path.join(dir, name));
209+
yield* db.unsafe("PRAGMA journal_mode = WAL");
210+
yield* db.unsafe(
211+
"CREATE TABLE message (id TEXT, session_id TEXT, time_created INTEGER, time_updated INTEGER, data TEXT)",
212+
);
213+
yield* db.unsafe(
214+
"INSERT INTO message(rowid, id, session_id, time_created, time_updated, data) VALUES (1, 'a', 's', 1, 1, ?)",
215+
[JSON.stringify({ modelID: "m", tokens: { input } })],
216+
);
217+
}),
218+
);
219+
const input = Effect.map(
220+
readOpenCodeUsage(dir, 0),
221+
(result) => result.files[0]?.records[0]?.totals.uncachedInputTokens,
222+
);
223+
yield* write("opencode.db", 100);
224+
assert.strictEqual(yield* input, 100);
225+
yield* write("replacement.db", 900);
226+
yield* fileSystem.rename(path.join(dir, "replacement.db"), path.join(dir, "opencode.db"));
227+
assert.strictEqual(yield* input, 900);
228+
// A backup restored in place keeps the inode and birth time, like `cp -p`.
229+
yield* write("backup.db", 500);
230+
yield* fileSystem.copyFile(path.join(dir, "backup.db"), path.join(dir, "opencode.db"));
231+
yield* fileSystem.utimes(path.join(dir, "opencode.db"), 0, 0);
232+
assert.strictEqual(yield* input, 500);
164233
}).pipe(Effect.provide(NodeServices.layer)),
165234
);
166235

@@ -188,6 +257,27 @@ describe("readOpenCodeUsage", () => {
188257
const legacy = path.join(dir, "storage", "message", message.sessionID);
189258
yield* fileSystem.makeDirectory(legacy, { recursive: true });
190259
yield* fileSystem.writeFileString(path.join(legacy, "msg-1.json"), JSON.stringify(message));
260+
yield* Effect.acquireRelease(
261+
Effect.sync(() => {
262+
readerWorkers.enabled = true;
263+
readerWorkers.started = 0;
264+
}),
265+
() => Effect.sync(() => (readerWorkers.enabled = false)),
266+
);
267+
let mainThreadBodyReads = 0;
268+
const originalAll = NodeSqlite.StatementSync.prototype.all;
269+
yield* Effect.acquireRelease(
270+
Effect.sync(() =>
271+
vi.spyOn(NodeSqlite.StatementSync.prototype, "all").mockImplementation(function (
272+
this: NodeSqlite.StatementSync,
273+
...params
274+
) {
275+
if (this.sourceSQL.includes("data ->")) mainThreadBodyReads++;
276+
return originalAll.apply(this, params);
277+
}),
278+
),
279+
(spy) => Effect.sync(() => spy.mockRestore()),
280+
);
191281
const first = yield* readOpenCodeUsage(dir, 0);
192282
assert.isFalse(first.error);
193283
const records = first.files.flatMap((file) => file.records);
@@ -212,6 +302,9 @@ describe("readOpenCodeUsage", () => {
212302
["opencode:msg-2"],
213303
);
214304
assert.isAbove(Number((yield* fileSystem.stat(path.join(dir, "opencode.db-wal"))).size), 0);
305+
// A large database must not be read on the server's event loop.
306+
assert.isAbove(readerWorkers.started, 0);
307+
assert.strictEqual(mainThreadBodyReads, 0);
215308
}).pipe(Effect.provide(NodeServices.layer)),
216309
);
217310

‎packages/provider-opencode/src/server/usage.ts‎

Lines changed: 86 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@ import * as FileSystem from "effect/FileSystem";
1111
import * as Option from "effect/Option";
1212
import * as Path from "effect/Path";
1313
import type * as PlatformError from "effect/PlatformError";
14+
import * as Semaphore from "effect/Semaphore";
1415
import * as SqlClient from "effect/sql/SqlClient";
1516

1617
import type { OpenCodeSettings } from "../settings.ts";
@@ -93,6 +94,18 @@ export interface OpenCodeUsageReadResult {
9394
readonly error: boolean;
9495
}
9596

97+
interface CachedRow {
98+
readonly updated: unknown;
99+
readonly size: unknown;
100+
readonly created: unknown;
101+
readonly record: UsageRecord | null;
102+
}
103+
104+
// Parsed rows by `${databasePath}\0${table}`, then rowid, so unchanged rows are not read again.
105+
const rowCache = new Map<string, { version: string; rows: Map<number, CachedRow> }>();
106+
// Concurrent scans of the same database would each read every uncached row.
107+
const scanLock = Semaphore.makeUnsafe(1);
108+
96109
const isNotFound = (cause: PlatformError.PlatformError) => cause.reason._tag === "NotFound";
97110
const MESSAGE_PAGE_SIZE = 64;
98111

@@ -116,6 +129,7 @@ const LEGACY_STAT_BATCH = 256;
116129
export const readOpenCodeUsage = Effect.fn("readOpenCodeUsage")(function* (
117130
root: string,
118131
sinceMs: number,
132+
retentionCutoffMs = sinceMs,
119133
): Effect.fn.Return<OpenCodeUsageReadResult, never, FileSystem.FileSystem | Path.Path> {
120134
const fileSystem = yield* FileSystem.FileSystem;
121135
const path = yield* Path.Path;
@@ -164,6 +178,22 @@ export const readOpenCodeUsage = Effect.fn("readOpenCodeUsage")(function* (
164178
found = true;
165179
const file = { path: path.join(root, name), records: [] as UsageRecord[] };
166180
files.push(file);
181+
// Taken before the snapshot opens, so a write that races the scan invalidates its rows.
182+
const [main, wal] = yield* Effect.forEach([file.path, `${file.path}-wal`], (target) =>
183+
Effect.option(fileSystem.stat(target)),
184+
);
185+
const stamp = (info: Option.Option<FileSystem.File.Info>) =>
186+
Option.match(info, {
187+
onNone: () => "none",
188+
onSome: (stat) => `${stat.size}:${Option.getOrNull(stat.mtime)?.getTime()}`,
189+
});
190+
// A replaced or restored database can repeat rowids and change markers, so every key includes
191+
// the main file; WAL commits leave it alone until a checkpoint.
192+
const identity = Option.match(main!, {
193+
onNone: () => "none",
194+
onSome: (stat) =>
195+
`${stat.dev}:${Option.getOrNull(stat.ino)}:${Option.getOrNull(stat.birthtime)?.getTime()}/${stamp(main!)}`,
196+
});
167197
yield* Effect.gen(function* () {
168198
const sql = yield* SqlClient.SqlClient;
169199
// Fail promptly on live-writer locks instead of stalling the server.
@@ -182,30 +212,53 @@ export const readOpenCodeUsage = Effect.fn("readOpenCodeUsage")(function* (
182212
),
183213
);
184214
const timestamp = columns.has("time_created") ? "time_created" : "NULL";
215+
const updated = columns.has("time_updated") ? "time_updated" : "NULL";
216+
// Without time_updated an in-place edit can keep the length, so any database write counts.
217+
const version = updated === "NULL" ? `${identity}/${stamp(wal!)}` : identity;
185218
const predicates = table === "session_message" ? ["type = 'assistant'"] : [];
186219
if (timestamp !== "NULL") predicates.push("time_created >= ?");
187-
// List only rowids so SQLite can use time indexes without reading message bodies.
188-
const listed = (yield* sql.unsafe<{ readonly row_id: number }>(
189-
`SELECT rowid AS row_id FROM ${table}
220+
// List rowids and change markers so SQLite can use time indexes without reading message
221+
// bodies; octet_length comes from the record header.
222+
const listed = (yield* sql.unsafe<{
223+
readonly row_id: number;
224+
readonly updated: unknown;
225+
readonly size: unknown;
226+
readonly created: unknown;
227+
}>(
228+
`SELECT rowid AS row_id, ${updated} AS updated, octet_length(data) AS size,
229+
${timestamp} AS created
230+
FROM ${table}
190231
${predicates.length ? `WHERE ${predicates.join(" AND ")}` : ""}`,
191232
timestamp === "NULL" ? [] : [sinceMs],
192233
)).toSorted((a, b) => a.row_id - b.row_id);
193234
databaseRows += listed.length;
235+
const key = `${file.path}\0${table}`;
236+
const previous = rowCache.get(key);
237+
const reusable = previous?.version === version ? previous.rows : undefined;
238+
const cached = new Map<number, CachedRow>();
239+
const misses: typeof listed = [];
240+
for (const row of listed) {
241+
const hit = reusable?.get(row.row_id);
242+
if (hit && hit.updated === row.updated && hit.size === row.size)
243+
cached.set(row.row_id, hit);
244+
else misses.push(row);
245+
}
194246
// Filter and project in SQLite: user diffs and assistant bodies can be hundreds of MB.
195247
const validAssistant = `CASE WHEN typeof(data) = 'text' AND json_valid(data)
196248
THEN json_type(data, '$.role') IS NULL OR data ->> '$.role' = 'assistant' END`;
197249
// Omit per-page spans; the enclosing scan records row and page counts.
198-
for (let start = 0; start < listed.length; start += MESSAGE_PAGE_SIZE) {
199-
const page = listed.slice(start, start + MESSAGE_PAGE_SIZE);
250+
for (let start = 0; start < misses.length; start += MESSAGE_PAGE_SIZE) {
251+
const page = misses.slice(start, start + MESSAGE_PAGE_SIZE);
200252
databasePages++;
201253
const rows = yield* sql
202254
.unsafe<{
255+
readonly row_id: number;
203256
readonly id: unknown;
204257
readonly session_id: unknown;
205258
readonly data: unknown;
206259
readonly created: unknown;
207260
}>(
208-
`SELECT id, session_id, ${timestamp} AS created, json_object(
261+
`SELECT rowid AS row_id, id, session_id, ${timestamp} AS created, json_object(
209262
'tokens', data -> '$.tokens', 'cost', data -> '$.cost',
210263
'model', data -> '$.model', 'modelID', data -> '$.modelID',
211264
'providerID', data -> '$.providerID',
@@ -217,22 +270,39 @@ export const readOpenCodeUsage = Effect.fn("readOpenCodeUsage")(function* (
217270
page.map((row) => row.row_id),
218271
)
219272
.pipe(Effect.withTracerEnabled(false));
273+
const parsed = new Map<number, UsageRecord | null>();
220274
for (const row of rows) {
221-
append(
222-
file.records,
275+
parsed.set(
276+
row.row_id,
223277
parseOpenCodeMessage(text(row.data), {
224278
id: text(row.id),
225279
sessionId: text(row.session_id),
226280
...(typeof row.created === "number" ? { timestampMs: row.created } : {}),
227281
}),
228282
);
229283
}
284+
// Rows the SQL filter dropped are cached as empty so they are not read again either.
285+
for (const row of page) {
286+
cached.set(row.row_id, { ...row, record: parsed.get(row.row_id) ?? null });
287+
}
230288
yield* Effect.yieldNow;
231289
}
290+
for (const row of listed) append(file.records, cached.get(row.row_id)!.record);
291+
// Rows before this window were not listed; keep them for a wider window until retention.
292+
for (const [rowId, entry] of reusable ?? []) {
293+
const created = entry.created;
294+
if (typeof created === "number" && created < sinceMs && created >= retentionCutoffMs)
295+
cached.set(rowId, entry);
296+
}
297+
rowCache.set(key, { version, rows: cached });
232298
}
233299
}).pipe(
234300
(read) => Effect.flatMap(SqlClient.SqlClient, (sql) => sql.withTransaction(read)),
235-
Effect.provide(NodeSqliteClient.layer({ filename: file.path, readonly: true })),
301+
// Run the scan on a reader worker so large databases do not block the server's event loop.
302+
NodeSqliteClient.readOnly,
303+
Effect.provide(
304+
NodeSqliteClient.layer({ filename: file.path, readonly: true, readerWorker: true }),
305+
),
236306
Effect.catchTags({
237307
SqlError: () => {
238308
error = true;
@@ -312,7 +382,7 @@ export const readOpenCodeUsage = Effect.fn("readOpenCodeUsage")(function* (
312382
"usage.database_pages": databasePages,
313383
});
314384
return { files, missing: !found && !error, error };
315-
});
385+
}, scanLock.withPermit);
316386

317387
const resolveOpenCodeDataDirs = Effect.fn("resolveOpenCodeDataDirs")(function* (
318388
environment: NodeJS.ProcessEnv,
@@ -346,15 +416,19 @@ export type OpenCodeUsageReaderEnv = FileSystem.FileSystem | Path.Path;
346416
export const openCodeUsageReader: ProviderUsageReader<OpenCodeSettings, OpenCodeUsageReaderEnv> = {
347417
kind: "scan",
348418
provider: "opencode",
349-
scan: Effect.fn("openCodeUsageReader.scan")(function* ({ instances, windowStartMs }) {
419+
scan: Effect.fn("openCodeUsageReader.scan")(function* ({
420+
instances,
421+
windowStartMs,
422+
retentionCutoffMs,
423+
}) {
350424
const roots = new Set<string>();
351425
for (const instance of instances) {
352426
for (const root of yield* resolveOpenCodeDataDirs(instance.environment)) roots.add(root);
353427
}
354428
return yield* Effect.forEach(
355429
roots,
356430
(dir) =>
357-
readOpenCodeUsage(dir, windowStartMs).pipe(
431+
readOpenCodeUsage(dir, windowStartMs, retentionCutoffMs).pipe(
358432
Effect.map((result) => ({
359433
dir,
360434
files: result.missing && !result.error ? null : result.files,

0 commit comments

Comments
 (0)