adonisjs-server-stats 1.10.0 → 1.10.3

package/dist/src/debug/debug_store.js

@@ -6,6 +6,37 @@ import { EventCollector } from './event_collector.js';
 import { QueryCollector } from './query_collector.js';
 import { RouteInspector } from './route_inspector.js';
 import { TraceCollector } from './trace_collector.js';
+/** Read and parse persisted debug data from disk. Returns null on failure. */
+async function readPersistedData(filePath) {
+    let raw;
+    try {
+        raw = await readFile(filePath, 'utf-8');
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT') {
+            log.warn(`Failed to read persisted debug data from ${bold(filePath)}: ${error?.message}`);
+        }
+        return null;
+    }
+    try {
+        const data = JSON.parse(raw);
+        if (typeof data !== 'object' || data === null)
+            return null;
+        return data;
+    }
+    catch {
+        log.warn(`Persisted debug data corrupted, resetting: ${bold(filePath)}`);
+        return null;
+    }
+}
+/** Load an array from the record into a collector if present and non-empty. */
+function loadIfPresent(record, key, loader) {
+    if (!loader)
+        return;
+    if (Array.isArray(record[key]) && record[key].length > 0) {
+        loader.loadRecords(record[key]);
+    }
+}
 /**
  * Singleton store holding all debug data collectors.
  * Bound to the AdonisJS container as `debug.store`.
@@ -88,38 +119,12 @@ export class DebugStore {
     }
     /** Restore collector data from a JSON file on disk. */
     async loadFromDisk(filePath) {
-        let raw;
-        try {
-            raw = await readFile(filePath, 'utf-8');
-        }
-        catch (error) {
-            if (error?.code !== 'ENOENT') {
-                log.warn(`Failed to read persisted debug data from ${bold(filePath)}: ${error?.message}`);
-            }
+        const record = await readPersistedData(filePath);
+        if (!record)
             return;
-        }
-        let data;
-        try {
-            data = JSON.parse(raw);
-        }
-        catch {
-            log.warn(`Persisted debug data corrupted, resetting: ${bold(filePath)}`);
-            return;
-        }
-        if (typeof data !== 'object' || data === null)
-            return;
-        const record = data;
-        if (Array.isArray(record.queries) && record.queries.length > 0) {
-            this.queries.loadRecords(record.queries);
-        }
-        if (Array.isArray(record.events) && record.events.length > 0) {
-            this.events.loadRecords(record.events);
-        }
-        if (Array.isArray(record.emails) && record.emails.length > 0) {
-            this.emails.loadRecords(record.emails);
-        }
-        if (this.traces && Array.isArray(record.traces) && record.traces.length > 0) {
-            this.traces.loadRecords(record.traces);
-        }
+        loadIfPresent(record, 'queries', this.queries);
+        loadIfPresent(record, 'events', this.events);
+        loadIfPresent(record, 'emails', this.emails);
+        loadIfPresent(record, 'traces', this.traces);
     }
 }

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

@@ -1,16 +1,9 @@
 import type { EmailRecord, Emitter } from './types.js';
 /**
  * Listens to AdonisJS mail events and stores captured emails in a ring buffer.
- *
- * Events:
- * - `mail:sending` — email about to be sent
- * - `mail:sent` — email successfully sent (updates matching 'sending' record)
- * - `mail:queueing` — email about to be queued (sendLater)
- * - `mail:queued` — email successfully queued (updates matching 'queueing' record)
- * - `queued:mail:error` — queued email failed
  */
 export declare class EmailCollector {
-    private static readonly MAX_HTML_SIZE;
+    #private;
     private buffer;
     private emitter;
     private handlers;
@@ -26,8 +19,6 @@ export declare class EmailCollector {
         max: number;
     };
     clear(): void;
-    private buildRecord;
-    private capSize;
     /**
      * Push an externally-created email record into the buffer.
      *

package/dist/src/debug/email_collector.js

@@ -1,17 +1,52 @@
 import { extractAddresses } from '../utils/mail_helpers.js';
 import { RingBuffer } from './ring_buffer.js';
+const MAX_HTML_SIZE = 50_000;
+/** Extract the message object from the event data. */
+function extractMessage(data) {
+    return data?.message || data;
+}
+/** Extract message ID from event data. */
+function extractMessageId(data) {
+    return data?.response?.messageId || data?.messageId || null;
+}
+/** Truncate large HTML/text bodies to prevent memory bloat. */
+function capSize(value) {
+    if (!value)
+        return null;
+    if (value.length <= MAX_HTML_SIZE)
+        return value;
+    return value.slice(0, MAX_HTML_SIZE) + '\n<!-- truncated -->';
+}
+/** Resolve an address field to a string, defaulting when empty. */
+function resolveAddress(field, fallback) {
+    return extractAddresses(field) || fallback;
+}
+/** Resolve the mailer name from event data. */
+function resolveMailer(data) {
+    return data?.mailerName || data?.mailer || 'unknown';
+}
+/** Count attachments safely. */
+function countAttachments(msg) {
+    return Array.isArray(msg?.attachments) ? msg.attachments.length : 0;
+}
+/** Build the core fields of an email record from a mail message. */
+function buildRecordFields(msg, data) {
+    return {
+        from: resolveAddress(msg?.from, 'unknown'),
+        to: resolveAddress(msg?.to, 'unknown'),
+        cc: resolveAddress(msg?.cc, null),
+        bcc: resolveAddress(msg?.bcc, null),
+        subject: msg?.subject || '(no subject)',
+        html: capSize(msg?.html),
+        text: capSize(msg?.text),
+        mailer: resolveMailer(data),
+        attachmentCount: countAttachments(msg),
+    };
+}
 /**
  * Listens to AdonisJS mail events and stores captured emails in a ring buffer.
- *
- * Events:
- * - `mail:sending` — email about to be sent
- * - `mail:sent` — email successfully sent (updates matching 'sending' record)
- * - `mail:queueing` — email about to be queued (sendLater)
- * - `mail:queued` — email successfully queued (updates matching 'queueing' record)
- * - `queued:mail:error` — queued email failed
  */
 export class EmailCollector {
-    static MAX_HTML_SIZE = 50_000; // 50 KB cap per email body
     buffer;
     emitter = null;
     handlers = [];
@@ -22,61 +57,47 @@ export class EmailCollector {
         if (!emitter || typeof emitter.on !== 'function')
             return;
         this.emitter = emitter;
-        const onSending = (data) => {
-            const msg = data?.message || data;
-            const record = this.buildRecord(msg, 'sending', data);
-            this.buffer.push(record);
-        };
-        const onSent = (data) => {
-            const msg = data?.message || data;
-            const to = extractAddresses(msg?.to);
-            const subject = msg?.subject || '';
-            // Try to find the matching 'sending' record and update it (no buffer copy)
-            const match = this.buffer.findFromEnd((rec) => rec.status === 'sending' && rec.to === to && rec.subject === subject);
-            if (match) {
-                match.status = 'sent';
-                match.messageId = data?.response?.messageId || data?.messageId || null;
-                return;
-            }
-            // No matching 'sending' record — insert a new 'sent' record
-            const record = this.buildRecord(msg, 'sent', data);
-            record.messageId = data?.response?.messageId || data?.messageId || null;
-            this.buffer.push(record);
-        };
-        const onQueueing = (data) => {
-            const msg = data?.message || data;
-            const record = this.buildRecord(msg, 'queueing', data);
-            this.buffer.push(record);
-        };
-        const onQueued = (data) => {
-            const msg = data?.message || data;
-            const to = extractAddresses(msg?.to);
-            const subject = msg?.subject || '';
-            // Try to find the matching 'queueing' record and update it
-            const match = this.buffer.findFromEnd((rec) => rec.status === 'queueing' && rec.to === to && rec.subject === subject);
-            if (match) {
-                match.status = 'queued';
-                return;
-            }
-            const record = this.buildRecord(msg, 'queued', data);
-            this.buffer.push(record);
-        };
-        const onQueuedError = (data) => {
-            const msg = data?.message || data;
-            const record = this.buildRecord(msg, 'failed', data);
-            this.buffer.push(record);
-        };
         this.handlers = [
-            { event: 'mail:sending', fn: onSending },
-            { event: 'mail:sent', fn: onSent },
-            { event: 'mail:queueing', fn: onQueueing },
-            { event: 'mail:queued', fn: onQueued },
-            { event: 'queued:mail:error', fn: onQueuedError },
+            { event: 'mail:sending', fn: (data) => this.#onSimpleEvent(data, 'sending') },
+            { event: 'mail:sent', fn: (data) => this.#onTransitionEvent(data, 'sending', 'sent') },
+            { event: 'mail:queueing', fn: (data) => this.#onSimpleEvent(data, 'queueing') },
+            { event: 'mail:queued', fn: (data) => this.#onTransitionEvent(data, 'queueing', 'queued') },
+            { event: 'queued:mail:error', fn: (data) => this.#onSimpleEvent(data, 'failed') },
         ];
         for (const h of this.handlers) {
             emitter.on(h.event, h.fn);
         }
     }
+    /** Handle events that simply push a new record. */
+    #onSimpleEvent(data, status) {
+        const msg = extractMessage(data);
+        const record = this.#buildRecord(msg, status, data);
+        this.buffer.push(record);
+    }
+    /** Handle events that update an existing record or create a new one. */
+    #onTransitionEvent(data, fromStatus, toStatus) {
+        const msg = extractMessage(data);
+        const to = extractAddresses(msg?.to);
+        const subject = msg?.subject || '';
+        const match = this.buffer.findFromEnd((rec) => rec.status === fromStatus && rec.to === to && rec.subject === subject);
+        if (match) {
+            match.status = toStatus;
+            match.messageId = extractMessageId(data);
+            return;
+        }
+        const record = this.#buildRecord(msg, toStatus, data);
+        record.messageId = extractMessageId(data);
+        this.buffer.push(record);
+    }
+    #buildRecord(msg, status, data) {
+        return {
+            id: this.buffer.getNextId(),
+            ...buildRecordFields(msg, data),
+            status,
+            messageId: null,
+            timestamp: Date.now(),
+        };
+    }
     stop() {
         if (this.emitter && typeof this.emitter.off === 'function') {
             for (const h of this.handlers) {
@@ -105,30 +126,6 @@ export class EmailCollector {
     clear() {
         this.buffer.clear();
     }
-    buildRecord(msg, status, data) {
-        return {
-            id: this.buffer.getNextId(),
-            from: extractAddresses(msg?.from) || 'unknown',
-            to: extractAddresses(msg?.to) || 'unknown',
-            cc: extractAddresses(msg?.cc) || null,
-            bcc: extractAddresses(msg?.bcc) || null,
-            subject: msg?.subject || '(no subject)',
-            html: this.capSize(msg?.html),
-            text: this.capSize(msg?.text),
-            mailer: data?.mailerName || data?.mailer || 'unknown',
-            status,
-            messageId: null,
-            attachmentCount: Array.isArray(msg?.attachments) ? msg.attachments.length : 0,
-            timestamp: Date.now(),
-        };
-    }
-    capSize(value) {
-        if (!value)
-            return null;
-        if (value.length <= EmailCollector.MAX_HTML_SIZE)
-            return value;
-        return value.slice(0, EmailCollector.MAX_HTML_SIZE) + '\n<!-- truncated -->';
-    }
     /**
      * Push an externally-created email record into the buffer.
      *

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

@@ -1,7 +1,6 @@
 import type { EventRecord, Emitter } from './types.js';
 /**
  * Wraps the AdonisJS emitter to log all events with timestamps.
- * Uses monkey-patching of emitter.emit to intercept all events.
  */
 export declare class EventCollector {
     private buffer;
@@ -10,14 +9,8 @@ export declare class EventCollector {
     constructor(maxEvents?: number);
     start(emitter: Emitter): void;
     stop(): void;
-    /** Reusable WeakSet to avoid GC churn on every event. */
     private circulars;
     private summarizeData;
-    /**
-     * Recursively limit object depth to prevent deeply-nested payloads
-     * from causing expensive serialization.
-     */
-    private limitDepth;
     getEvents(): EventRecord[];
     getLatest(n?: number): EventRecord[];
     getTotalCount(): number;
@@ -26,8 +19,6 @@ export declare class EventCollector {
         max: number;
     };
     clear(): void;
-    /** Register a callback that fires whenever a new event is recorded. */
     onNewItem(cb: ((item: EventRecord) => void) | null): void;
-    /** Restore persisted records into the buffer and reset the ID counter. */
     loadRecords(records: EventRecord[]): void;
 }

package/dist/src/debug/event_collector.js

@@ -1,8 +1,81 @@
 import { isExcludedRequest } from '../middleware/request_tracking_middleware.js';
 import { RingBuffer } from './ring_buffer.js';
+/** Events to skip (handled by other collectors or noisy). */
+const SKIPPED_EVENTS = new Set([
+    'db:query',
+    'mail:sending',
+    'mail:sent',
+    'mail:queueing',
+    'mail:queued',
+    'queued:mail:error',
+    'http:request_completed',
+]);
+/** Check if an event should be recorded. */
+function shouldRecord(eventName) {
+    if (eventName.startsWith('__'))
+        return false;
+    if (SKIPPED_EVENTS.has(eventName))
+        return false;
+    if (isExcludedRequest())
+        return false;
+    return true;
+}
+/** Truncate a string to a max length. */
+function truncateString(s, maxLen) {
+    return s.length > maxLen ? s.slice(0, maxLen) + '...' : s;
+}
+/** Fallback stringification when JSON.stringify fails. */
+function fallbackStringify(data) {
+    if (typeof data === 'object' && data !== null) {
+        const ctorName = data.constructor?.name;
+        if (ctorName)
+            return `[${ctorName}]`;
+    }
+    return typeof data;
+}
+/** Limit depth of an array value. */
+function limitDepthArray(value, maxDepth, seen) {
+    const take = Math.min(value.length, 20);
+    const arr = Array.from({ length: take });
+    for (let i = 0; i < take; i++) {
+        arr[i] = limitDepth(value[i], maxDepth - 1, seen);
+    }
+    return arr;
+}
+/** Limit depth of an object value. */
+function limitDepthObject(value, maxDepth, seen) {
+    const keys = Object.keys(value);
+    const result = {};
+    const limit = Math.min(keys.length, 50);
+    for (let i = 0; i < limit; i++) {
+        result[keys[i]] = limitDepth(value[keys[i]], maxDepth - 1, seen);
+    }
+    if (keys.length > 50) {
+        result['...'] = `(${keys.length - 50} more keys)`;
+    }
+    return result;
+}
+/** Recursively limit object depth to prevent expensive serialization. */
+function limitDepth(value, maxDepth, seen) {
+    if (maxDepth <= 0)
+        return '[...]';
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === 'function')
+        return `[Function: ${value.name || 'anonymous'}]`;
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (typeof value !== 'object')
+        return value;
+    if (seen.has(value))
+        return '[Circular]';
+    seen.add(value);
+    if (Array.isArray(value))
+        return limitDepthArray(value, maxDepth, seen);
+    return limitDepthObject(value, maxDepth, seen);
+}
 /**
  * Wraps the AdonisJS emitter to log all events with timestamps.
- * Uses monkey-patching of emitter.emit to intercept all events.
  */
 export class EventCollector {
     buffer;
@@ -17,17 +90,8 @@ export class EventCollector {
         this.emitter = emitter;
         this.originalEmit = emitter.emit.bind(emitter);
         emitter.emit = (event, data) => {
-            // Resolve event name: class-based events use the class name, string events are used as-is
             const eventName = typeof event === 'string' ? event : event?.name || 'unknown';
-            // Skip internal/noisy events, mail events (handled by EmailCollector),
-            // HTTP lifecycle events (redundant with timeline), and events triggered
-            // by debug panel polling requests
-            if (!eventName.startsWith('__') &&
-                eventName !== 'db:query' &&
-                !eventName.startsWith('mail:') &&
-                eventName !== 'queued:mail:error' &&
-                eventName !== 'http:request_completed' &&
-                !isExcludedRequest()) {
+            if (shouldRecord(eventName)) {
                 const record = {
                     id: this.buffer.getNextId(),
                     event: eventName,
@@ -46,68 +110,23 @@ export class EventCollector {
         this.originalEmit = null;
         this.emitter = null;
     }
-    /** Reusable WeakSet to avoid GC churn on every event. */
     circulars = new WeakSet();
     summarizeData(data) {
         if (data === undefined || data === null)
             return null;
         try {
             if (typeof data === 'string')
-                return data.length > 4096 ? data.slice(0, 4096) + '...' : data;
+                return truncateString(data, 4096);
             if (typeof data !== 'object')
                 return String(data);
-            // Reuse the WeakSet across calls to avoid per-event allocation
             this.circulars = new WeakSet();
-            const limited = this.limitDepth(data, 3, this.circulars);
-            // Compact JSON (no indent) to reduce string size and serialization time
+            const limited = limitDepth(data, 3, this.circulars);
             const result = JSON.stringify(limited) ?? '';
-            return result.length > 4096 ? result.slice(0, 4096) + '...' : result;
+            return truncateString(result, 4096);
         }
         catch {
-            if (typeof data === 'object' && data !== null) {
-                const ctorName = data.constructor?.name;
-                if (ctorName)
-                    return `[${ctorName}]`;
-            }
-            return typeof data;
-        }
-    }
-    /**
-     * Recursively limit object depth to prevent deeply-nested payloads
-     * from causing expensive serialization.
-     */
-    limitDepth(value, maxDepth, seen) {
-        if (maxDepth <= 0)
-            return '[...]';
-        if (value === null || value === undefined)
-            return value;
-        if (typeof value === 'function')
-            return `[Function: ${value.name || 'anonymous'}]`;
-        if (typeof value === 'bigint')
-            return value.toString();
-        if (typeof value !== 'object')
-            return value;
-        if (seen.has(value))
-            return '[Circular]';
-        seen.add(value);
-        if (Array.isArray(value)) {
-            const take = Math.min(value.length, 20);
-            const arr = Array.from({ length: take });
-            for (let i = 0; i < take; i++) {
-                arr[i] = this.limitDepth(value[i], maxDepth - 1, seen);
-            }
-            return arr;
-        }
-        const keys = Object.keys(value);
-        const result = {};
-        const limit = Math.min(keys.length, 50);
-        for (let i = 0; i < limit; i++) {
-            result[keys[i]] = this.limitDepth(value[keys[i]], maxDepth - 1, seen);
-        }
-        if (keys.length > 50) {
-            result['...'] = `(${keys.length - 50} more keys)`;
+            return fallbackStringify(data);
         }
-        return result;
     }
     getEvents() {
         return this.buffer.toArray().reverse();
@@ -124,11 +143,9 @@ export class EventCollector {
     clear() {
         this.buffer.clear();
     }
-    /** Register a callback that fires whenever a new event is recorded. */
     onNewItem(cb) {
         this.buffer.onPush(cb);
     }
-    /** Restore persisted records into the buffer and reset the ID counter. */
     loadRecords(records) {
         this.buffer.load(records);
         const maxId = records.reduce((m, r) => Math.max(m, r.id), 0);

package/dist/src/debug/query_collector.js

@@ -1,6 +1,28 @@
 import { isExcludedRequest } from '../middleware/request_tracking_middleware.js';
 import { round } from '../utils/math_helpers.js';
 import { RingBuffer } from './ring_buffer.js';
+/** Parse duration from DbQueryEvent (may be number, hrtime tuple, or absent). */
+function parseDuration(duration) {
+    if (typeof duration === 'number')
+        return duration;
+    if (Array.isArray(duration))
+        return duration[0] * 1e3 + duration[1] / 1e6;
+    return 0;
+}
+/** Build a QueryRecord from a db:query event. */
+function buildQueryRecord(data, id) {
+    return {
+        id,
+        sql: data.sql || '',
+        bindings: data.bindings || [],
+        duration: round(parseDuration(data.duration)),
+        method: data.method || 'unknown',
+        model: data.model || null,
+        connection: data.connection || 'default',
+        inTransaction: data.inTransaction || false,
+        timestamp: Date.now(),
+    };
+}
 /**
  * Listens to Lucid's `db:query` event and stores queries in a ring buffer.
  *
@@ -21,29 +43,11 @@ export class QueryCollector {
     async start(emitter) {
         this.emitter = emitter;
         this.handler = (data) => {
-            // Self-exclude: skip queries from the dashboard's dedicated SQLite connection
             if (data.connection === 'server_stats')
                 return;
-            // Self-exclude: skip queries triggered by debug panel polling requests
             if (isExcludedRequest())
                 return;
-            const duration = typeof data.duration === 'number'
-                ? data.duration
-                : Array.isArray(data.duration)
-                    ? data.duration[0] * 1e3 + data.duration[1] / 1e6
-                    : 0;
-            const record = {
-                id: this.buffer.getNextId(),
-                sql: data.sql || '',
-                bindings: data.bindings || [],
-                duration: round(duration),
-                method: data.method || 'unknown',
-                model: data.model || null,
-                connection: data.connection || 'default',
-                inTransaction: data.inTransaction || false,
-                timestamp: Date.now(),
-            };
-            this.buffer.push(record);
+            this.buffer.push(buildQueryRecord(data, this.buffer.getNextId()));
         };
         if (emitter && typeof emitter.on === 'function') {
             emitter.on('db:query', this.handler);

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

@@ -1,14 +1,10 @@
 import type { RouteRecord, Router } from './types.js';
 /**
  * Reads the router's route table at boot time and caches it.
- * Static data computed once — routes don't change after boot.
  */
 export declare class RouteInspector {
+    #private;
     private routes;
-    /**
-     * Inspect the router and cache all routes.
-     * Call this in the provider's `ready()` hook.
-     */
     inspect(router: Router): void;
     private resolveHandler;
     private resolveMiddleware;