adonisjs-server-stats 1.16.0 → 1.17.0

package/dist/src/dashboard/write_queue.js

@@ -6,6 +6,8 @@
  * be tested in isolation.
  */
 import { round } from '../utils/math_helpers.js';
+import { yieldToEventLoop } from './migrator_tables.js';
+import { sanitizeBindings, sanitizeRecordValues } from './sensitive_patterns.js';
 // ---------------------------------------------------------------------------
 // Warn-once tracking for write-path catch blocks
 // ---------------------------------------------------------------------------
@@ -16,6 +18,14 @@ export function hasWarned(path) {
 export function markWarned(path) {
     warnedWritePaths.add(path);
 }
+/**
+ * Forget which write paths have warned. Called when a DashboardStore stops so
+ * a re-initialized store in the same process warns afresh instead of
+ * inheriting a spent latch from its predecessor.
+ */
+export function resetWriteWarnings() {
+    warnedWritePaths.clear();
+}
 // ---------------------------------------------------------------------------
 // SQL normalization
 // ---------------------------------------------------------------------------
@@ -36,32 +46,11 @@ export function normalizeSql(sql) {
         .trim();
 }
 // ---------------------------------------------------------------------------
-// Binding hygiene
+// Binding hygiene — implementation lives in sensitive_patterns.ts so the
+// in-memory QueryCollector can sanitize at capture time without importing the
+// write path. Re-exported here for existing consumers.
 // ---------------------------------------------------------------------------
-/** Max length for a persisted string binding before it is truncated. */
-const MAX_BINDING_LEN = 256;
-/**
- * Redact/truncate SQL bindings before persistence so secret-looking values
- * (long tokens, hashes, keys) are not stored in cleartext.
- *
- * Conservative: only long strings are truncated; short values (ids, flags,
- * emails, ordinary params) pass through so normal capture is unaffected.
- */
-export function sanitizeBindings(bindings) {
-    if (Array.isArray(bindings))
-        return bindings.map(sanitizeBindings);
-    if (typeof bindings === 'string' && bindings.length > MAX_BINDING_LEN) {
-        return bindings.slice(0, MAX_BINDING_LEN) + `…[truncated ${bindings.length} chars]`;
-    }
-    if (bindings && typeof bindings === 'object') {
-        const out = {};
-        for (const [k, v] of Object.entries(bindings)) {
-            out[k] = sanitizeBindings(v);
-        }
-        return out;
-    }
-    return bindings;
-}
+export { sanitizeBindings };
 // ---------------------------------------------------------------------------
 // Pure data-prep functions
 // ---------------------------------------------------------------------------
@@ -78,13 +67,14 @@ export function prepareRequestRows(requests) {
             .map((q) => ({
             sql_text: q.sql,
             sql_normalized: normalizeSql(q.sql),
-            bindings: q.bindings ? JSON.stringify(sanitizeBindings(q.bindings)) : null,
+            bindings: q.bindings ? JSON.stringify(sanitizeBindings(q.bindings, q.sql)) : null,
             duration: round(q.duration),
             method: q.method,
             model: q.model,
             connection: q.connection,
             in_transaction: q.inTransaction ? 1 : 0,
         })),
+        eventRows: buildEventRows(input.events ?? []),
         traceRow: input.trace
             ? {
                 method: input.trace.method,
@@ -100,6 +90,13 @@ export function prepareRequestRows(requests) {
 }
 /**
  * Transform raw log entries into SQLite-ready row objects.
+ *
+ * The full pino record lands in `data`, and log lines routinely carry bound
+ * request context — authorization headers, cookies, tokens in payloads — so
+ * the record is run through the shared redaction rules (secret-named keys and
+ * credential-shaped values) before it is stringified. The `message` column is
+ * kept verbatim: it is free text, and the shape rules are anchored to whole
+ * values, so prose stays readable.
  */
 export function prepareLogRows(logs) {
     return logs.map((entry) => {
@@ -110,7 +107,7 @@ export function prepareLogRows(logs) {
             request_id: entry.request_id || entry.requestId || entry['x-request-id']
                 ? String(entry.request_id || entry.requestId || entry['x-request-id'])
                 : null,
-            data: JSON.stringify(entry),
+            data: JSON.stringify(sanitizeRecordValues(entry)),
         };
     });
 }
@@ -135,9 +132,14 @@ export function buildEmailRow(record) {
 /**
  * Transform EventRecords into SQLite-ready row objects.
  */
+/**
+ * Build event rows. `request_id` is attached at insert time, once the owning
+ * request row has an id — leaving it null here (as this did previously) meant
+ * retention never reclaimed them, since events are only pruned via the
+ * `server_stats_requests` foreign-key cascade.
+ */
 export function buildEventRows(events) {
     return events.map((e) => ({
-        request_id: null,
         event_name: e.event,
         data: e.data,
     }));
@@ -147,9 +149,16 @@ export function buildEventRows(events) {
 // ---------------------------------------------------------------------------
 /**
  * Insert rows into a table in batches of 50.
+ *
+ * Yields to the event loop between chunks: better-sqlite3 is fully
+ * synchronous, so without a real macrotask hop a large batch would execute
+ * back-to-back on microtask continuations and stall the host app — the exact
+ * failure mode `migrator_tables.ts` documents and guards against.
  */
 export async function batchInsert(trx, table, rows) {
     for (let i = 0; i < rows.length; i += 50) {
+        if (i > 0)
+            await yieldToEventLoop();
         await trx(table).insert(rows.slice(i, i + 50));
     }
 }
@@ -176,7 +185,7 @@ function buildRequestRow(input) {
 }
 /** Insert a single prepared request with its queries and trace. */
 async function insertOneRequest(trx, prepared) {
-    const { input, filteredQueries, traceRow } = prepared;
+    const { input, filteredQueries, traceRow, eventRows } = prepared;
     const row = buildRequestRow(input);
     const [requestId] = await trx('server_stats_requests').insert(row);
     const hasId = requestId !== null && requestId !== undefined;
@@ -184,12 +193,24 @@ async function insertOneRequest(trx, prepared) {
         const rows = filteredQueries.map((q) => ({ ...q, request_id: requestId }));
         await batchInsert(trx, 'server_stats_queries', rows);
     }
+    if (hasId && eventRows.length > 0) {
+        const rows = eventRows.map((e) => ({ ...e, request_id: requestId }));
+        await batchInsert(trx, 'server_stats_events', rows);
+    }
     if (hasId && traceRow) {
         await trx('server_stats_traces').insert({ ...traceRow, request_id: requestId });
     }
 }
 export async function flushRequests(trx, preparedRequests) {
+    let sinceYield = 0;
     for (const prepared of preparedRequests) {
+        // Up to ~4 synchronous statements per request; a full backlog is hundreds
+        // of them in one flush. Yield periodically so the host app's I/O keeps
+        // being serviced mid-flush (see batchInsert for why awaits alone don't).
+        if (++sinceYield >= 10) {
+            sinceYield = 0;
+            await yieldToEventLoop();
+        }
         try {
             await insertOneRequest(trx, prepared);
         }
@@ -202,24 +223,6 @@ export async function flushRequests(trx, preparedRequests) {
         }
     }
 }
-/**
- * Flush pending events into the database.
- */
-export async function flushEvents(trx, events) {
-    for (const { events: evts } of events) {
-        try {
-            const rows = buildEventRows(evts);
-            await batchInsert(trx, 'server_stats_events', rows);
-        }
-        catch (err) {
-            if (!hasWarned('recordEvents')) {
-                markWarned('recordEvents');
-                const { log } = await import('../utils/logger.js');
-                log.warn(`dashboard: recordEvents failed — ${err?.message}`);
-            }
-        }
-    }
-}
 /**
  * Flush pending emails into the database.
  */

package/dist/src/debug/event_collector.d.ts

@@ -12,6 +12,14 @@ export declare class EventCollector {
     private circulars;
     private summarizeData;
     getEvents(): EventRecord[];
+    /**
+     * Events recorded after `lastId`, oldest first.
+     *
+     * Mirrors `QueryCollector.getQueriesSince` and drives the dashboard's
+     * request pipe, which persists whatever accumulated since the previous
+     * request completed.
+     */
+    getEventsSince(lastId: number): EventRecord[];
     getLatest(n?: number): EventRecord[];
     getTotalCount(): number;
     getBufferInfo(): {

package/dist/src/debug/event_collector.js

@@ -135,6 +135,18 @@ export class EventCollector {
     getEvents() {
         return this.buffer.toArray().reverse();
     }
+    /**
+     * Events recorded after `lastId`, oldest first.
+     *
+     * Mirrors `QueryCollector.getQueriesSince` and drives the dashboard's
+     * request pipe, which persists whatever accumulated since the previous
+     * request completed.
+     */
+    getEventsSince(lastId) {
+        if (lastId <= 0)
+            return this.buffer.toArray();
+        return this.buffer.collectFromEnd((e) => e.id > lastId);
+    }
     getLatest(n = 100) {
         return this.buffer.latest(n);
     }

package/dist/src/debug/query_collector.js

@@ -1,3 +1,4 @@
+import { sanitizeBindings } from '../dashboard/sensitive_patterns.js';
 import { isExcludedRequest } from '../middleware/request_tracking_middleware.js';
 import { round } from '../utils/math_helpers.js';
 import { RingBuffer } from './ring_buffer.js';
@@ -14,7 +15,11 @@ function buildQueryRecord(data, id) {
     return {
         id,
         sql: data.sql || '',
-        bindings: data.bindings || [],
+        // Sanitized at capture time so the in-memory debug panel never shows a
+        // credential the persisted dashboard would have redacted. The write path
+        // sanitizes again (idempotently) as defense in depth for records loaded
+        // from an older on-disk dump.
+        bindings: sanitizeBindings(data.bindings || [], data.sql || '') ?? [],
         duration: round(parseDuration(data.duration)),
         method: data.method || 'unknown',
         model: data.model || null,

package/dist/src/debug/trace_collector.js

@@ -7,11 +7,16 @@ import { RingBuffer } from './ring_buffer.js';
  */
 const globalRef = { current: null };
 /**
- * Tracks whether console.warn is currently patched by a TraceCollector, so a
- * second instance (or a skipped stop()) cannot double-wrap it and leak the
- * patch permanently.
+ * Tracks which TraceCollector currently owns the console.warn patch, so a
+ * second instance cannot double-wrap it and leak the patch permanently. The
+ * owner (not a boolean) matters: if a prior instance never ran stop(), its
+ * wrapper checks the *old* AsyncLocalStorage and silently stops attaching
+ * warnings to traces — a newcomer must be able to detect that and take over.
  */
-const consoleWarnPatch = { active: false };
+const consoleWarnPatch = {
+    owner: null,
+    original: null,
+};
 /**
  * Wrap an async function in a traced span.
  *
@@ -157,12 +162,18 @@ export class TraceCollector {
             };
             emitter.on('db:query', this.dbHandler);
         }
-        // Intercept console.warn to capture warnings per-request. Guard against
-        // double-wrapping: if another instance (or a prior start() without a
-        // matching stop()) already patched console.warn, don't wrap it again —
-        // that would capture the patched fn as the "original" and leak the patch.
-        if (!consoleWarnPatch.active) {
-            consoleWarnPatch.active = true;
+        // Intercept console.warn to capture warnings per-request. If a prior
+        // instance still owns the patch (its stop() was skipped), restore its
+        // original first and take over — deferring to the stale owner would leave
+        // a wrapper bound to a dead AsyncLocalStorage, silently detaching
+        // warnings from every trace. Never wrap the wrapper: the restore below
+        // guarantees `console.warn` is the real one before we capture it.
+        if (consoleWarnPatch.owner !== this) {
+            if (consoleWarnPatch.owner && consoleWarnPatch.original) {
+                console.warn = consoleWarnPatch.original;
+            }
+            consoleWarnPatch.owner = this;
+            consoleWarnPatch.original = console.warn;
             this.originalConsoleWarn = console.warn;
             console.warn = (...args) => {
                 const ctx = this.als.getStore();
@@ -178,10 +189,12 @@ export class TraceCollector {
         if (this.emitter && this.dbHandler) {
             this.emitter.off('db:query', this.dbHandler);
         }
-        // Only restore console.warn if this instance was the one that patched it.
-        if (this.originalConsoleWarn) {
+        // Only restore console.warn if this instance still owns the patch — a
+        // newer instance may have taken over, and restoring would clobber it.
+        if (consoleWarnPatch.owner === this && this.originalConsoleWarn) {
             console.warn = this.originalConsoleWarn;
-            consoleWarnPatch.active = false;
+            consoleWarnPatch.owner = null;
+            consoleWarnPatch.original = null;
         }
         this.dbHandler = null;
         this.emitter = null;