nntrivi2001
ca821008e2
Measured on a copy of a real 1.2 GB / 253K-event database, 10 simulated browsers + 10 hooks/s for 90 s: event-loop delay p99 1239 ms → 32 ms (max 2.0 s → 94 ms), 266 failed requests → 0, 74 → 111 requests/s served, server RSS 633 → 346 MB. Entry bundle 975 KB raw → 394 KB (106 KB brotli). Server - /api/analytics: the events-table scans run in the read worker (scoped-stats eventAggregates, read-pool job analyticsEvents); runRead takes maxAgeMs — analytics 10 s, /api/workflows 30 s — keyed by the args - /api/workflows/skill-usage: +event_type and a tool_name range instead of LIKE, so it uses idx_events_tool (784 ms → a few ms) - idx_events_session_type_tool (session_id, event_type, tool_name, created_at) replaces idx_events_session_type: covering reads for session stats, the hook dedupes and the import resume point (1.2 s → 20 ms); 64 MB cache_size and 256 MB mmap_size on both connections - WAL: the server sets wal_autocheckpoint = 0 and checkpoints PASSIVE every DASHBOARD_WAL_CHECKPOINT_MS (5 s) from the read worker's own writable connection; a failed checkpoint restores the automatic one (hook COMMIT p95 109 ms → 15 ms at 100 hooks/s) - tmux: one list-sessions answers a whole GET /api/lanes and the heal beat (liveSessions), shared for 1 s and cleared by this process's new/kill — GET /api/run's sync spawns had blocked 60 s of a 90 s run; the heal beat skips tmux when nothing runs; attach options chained into 2 spawns - hooks: TurnDuration/APIError deduped against one read per hook instead of a query per transcript entry (23 ms/hook on a 763-turn session); one lane scan per hook; hourly upserts skip rows that did not grow; frames are sent after the transaction commits (and after the pane binding); new_event carries its row id; a split pane's (slot 1–9) hooks no longer rebind the lane's session_id - watchdog liveness probe runs ps asynchronously; transcript newline scan via indexOf; startup subagent backfill fingerprints the files it already checked - pty attach: backpressure (pause past 1 MB unsent, resume under 256 KB) - static: hashed assets served from their pre-compressed .br/.gz sibling Client - hidden tabs neither refetch on WS events nor poll (useLiveRefresh, panes, lane cards, git header, changes panel, settings); no per-tab hourly /updates/check (the server already checks) - refetch storms throttled (workspace tree/session list 3 s, /api/run only on a run-key change, notification pane lookup only when shown); WS reconnect jitter; terminal retry backoff 1.5 → 30 s, stops on 1008 - heavier throttles for aggregates (15 s) and detail views; Monitor keepIfSame; GET in-flight dedupe in request() - lazy Dashboard/History, xterm (with the first terminal), lane modals, Sagi (only while enabled); only the active locale loads; Workspace chunk prefetched on a /workspace deep link - Sagi: no work while disabled, pupil via CSS variables, memo avatar - build: .br/.gz siblings, sourcemap hidden; service worker no longer caches /assets/ (cache v3 drops the old one) Tests: scripts/test-server.js drops the GIT_DIR-family variables a hook exports, so a suite run from a linked worktree's pre-commit can no longer commit into the real repository or set core.bare. Docs: ARCHITECTURE, DATABASE, API, DEPLOYMENT, client README, docs/plans/perf/README.md (audit, checklist, results).
73 lines
2.4 KiB
JavaScript
73 lines
2.4 KiB
JavaScript
/**
|
|
* @file Per-hour token usage (`token_usage_hourly`): written from a Claude
|
|
* transcript's `tokensByHour` (`server/lib/transcript-cache.js`) by the hook
|
|
* writer, back-filled once for sessions recorded before the table existed, and
|
|
* read only by the daily cost split in `GET /api/pricing/cost` — so a session
|
|
* that runs for days books each day's spend to that day instead of its start.
|
|
* @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
|
|
*/
|
|
|
|
const { db, stmts } = require("../db");
|
|
const TranscriptCache = require("./transcript-cache");
|
|
|
|
/** Write every hour of one transcript parse (MAX per hour, see the statement). */
|
|
function writeHourly(sessionId, tokensByHour) {
|
|
// Runs every hour of the session on each hook — ~1 row per active hour per
|
|
// model; the statement leaves a row that did not grow untouched (no write).
|
|
for (const t of Object.values(tokensByHour || {})) {
|
|
stmts.upsertHourlyUsage.run(
|
|
sessionId,
|
|
t.hour,
|
|
t.model,
|
|
t.speed,
|
|
t.geo,
|
|
t.tier,
|
|
t.input,
|
|
t.output,
|
|
t.cacheRead,
|
|
t.cacheWrite,
|
|
t.cacheWrite1h,
|
|
t.webSearch,
|
|
t.webFetch,
|
|
t.codeExec
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fill the table for Claude sessions that have tokens but no hourly rows yet,
|
|
* one transcript per tick so a large history never blocks the event loop.
|
|
* Resolves with the number of sessions written.
|
|
*/
|
|
function backfillHourly() {
|
|
const rows = db
|
|
.prepare(
|
|
`SELECT s.id, s.transcript_path FROM sessions s
|
|
WHERE s.transcript_path IS NOT NULL AND s.transcript_path != ''
|
|
AND EXISTS (SELECT 1 FROM token_usage tu WHERE tu.session_id = s.id)
|
|
AND NOT EXISTS (SELECT 1 FROM token_usage_hourly h WHERE h.session_id = s.id)`
|
|
)
|
|
.all();
|
|
const cache = new TranscriptCache(1);
|
|
let written = 0;
|
|
return new Promise((resolve) => {
|
|
const next = (i) => {
|
|
if (i >= rows.length) return resolve(written);
|
|
const { id, transcript_path } = rows[i];
|
|
try {
|
|
const result = cache.extract(transcript_path);
|
|
if (result?.tokensByHour && Object.keys(result.tokensByHour).length > 0) {
|
|
db.transaction(() => writeHourly(id, result.tokensByHour))();
|
|
written++;
|
|
}
|
|
} catch {
|
|
/* an unreadable transcript keeps its start-date booking */
|
|
}
|
|
setImmediate(() => next(i + 1));
|
|
};
|
|
next(0);
|
|
});
|
|
}
|
|
|
|
module.exports = { writeHourly, backfillHourly };
|