adonisjs-server-stats 1.10.0 → 1.10.3

package/dist/src/dashboard/saved_filter_queries.js

@@ -0,0 +1,24 @@
+/**
+ * Saved filter CRUD operations for the DashboardStore.
+ *
+ * Extracted from DashboardStore to reduce file length.
+ */
+export function fetchSavedFilters(db, cache, section) {
+    return cache.coalesce('savedFilters:' + (section || ''), async () => {
+        const q = db('server_stats_saved_filters').orderBy('created_at', 'desc');
+        if (section)
+            q.where('section', section);
+        return q;
+    });
+}
+export async function insertSavedFilter(db, name, section, filterConfig) {
+    const [id] = await db('server_stats_saved_filters').insert({
+        name,
+        section,
+        filter_config: JSON.stringify(filterConfig),
+    });
+    return { id, name, section, filterConfig };
+}
+export async function removeSavedFilter(db, id) {
+    return (await db('server_stats_saved_filters').where('id', id).delete()) > 0;
+}

package/dist/src/dashboard/storage_stats.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Storage statistics queries for the dashboard diagnostics endpoint.
+ */
+import { CoalesceCache } from './coalesce_cache.js';
+import type { Knex } from 'knex';
+/**
+ * Get the file sizes of the SQLite database and its WAL file.
+ */
+export declare function getFileSizes(dbFilePath: string): Promise<[number, number]>;
+/**
+ * Count rows in all dashboard tables within a single transaction.
+ */
+export declare function countAllTables(db: Knex): Promise<Array<{
+    name: string;
+    rowCount: number;
+}>>;
+export interface StorageStatsResult {
+    ready: boolean;
+    dbPath: string;
+    fileSizeMb: number;
+    walSizeMb: number;
+    retentionDays: number;
+    tables: Array<{
+        name: string;
+        rowCount: number;
+    }>;
+    lastCleanupAt: number | null;
+}
+export interface StorageStatsOpts {
+    db: Knex;
+    cache: CoalesceCache;
+    dbFilePath: string;
+    dbPath: string;
+    retentionDays: number;
+    lastCleanupAt: number | null;
+    onResult: (stats: StorageStatsResult) => void;
+}
+/**
+ * Build storage stats by querying file sizes and table row counts.
+ */
+export declare function fetchStorageStats(opts: StorageStatsOpts): Promise<StorageStatsResult>;

package/dist/src/dashboard/storage_stats.js

@@ -0,0 +1,81 @@
+/**
+ * Storage statistics queries for the dashboard diagnostics endpoint.
+ */
+import { stat as fsStat } from 'node:fs/promises';
+// ---------------------------------------------------------------------------
+// File size helpers
+// ---------------------------------------------------------------------------
+/**
+ * Get the file sizes of the SQLite database and its WAL file.
+ */
+export async function getFileSizes(dbFilePath) {
+    let fileSizeMb = 0;
+    let walSizeMb = 0;
+    try {
+        const s = await fsStat(dbFilePath);
+        fileSizeMb = Math.round((s.size / (1024 * 1024)) * 100) / 100;
+    }
+    catch {
+        // File may not exist yet
+    }
+    try {
+        const ws = await fsStat(dbFilePath + '-wal');
+        walSizeMb = Math.round((ws.size / (1024 * 1024)) * 100) / 100;
+    }
+    catch {
+        // WAL file may not exist
+    }
+    return [fileSizeMb, walSizeMb];
+}
+// ---------------------------------------------------------------------------
+// Table row counts
+// ---------------------------------------------------------------------------
+const TABLE_NAMES = [
+    'server_stats_requests',
+    'server_stats_queries',
+    'server_stats_events',
+    'server_stats_emails',
+    'server_stats_logs',
+    'server_stats_traces',
+    'server_stats_metrics',
+    'server_stats_saved_filters',
+];
+/**
+ * Count rows in all dashboard tables within a single transaction.
+ */
+export async function countAllTables(db) {
+    return db.transaction(async (trx) => {
+        const result = [];
+        for (const name of TABLE_NAMES) {
+            try {
+                const [row] = await trx(name).count('* as count');
+                result.push({ name, rowCount: Number(row.count) });
+            }
+            catch {
+                result.push({ name, rowCount: 0 });
+            }
+        }
+        return result;
+    });
+}
+/**
+ * Build storage stats by querying file sizes and table row counts.
+ */
+export function fetchStorageStats(opts) {
+    const { db, cache, dbFilePath, dbPath, retentionDays, lastCleanupAt, onResult } = opts;
+    return cache.coalesce('storageStats', async () => {
+        const [fileSizeMb, walSizeMb] = await getFileSizes(dbFilePath);
+        const tables = await countAllTables(db);
+        const stats = {
+            ready: true,
+            dbPath,
+            fileSizeMb,
+            walSizeMb,
+            retentionDays,
+            tables,
+            lastCleanupAt,
+        };
+        onResult(stats);
+        return stats;
+    });
+}

package/dist/src/dashboard/write_queue.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Data preparation helpers for the DashboardStore write queue.
+ *
+ * These functions transform in-memory records into SQLite-ready row
+ * objects. They are pure (no I/O, no Knex dependency) so they can
+ * be tested in isolation.
+ */
+import type { EventRecord, EmailRecord } from '../debug/types.js';
+import type { PersistRequestInput } from './dashboard_types.js';
+import type { Knex } from 'knex';
+export declare function hasWarned(path: string): boolean;
+export declare function markWarned(path: string): void;
+/**
+ * Normalize a SQL query by replacing literal values with `?` placeholders.
+ * Used for grouping identical query patterns.
+ */
+export declare function normalizeSql(sql: string): string;
+export interface PreparedQuery {
+    sql_text: string;
+    sql_normalized: string;
+    bindings: string | null;
+    duration: number;
+    method: string;
+    model: string | null;
+    connection: string;
+    in_transaction: number;
+}
+export interface PreparedTraceRow {
+    method: string;
+    url: string;
+    status_code: number;
+    total_duration: number;
+    span_count: number;
+    spans: string;
+    warnings: string | null;
+}
+export interface PreparedRequest {
+    input: PersistRequestInput;
+    filteredQueries: PreparedQuery[];
+    traceRow: PreparedTraceRow | null;
+}
+export interface PreparedLog {
+    [key: string]: unknown;
+    level: string;
+    message: string;
+    request_id: string | null;
+    data: string;
+}
+export interface EmailRow {
+    [key: string]: unknown;
+    from_addr: string;
+    to_addr: string;
+    cc: string | null;
+    bcc: string | null;
+    subject: string;
+    html: string | null;
+    text_body: string | null;
+    mailer: string;
+    status: string;
+    message_id: string | null;
+    attachment_count: number;
+}
+export interface EventRow {
+    [key: string]: unknown;
+    request_id: null;
+    event_name: string;
+    data: string | null;
+}
+/**
+ * Pre-stringify and transform request inputs into SQLite-ready row objects.
+ * This is done OUTSIDE the transaction so the synchronous better-sqlite3
+ * execution does not block the event loop on large spans.
+ */
+export declare function prepareRequestRows(requests: PersistRequestInput[]): PreparedRequest[];
+/**
+ * Transform raw log entries into SQLite-ready row objects.
+ */
+export declare function prepareLogRows(logs: Record<string, unknown>[]): PreparedLog[];
+/**
+ * Transform an EmailRecord into a SQLite-ready row object.
+ */
+export declare function buildEmailRow(record: EmailRecord): EmailRow;
+/**
+ * Transform EventRecords into SQLite-ready row objects.
+ */
+export declare function buildEventRows(events: EventRecord[]): EventRow[];
+/**
+ * Insert rows into a table in batches of 50.
+ */
+export declare function batchInsert(trx: Knex.Transaction, table: string, rows: Record<string, unknown>[]): Promise<void>;
+export declare function flushRequests(trx: Knex.Transaction, preparedRequests: PreparedRequest[]): Promise<void>;
+/**
+ * Flush pending events into the database.
+ */
+export declare function flushEvents(trx: Knex.Transaction, events: {
+    requestIndex: number;
+    events: EventRecord[];
+}[]): Promise<void>;
+/**
+ * Flush pending emails into the database.
+ */
+export declare function flushEmails(trx: Knex.Transaction, emails: EmailRecord[]): Promise<void>;
+/**
+ * Flush prepared logs into the database.
+ */
+export declare function flushLogs(trx: Knex.Transaction, preparedLogs: PreparedLog[]): Promise<void>;

package/dist/src/dashboard/write_queue.js

@@ -0,0 +1,225 @@
+/**
+ * Data preparation helpers for the DashboardStore write queue.
+ *
+ * These functions transform in-memory records into SQLite-ready row
+ * objects. They are pure (no I/O, no Knex dependency) so they can
+ * be tested in isolation.
+ */
+import { round } from '../utils/math_helpers.js';
+// ---------------------------------------------------------------------------
+// Warn-once tracking for write-path catch blocks
+// ---------------------------------------------------------------------------
+const warnedWritePaths = new Set();
+export function hasWarned(path) {
+    return warnedWritePaths.has(path);
+}
+export function markWarned(path) {
+    warnedWritePaths.add(path);
+}
+// ---------------------------------------------------------------------------
+// SQL normalization
+// ---------------------------------------------------------------------------
+/**
+ * Normalize a SQL query by replacing literal values with `?` placeholders.
+ * Used for grouping identical query patterns.
+ */
+export function normalizeSql(sql) {
+    return sql
+        .replace(/'[^']*'/g, '?')
+        .replace(/\b\d+(\.\d+)?\b/g, '?')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+// ---------------------------------------------------------------------------
+// Pure data-prep functions
+// ---------------------------------------------------------------------------
+/**
+ * Pre-stringify and transform request inputs into SQLite-ready row objects.
+ * This is done OUTSIDE the transaction so the synchronous better-sqlite3
+ * execution does not block the event loop on large spans.
+ */
+export function prepareRequestRows(requests) {
+    return requests.map((input) => ({
+        input,
+        filteredQueries: input.queries
+            .filter((q) => q.connection !== 'server_stats')
+            .map((q) => ({
+            sql_text: q.sql,
+            sql_normalized: normalizeSql(q.sql),
+            bindings: q.bindings ? JSON.stringify(q.bindings) : null,
+            duration: round(q.duration),
+            method: q.method,
+            model: q.model,
+            connection: q.connection,
+            in_transaction: q.inTransaction ? 1 : 0,
+        })),
+        traceRow: input.trace
+            ? {
+                method: input.trace.method,
+                url: input.trace.url,
+                status_code: input.trace.statusCode,
+                total_duration: round(input.trace.totalDuration),
+                span_count: input.trace.spanCount,
+                spans: JSON.stringify(input.trace.spans),
+                warnings: input.trace.warnings.length > 0 ? JSON.stringify(input.trace.warnings) : null,
+            }
+            : null,
+    }));
+}
+/**
+ * Transform raw log entries into SQLite-ready row objects.
+ */
+export function prepareLogRows(logs) {
+    return logs.map((entry) => {
+        const levelName = typeof entry.levelName === 'string' ? entry.levelName : String(entry.level || 'unknown');
+        return {
+            level: levelName,
+            message: String(entry.msg || entry.message || ''),
+            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),
+        };
+    });
+}
+/**
+ * Transform an EmailRecord into a SQLite-ready row object.
+ */
+export function buildEmailRow(record) {
+    return {
+        from_addr: record.from,
+        to_addr: record.to,
+        cc: record.cc,
+        bcc: record.bcc,
+        subject: record.subject,
+        html: record.html,
+        text_body: record.text,
+        mailer: record.mailer,
+        status: record.status,
+        message_id: record.messageId,
+        attachment_count: record.attachmentCount,
+    };
+}
+/**
+ * Transform EventRecords into SQLite-ready row objects.
+ */
+export function buildEventRows(events) {
+    return events.map((e) => ({
+        request_id: null,
+        event_name: e.event,
+        data: e.data,
+    }));
+}
+// ---------------------------------------------------------------------------
+// Batch insert helper
+// ---------------------------------------------------------------------------
+/**
+ * Insert rows into a table in batches of 50.
+ */
+export async function batchInsert(trx, table, rows) {
+    for (let i = 0; i < rows.length; i += 50) {
+        await trx(table).insert(rows.slice(i, i + 50));
+    }
+}
+// ---------------------------------------------------------------------------
+// Transaction sub-routines for flushWriteQueue
+// ---------------------------------------------------------------------------
+/**
+ * Flush prepared requests (with queries + traces) into the database.
+ */
+/** Build the request row object for insertion. */
+function buildRequestRow(input) {
+    const row = {
+        method: input.method,
+        url: input.url,
+        status_code: input.statusCode,
+        duration: round(input.duration),
+        span_count: input.trace?.spanCount ?? 0,
+        warning_count: input.trace?.warnings?.length ?? 0,
+    };
+    if (input.httpRequestId) {
+        row.http_request_id = String(input.httpRequestId);
+    }
+    return row;
+}
+/** Insert a single prepared request with its queries and trace. */
+async function insertOneRequest(trx, prepared) {
+    const { input, filteredQueries, traceRow } = prepared;
+    const row = buildRequestRow(input);
+    const [requestId] = await trx('server_stats_requests').insert(row);
+    const hasId = requestId !== null && requestId !== undefined;
+    if (hasId && filteredQueries.length > 0) {
+        const rows = filteredQueries.map((q) => ({ ...q, request_id: requestId }));
+        await batchInsert(trx, 'server_stats_queries', rows);
+    }
+    if (hasId && traceRow) {
+        await trx('server_stats_traces').insert({ ...traceRow, request_id: requestId });
+    }
+}
+export async function flushRequests(trx, preparedRequests) {
+    for (const prepared of preparedRequests) {
+        try {
+            await insertOneRequest(trx, prepared);
+        }
+        catch (err) {
+            if (!hasWarned('persistRequest')) {
+                markWarned('persistRequest');
+                const { log } = await import('../utils/logger.js');
+                log.warn(`dashboard: persistRequest failed — ${err?.message}`);
+            }
+        }
+    }
+}
+/**
+ * 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.
+ */
+export async function flushEmails(trx, emails) {
+    if (emails.length === 0)
+        return;
+    try {
+        const rows = emails.map((record) => buildEmailRow(record));
+        await batchInsert(trx, 'server_stats_emails', rows);
+    }
+    catch (err) {
+        if (!hasWarned('recordEmail')) {
+            markWarned('recordEmail');
+            const { log } = await import('../utils/logger.js');
+            log.warn(`dashboard: recordEmail failed — ${err?.message}`);
+        }
+    }
+}
+/**
+ * Flush prepared logs into the database.
+ */
+export async function flushLogs(trx, preparedLogs) {
+    if (preparedLogs.length === 0)
+        return;
+    try {
+        await batchInsert(trx, 'server_stats_logs', preparedLogs);
+    }
+    catch (err) {
+        if (!hasWarned('recordLog')) {
+            markWarned('recordLog');
+            const { log } = await import('../utils/logger.js');
+            log.warn(`dashboard: recordLog failed — ${err?.message}`);
+        }
+    }
+}

package/dist/src/data/data_access.d.ts

@@ -1,32 +1,5 @@
-import type { DashboardStore } from '../dashboard/dashboard_store.js';
-import type { DebugStore } from '../debug/debug_store.js';
-import type { QueryRecord, EventRecord, TraceRecord, RouteRecord } from '../debug/types.js';
-export interface ListOptions {
-    page?: number;
-    perPage?: number;
-    search?: string;
-    sort?: string;
-    sortDir?: 'asc' | 'desc';
-    filters?: Record<string, unknown>;
-    /**
-     * Force the data source for this read.
-     *
-     * - `'memory'` — always read from ring buffers ({@link DebugStore}).
-     *   Use this for the debug panel, which expects camelCase field names
-     *   matching the {@link QueryRecord}/{@link EventRecord}/etc. interfaces.
-     * - `'auto'` (default) — use SQLite when available, fall back to memory.
-     */
-    source?: 'memory' | 'auto';
-}
-export interface PaginatedResult<T = Record<string, unknown>> {
-    data: T[];
-    meta: {
-        total: number;
-        page: number;
-        perPage: number;
-        lastPage: number;
-    };
-}
+import type { ListOptions, PaginatedResult, DashboardStore, DebugStore, QueryRecord, EventRecord, TraceRecord, RouteRecord } from './data_access_helpers.js';
+export type { ListOptions, PaginatedResult };
 /**
  * Thin abstraction layer that delegates reads to either the
  * {@link DashboardStore} (SQLite persistence) or the {@link DebugStore}
@@ -81,9 +54,6 @@ export declare class DataAccess {
     getTraceDetail(id: number, source?: 'memory' | 'auto'): Promise<TraceRecord | null>;
     /**
      * Find log entries matching a specific request ID.
-     *
-     * Checks SQLite first (if available), then falls back to scanning
-     * the log file for entries with a matching `request_id` field.
      */
     private getRelatedLogsByRequestId;
     /**
@@ -101,11 +71,4 @@ export declare class DataAccess {
      * 256 KB of the application log file from the filesystem.
      */
     getLogs(opts?: ListOptions): Promise<PaginatedResult>;
-    /**
-     * Read and parse the last 256 KB of the application log file.
-     *
-     * Returns an array of enriched log entry objects. If the log file
-     * does not exist or cannot be read, returns an empty array.
-     */
-    private readLogFile;
 }