Files
MikrotikManager/backend/src/services/server-poll-cost-diagnostics.ts
T

70 lines
4.0 KiB
TypeScript

/** Opt-in owned-run diagnostics. Wrapping query is not unwrapped acceptance. */
import pg from "pg"
import { performance } from "node:perf_hooks"
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",
"mcp_grants", "mcp_protections", "mcp_owner_revocations",
"operation_config_locks", "settings", "servers", "server_interfaces", "server_ip_addresses"] as const
const TABLE_PATTERNS = TABLES.map(name => ({ name, pattern: new RegExp(`\\b${name}\\b`, "i") }))
const COMMANDS = new Set(["SELECT", "INSERT", "UPDATE", "DELETE", "BEGIN", "COMMIT", "ROLLBACK", "SET", "WITH", "SHOW"])
export interface ServerPollQueryCost { category: string; count: number; totalMs: number; maxMs: number; errors: number }
function category(args: unknown[]): string {
// Inspect only a bounded SQL prefix, never values, results or error text.
const first = args[0]
const descriptor = first && typeof first === "object" ? Object.getOwnPropertyDescriptor(first, "text") : undefined
const sql = typeof first === "string" ? first.slice(0, 65536) : typeof descriptor?.value === "string" ? descriptor.value.slice(0, 65536) : ""
const token = /^\s*([a-z]+)/i.exec(sql)?.[1]?.toUpperCase() ?? "OTHER"
const command = COMMANDS.has(token) ? token : "OTHER"
const table = TABLE_PATTERNS.find(entry => entry.pattern.test(sql))?.name ?? "other"
return `${table}:${command}`
}
export function installServerPollCostDiagnostics(options: { prototype?: object; now?: () => number } = {}) {
const prototype = options.prototype ?? pg.Client.prototype
const original = Object.getOwnPropertyDescriptor(prototype, "query")
if (!original || typeof original.value !== "function") throw new Error("Expected an own query method")
const query = original.value as (this: unknown, ...args: unknown[]) => unknown
const now = options.now ?? (() => performance.now())
const costs = new Map<string, ServerPollQueryCost>()
// Instrumentation must never replace a query's success or failure.
const clock = () => { try { const value = now(); return Number.isFinite(value) ? value : 0 } catch { return 0 } }
function wrapped(this: unknown, ...args: unknown[]) {
const started = clock()
let key = "other:OTHER"
try { key = category(args) } catch { /* Exotic query objects remain untouched. */ }
let completed = false
const finish = (error: boolean) => {
if (completed) return
completed = true
const elapsed = Math.max(0, clock() - started)
if (!costs.has(key) && costs.size >= 127) key = "overflow:OTHER"
const cost = costs.get(key) ?? { category: key, count: 0, totalMs: 0, maxMs: 0, errors: 0 }
cost.count++; cost.totalMs += elapsed; cost.maxMs = Math.max(cost.maxMs, elapsed); cost.errors += Number(error)
costs.set(key, cost)
}
const callback = args[args.length - 1]
const hasCallback = typeof callback === "function"
if (hasCallback) args[args.length - 1] = function(this: unknown, ...values: unknown[]) {
finish(Boolean(values[0]))
return Reflect.apply(callback, this, values)
}
try {
const returned = Reflect.apply(query, this, args)
if (!hasCallback && returned instanceof Promise) {
// Observe without returning a chained promise or creating an unhandled rejection.
void Promise.prototype.then.call(returned, () => finish(false), () => finish(true)).catch(() => {})
}
return returned
} catch (error) { finish(true); throw error }
}
Object.defineProperty(prototype, "query", { ...original, value: wrapped })
return {
snapshot: () => ({ diagnosticOnly: true as const, wrappedPgQuery: true as const,
categories: [...costs.values()].map(value => ({ ...value })).sort((a, b) => a.category.localeCompare(b.category)) }),
restore: () => { Object.defineProperty(prototype, "query", original) },
}
}