import assert from "node:assert/strict" import { test } from "node:test" import { installServerPollCostDiagnostics } from "./server-poll-cost-diagnostics.js" test("promise identity, receiver, arguments and exact descriptor survive instrumentation", async () => { const result = Promise.resolve({ secret: "result" }), values = ["private-parameter"] const config = { text: "SELECT * FROM server_poll_acks WHERE secret=$1", values } const prototype = { query(this: unknown, ...args: unknown[]) { assert.equal(this, client); assert.deepEqual(args, [config]); return result } } const descriptor = Object.getOwnPropertyDescriptor(prototype, "query") const client = Object.create(prototype) as typeof prototype let time = 10 const diagnostics = installServerPollCostDiagnostics({ prototype, now: () => time }) try { assert.equal(client.query(config), result); time = 17; await result assert.deepEqual(diagnostics.snapshot().categories, [{ category: "server_poll_acks:SELECT", count: 1, totalMs: 7, maxMs: 7, errors: 0 }]) assert(!JSON.stringify(diagnostics.snapshot()).includes("private")) const snapshot = diagnostics.snapshot(); snapshot.categories[0].count = 99 assert.equal(diagnostics.snapshot().categories[0].count, 1) } finally { diagnostics.restore() } assert.deepEqual(Object.getOwnPropertyDescriptor(prototype, "query"), descriptor) }) test("callback receiver, all arguments, return and original query return are preserved", () => { const receiver = {}, error = new Error("private-error"), result = { secret: "private-result" }, queryReturn = {} const callbackReturn = {}, params = ["private-param"] const prototype = { query(this: unknown, ...args: unknown[]) { assert.equal(this, client); assert.equal(args[0], "INSERT INTO server_poll_intents VALUES($1)"); assert.equal(args[1], params) assert.equal(Reflect.apply(args[2] as (...values: unknown[]) => unknown, receiver, [error, result, 3]), callbackReturn) return queryReturn } } const client = Object.create(prototype) as typeof prototype const diagnostics = installServerPollCostDiagnostics({ prototype }) try { const callback = function(this: unknown, ...args: unknown[]) { assert.equal(this, receiver); assert.deepEqual(args, [error, result, 3]); return callbackReturn } assert.equal(client.query("INSERT INTO server_poll_intents VALUES($1)", params, callback), queryReturn) const snapshot = diagnostics.snapshot(); assert.equal(snapshot.categories[0].errors, 1) assert(!JSON.stringify(snapshot).includes("private")) } finally { diagnostics.restore() } }) test("rejected promise and synchronous throw keep original identities and are counted once", async () => { const failure = new Error("do-not-log"), promise = Promise.reject(failure) let sync = false const prototype = { query() { if (sync) throw failure; return promise } } const diagnostics = installServerPollCostDiagnostics({ prototype }) try { assert.equal(prototype.query(), promise); await assert.rejects(promise, error => error === failure) sync = true; assert.throws(() => prototype.query(), error => error === failure) assert.equal(diagnostics.snapshot().categories[0].count, 2); assert.equal(diagnostics.snapshot().categories[0].errors, 2) assert(!JSON.stringify(diagnostics.snapshot()).includes("do-not-log")) } finally { diagnostics.restore() } }) test("deferred callbacks aggregate completion costs and preserve receiver", () => { let pending: ((...values: unknown[]) => unknown) | undefined, time = 0 const returned = {}, receiver = {} const prototype = { query(...args: unknown[]) { pending = args[1] as typeof pending; return returned } } const diagnostics = installServerPollCostDiagnostics({ prototype, now: () => time }) try { const callback = function(this: unknown, error: unknown, value: unknown) { assert.equal(this, receiver); assert.equal(error, null); return value } assert.equal(prototype.query("UPDATE servers SET name=$1", callback), returned) assert.equal(diagnostics.snapshot().categories.length, 0) time = 5; assert.equal(Reflect.apply(pending!, receiver, [null, "first"]), "first") time = 10; prototype.query("UPDATE servers SET name=$1", callback) time = 13; assert.equal(Reflect.apply(pending!, receiver, [null, "second"]), "second") assert.deepEqual(diagnostics.snapshot().categories, [{ category: "servers:UPDATE", count: 2, totalMs: 8, maxMs: 5, errors: 0 }]) } finally { diagnostics.restore() } }) test("callback throw propagates without double counting or changing error", () => { const failure = new Error("callback"), prototype = { query(...args: unknown[]) { return Reflect.apply(args[1] as (...values: unknown[]) => unknown, null, [null, {}]) } } const diagnostics = installServerPollCostDiagnostics({ prototype }) try { assert.throws(() => prototype.query("SELECT 1", () => { throw failure }), error => error === failure) assert.equal(diagnostics.snapshot().categories[0].count, 1) assert.equal(diagnostics.snapshot().categories[0].errors, 0) } finally { diagnostics.restore() } }) test("bounded categories use only fixed tags, including overflow", () => { const prototype = { query(...args: unknown[]) { return Reflect.apply(args[1] as (...values: unknown[]) => unknown, null, [null, {}]) } } const diagnostics = installServerPollCostDiagnostics({ prototype }) try { const tables = ["server_poll_storage_admissions", "server_poll_storage_usage", "server_poll_archives", "server_poll_executions", "server_poll_intents", "server_poll_acks", "server_poll_receipts", "server_poll_quarantines", "mcp_operations", "mcp_operation_steps", "mcp_plans", "mcp_connections", "mcp_credentials", "mcp_settings"] for (const table of tables) for (const command of ["SELECT", "INSERT", "UPDATE", "DELETE", "BEGIN", "COMMIT", "ROLLBACK", "SET", "WITH", "SHOW"]) { // Callback completion is synchronous for this test double. prototype.query(`${command} ${table} private-name`, () => {}) } const categories = diagnostics.snapshot().categories assert.equal(categories.length, 128) assert.equal(categories.reduce((sum, item) => sum + item.count, 0), 140) assert.equal(categories.find(item => item.category === "overflow:OTHER")?.count, 13) assert(!JSON.stringify(categories).includes("private")) } finally { diagnostics.restore() } }) test("opaque config getters and unsupported return values remain untouched", () => { const config = { get text(): string { throw Error("must not inspect getter") } }, returned = { opaque: true } const prototype = { query(...args: unknown[]) { assert.equal(args[0], config); return returned } } const diagnostics = installServerPollCostDiagnostics({ prototype, now: () => { throw Error("clock") } }) try { assert.equal(prototype.query(config), returned) assert.deepEqual(diagnostics.snapshot().categories, []) } finally { diagnostics.restore() } }) test("current authority and portal tables have fixed diagnostic categories", () => { const prototype = { query(...args: unknown[]) { return Reflect.apply(args[1] as (...values: unknown[]) => unknown, null, [null, {}]) } } const diagnostics = installServerPollCostDiagnostics({ prototype }) try { for (const table of ["mcp_grants", "mcp_protections", "mcp_owner_revocations"]) prototype.query(`SELECT * FROM ${table}`, () => {}) assert.deepEqual(diagnostics.snapshot().categories.map(row => row.category), ["mcp_grants:SELECT", "mcp_owner_revocations:SELECT", "mcp_protections:SELECT"]) } finally { diagnostics.restore() } })