adonisjs-server-stats 1.17.0 → 1.18.0

package/dist/react/{TimelineTab-LHQHHKkO.js → TimelineTab-_byxh2mJ.js}

@@ -2,11 +2,11 @@ import { jsx as e, jsxs as t } from "react/jsx-runtime";
 import { useState as i, useMemo as q, useEffect as I, useCallback as O } from "react";
 import { formatDuration as m, durationClassName as j } from "adonisjs-server-stats/core";
 import { u as U } from "./useApiClient-CtEG7rHs.js";
-import { u as W, M as D, S as L } from "./index-LlFvooUN.js";
+import { u as W, M as D, S as L } from "./index-De7nsWBN.js";
 import { T as _ } from "./TimeAgoCell-o3KigGfM.js";
 import { u as z } from "./useResizableTable-CNJmACdt.js";
 import { F as G } from "./FilterBar-CQ7bD669.js";
-import { S as K, R as V } from "./SplitPaneWrapper-DQvJnsuk.js";
+import { S as K, R as V } from "./SplitPaneWrapper-BZ6VrBr-.js";
 const S = {
   request: "#1e3a5f",
   middleware: "rgba(30, 58, 95, 0.7)",

package/dist/react/{index-LlFvooUN.js → index-De7nsWBN.js}

@@ -437,7 +437,7 @@ function K({
     }
   );
 }
-const we = T(() => import("./QueriesTab-smQQJvJa.js")), ke = T(() => import("./EventsTab-DgS2v1HX.js")), ye = T(() => import("./EmailsTab-CkHOhj2F.js")), Ne = T(() => import("./RoutesTab-CpXNO-Rx.js")), Ce = T(() => import("./LogsTab-ixusY4v7.js")), Se = T(() => import("./TimelineTab-LHQHHKkO.js")), Le = T(() => import("./CacheTab-D55mfmeE.js")), Te = T(() => import("./JobsTab-zdxX_as-.js")), Ee = T(() => import("./ConfigTab-CNnsOXBh.js")), $e = T(() => import("./InternalsTab-BygoSorC.js")), xe = T(() => import("./CustomPaneTab-D-267UVd.js"));
+const we = T(() => import("./QueriesTab-DJY7aavR.js")), ke = T(() => import("./EventsTab-CgSdHbKU.js")), ye = T(() => import("./EmailsTab-BWwq-CxB.js")), Ne = T(() => import("./RoutesTab-Ch3PDLzo.js")), Ce = T(() => import("./LogsTab-BtD1h7DM.js")), Se = T(() => import("./TimelineTab-_byxh2mJ.js")), Le = T(() => import("./CacheTab-BN0QgPXz.js")), Te = T(() => import("./JobsTab-CzwLSRUC.js")), Ee = T(() => import("./ConfigTab-au26s-ON.js")), $e = T(() => import("./InternalsTab-CoVLHQbF.js")), xe = T(() => import("./CustomPaneTab-qvMnh8ss.js"));
 function ss(e) {
   const {
     defaultOpen: r = !1,
@@ -756,7 +756,7 @@ const je = X(void 0), Pe = [
   "jobs",
   "config",
   "internals"
-], He = T(() => import("./OverviewSection-CvhObTLP.js")), Ue = T(() => import("./RequestsSection-DKuYpViv.js")), qe = T(() => import("./QueriesSection-BvledwBI.js")), Fe = T(() => import("./EventsSection-CMeyjzVC.js")), ze = T(() => import("./RoutesSection-5RNVurQ6.js")), Ae = T(() => import("./LogsSection-XmiI2MMs.js")), We = T(() => import("./EmailsSection-Bqw4DI4r.js")), Ke = T(() => import("./CacheSection-C-X2Tnca.js")), Ve = T(() => import("./JobsSection-oWH6pbrG.js")), Je = T(() => import("./ConfigSection-C-HGnZfd.js")), Ge = T(() => import("./InternalsSection-lOv_UcSV.js"));
+], He = T(() => import("./OverviewSection-B28em0gQ.js")), Ue = T(() => import("./RequestsSection-DPmYM7tq.js")), qe = T(() => import("./QueriesSection-B0tFn_Dc.js")), Fe = T(() => import("./EventsSection-CA9b15dJ.js")), ze = T(() => import("./RoutesSection-Ck-RcFVS.js")), Ae = T(() => import("./LogsSection-BujNn_cO.js")), We = T(() => import("./EmailsSection-HfEMeRex.js")), Ke = T(() => import("./CacheSection-B-lSIN8Q.js")), Ve = T(() => import("./JobsSection-DgsS_VwU.js")), Je = T(() => import("./ConfigSection-u_TSfb9f.js")), Ge = T(() => import("./InternalsSection-IEeWXJqP.js"));
 function ts(e) {
   const {
     baseUrl: r = "",

package/dist/react/index.js

@@ -1,4 +1,4 @@
-import { B as s, D as t, c as r, J as u, M as g, d as o, d, S as D, T as S, e as h, a as B, u as T, f as b, g as l, h as m } from "./index-LlFvooUN.js";
+import { B as s, D as t, c as r, J as u, M as g, d as o, d, S as D, T as S, e as h, a as B, u as T, f as b, g as l, h as m } from "./index-De7nsWBN.js";
 export {
   s as Badge,
   t as DashboardPage,

package/dist/src/dashboard/dashboard_store.js

@@ -10,7 +10,7 @@ import { autoMigrate, runRetentionCleanup } from './migrator.js';
 import { fetchOverviewMetrics, fetchChartData, fetchOverviewWidgets, fetchSparklineData, } from './overview_store_queries.js';
 import { queryRequests, queryQueries, queryQueriesGrouped, queryEvents, queryEmails, queryEmailHtml, queryLogs, queryTraces, queryTraceDetail, queryRequestDetail, } from './read_queries.js';
 import { fetchSavedFilters, insertSavedFilter, removeSavedFilter } from './saved_filter_queries.js';
-import { fetchStorageStats } from './storage_stats.js';
+import { fetchStorageStats, emptyStorageStats } from './storage_stats.js';
 import { resetWriteWarnings } from './write_queue.js';
 const EMPTY_PAGINATED = (p, pp) => ({
     data: [],
@@ -63,7 +63,7 @@ export class DashboardStore {
         const cleanup = async () => {
             try {
                 if (this.db) {
-                    await runRetentionCleanup(this.db, this.config.retentionDays);
+                    await runRetentionCleanup(this.db, this.config.retentionDays, this.config.maxDbSizeMb);
                     this.lastCleanupAt = Date.now();
                     log.info('dashboard: retention cleanup complete');
                 }
@@ -110,17 +110,8 @@ export class DashboardStore {
         return this.db !== null;
     }
     async getStorageStats() {
-        const empty = {
-            ready: false,
-            dbPath: this.config.dbPath,
-            fileSizeMb: 0,
-            walSizeMb: 0,
-            retentionDays: this.config.retentionDays,
-            tables: [],
-            lastCleanupAt: null,
-        };
         if (!this.db)
-            return empty;
+            return emptyStorageStats(this.config.dbPath, this.config.retentionDays, this.config.maxDbSizeMb);
         if (this.cachedStorageStats &&
             Date.now() - this.cachedStorageStats.cachedAt < DashboardStore.STORAGE_TTL)
             return this.cachedStorageStats.data;
@@ -130,6 +121,7 @@ export class DashboardStore {
             dbFilePath: this.dbFilePath,
             dbPath: this.config.dbPath,
             retentionDays: this.config.retentionDays,
+            maxDbSizeMb: this.config.maxDbSizeMb,
             lastCleanupAt: this.lastCleanupAt,
             onResult: (stats) => {
                 this.cachedStorageStats = { data: stats, cachedAt: Date.now() };

package/dist/src/dashboard/knex_factory.js

@@ -8,7 +8,14 @@ import { log } from '../utils/logger.js';
 // ---------------------------------------------------------------------------
 // PRAGMA constants
 // ---------------------------------------------------------------------------
+// auto_vacuum must come FIRST: it only takes effect on a database whose
+// header hasn't been written yet, and even `journal_mode=WAL` initializes
+// the header. On existing databases it only takes effect after a VACUUM
+// (which runRetentionCleanup performs, guarded, when the file is mostly
+// dead pages). Incremental mode lets retention cleanup return deleted
+// pages to the OS in small chunks instead of growing the file forever.
 export const SQLITE_PRAGMAS = [
+    'auto_vacuum=INCREMENTAL',
     'journal_mode=WAL',
     'foreign_keys=ON',
     'synchronous=NORMAL',
@@ -17,6 +24,7 @@ export const SQLITE_PRAGMAS = [
     'temp_store=MEMORY',
 ];
 const PRAGMA_STATEMENTS_FOR_POOL = [
+    'auto_vacuum = INCREMENTAL',
     'journal_mode = WAL',
     'foreign_keys = ON',
     'synchronous = NORMAL',

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

@@ -11,12 +11,17 @@ import type { Knex } from 'knex';
  */
 export declare function autoMigrate(db: Knex): Promise<void>;
 /**
- * Delete records older than `retentionDays` from all tables.
+ * Delete records older than `retentionDays` from all tables, then enforce
+ * the database size cap.
  *
  * Foreign-key cascades on `server_stats_requests` handle the child
  * tables (queries, events, traces).  Standalone tables (logs, emails,
  * metrics, saved_filters) are pruned individually.
  *
+ * `maxDbSizeMb` bounds the *live* data size: when exceeded, the globally
+ * oldest rows are deleted — regardless of age — until usage drops below
+ * ~90% of the cap. `0` disables the cap.
+ *
  * Yields between each DELETE so the event loop stays responsive.
  */
-export declare function runRetentionCleanup(db: Knex, retentionDays: number): Promise<void>;
+export declare function runRetentionCleanup(db: Knex, retentionDays: number, maxDbSizeMb?: number): Promise<void>;

package/dist/src/dashboard/migrator.js

@@ -27,15 +27,20 @@ export async function autoMigrate(db) {
     await migrateSavedFilters(db);
 }
 /**
- * Delete records older than `retentionDays` from all tables.
+ * Delete records older than `retentionDays` from all tables, then enforce
+ * the database size cap.
  *
  * Foreign-key cascades on `server_stats_requests` handle the child
  * tables (queries, events, traces).  Standalone tables (logs, emails,
  * metrics, saved_filters) are pruned individually.
  *
+ * `maxDbSizeMb` bounds the *live* data size: when exceeded, the globally
+ * oldest rows are deleted — regardless of age — until usage drops below
+ * ~90% of the cap. `0` disables the cap.
+ *
  * Yields between each DELETE so the event loop stays responsive.
  */
-export async function runRetentionCleanup(db, retentionDays) {
+export async function runRetentionCleanup(db, retentionDays, maxDbSizeMb = 0) {
     // Use string interpolation instead of parameterized bindings.
     // Knex + better-sqlite3 can hang on parameterized db.raw() calls,
     // while non-parameterized queries (used in migrations) work fine.
@@ -53,7 +58,12 @@ export async function runRetentionCleanup(db, retentionDays) {
         await yieldToEventLoop();
         await batchDelete(db, 'server_stats_metrics', cutoff);
         await yieldToEventLoop();
-        // Reclaim space and update query planner statistics
+        if (maxDbSizeMb > 0)
+            await enforceSizeCap(db, maxDbSizeMb);
+        // Return deleted pages to the OS — PRAGMA optimize alone only updates
+        // planner stats, leaving the file at its high-water mark forever.
+        await reclaimFreeSpace(db);
+        // Update query planner statistics
         await db.raw('PRAGMA optimize');
     }
     catch (err) {
@@ -72,10 +82,134 @@ async function batchDelete(db, table, cutoff) {
     let hasMore = true;
     while (hasMore) {
         await db.raw(`DELETE FROM ${table} WHERE rowid IN (SELECT rowid FROM ${table} WHERE created_at < ${cutoff} LIMIT 1000)`);
-        const remaining = await db.raw(`SELECT COUNT(*) as cnt FROM ${table} WHERE created_at < ${cutoff} LIMIT 1`);
-        const cnt = remaining?.[0]?.cnt ?? 0;
-        hasMore = cnt > 0;
+        // changes() reports the last DELETE's row count on this connection
+        // (pool is min:1/max:1). Re-counting the remaining backlog here instead
+        // made total work quadratic in backlog size.
+        const deleted = await pragmaNumber(db, 'SELECT changes() AS n');
+        hasMore = deleted === 1000;
         if (hasMore)
             await yieldToEventLoop();
     }
 }
+/** Root tables pruned by the size cap; requests cascades to queries/events/traces. */
+const SIZE_CAP_TABLES = [
+    'server_stats_requests',
+    'server_stats_logs',
+    'server_stats_emails',
+    'server_stats_metrics',
+];
+/**
+ * Bytes of live data: total pages minus freelist pages. Freed pages are
+ * excluded because reclaimFreeSpace returns them to the OS afterwards.
+ */
+async function liveSizeBytes(db, pageSize) {
+    const pages = await pragmaNumber(db, 'PRAGMA page_count');
+    const freelist = await pragmaNumber(db, 'PRAGMA freelist_count');
+    return (pages - freelist) * pageSize;
+}
+/**
+ * Keep live data under `maxSizeMb` by deleting the globally oldest rows,
+ * whatever their age — a size cap effectively shortens the retention
+ * window when write volume outruns `retentionDays`.
+ *
+ * Prunes down to ~90% of the cap so the hourly cleanup doesn't re-trigger
+ * on every pass. Each round deletes 1000 rows from whichever root table
+ * currently holds the oldest data, so mixed workloads (trace-heavy vs
+ * log-heavy) shed their actual oldest history first.
+ */
+async function enforceSizeCap(db, maxSizeMb) {
+    const budget = maxSizeMb * 1024 * 1024;
+    const pageSize = await pragmaNumber(db, 'PRAGMA page_size');
+    if ((await liveSizeBytes(db, pageSize)) <= budget)
+        return;
+    const { log } = await import('../utils/logger.js');
+    log.info(`dashboard: database over the ${maxSizeMb} MB size cap — pruning oldest records`);
+    const target = budget * 0.9;
+    // 10k rounds × 1000 rows bounds one pass; the next hourly pass continues.
+    let guard = 10_000;
+    while (guard-- > 0 && (await liveSizeBytes(db, pageSize)) > target) {
+        const table = await findTableWithOldestRow(db);
+        if (!table)
+            break;
+        await db.raw(`DELETE FROM ${table} WHERE rowid IN (SELECT rowid FROM ${table} ORDER BY created_at LIMIT 1000)`);
+        const deleted = await pragmaNumber(db, 'SELECT changes() AS n');
+        if (deleted === 0)
+            break;
+        await yieldToEventLoop();
+    }
+}
+/** The root table whose oldest row is globally oldest, or null when all are empty. */
+async function findTableWithOldestRow(db) {
+    let best = null;
+    let bestTs = '';
+    for (const table of SIZE_CAP_TABLES) {
+        const rows = (await db.raw(`SELECT MIN(created_at) AS ts FROM ${table}`));
+        const ts = rows?.[0]?.ts;
+        if (ts && (best === null || ts < bestTs)) {
+            best = table;
+            bestTs = ts;
+        }
+    }
+    return best;
+}
+/**
+ * Return freelist pages to the OS after a cleanup pass.
+ *
+ * Databases created with `auto_vacuum=INCREMENTAL` are trimmed in bounded
+ * chunks so each synchronous step stays short. Legacy databases (created
+ * before the pragma existed) can't be trimmed incrementally, so when dead
+ * pages exceed ~30% of the file a one-time VACUUM rewrites it — which also
+ * converts it to incremental mode, since `auto_vacuum=INCREMENTAL` is set
+ * on this connection.
+ */
+async function reclaimFreeSpace(db) {
+    const mode = await pragmaNumber(db, 'PRAGMA auto_vacuum');
+    if (mode === 2) {
+        // Chunks of ~2000 pages (~8 MB at the 4 KB default) keep each synchronous
+        // call short; guard bounds one pass at ~8 GB in case freelist_count
+        // misbehaves.
+        let guard = 1000;
+        while (guard-- > 0) {
+            const freelist = await pragmaNumber(db, 'PRAGMA freelist_count');
+            if (freelist <= 0)
+                break;
+            if (!(await incrementalVacuumChunk(db)))
+                break;
+            await yieldToEventLoop();
+        }
+        return;
+    }
+    const pageCount = await pragmaNumber(db, 'PRAGMA page_count');
+    const freelistCount = await pragmaNumber(db, 'PRAGMA freelist_count');
+    if (pageCount > 0 && freelistCount / pageCount > 0.3) {
+        const { log } = await import('../utils/logger.js');
+        log.info(`dashboard: reclaiming ${freelistCount} of ${pageCount} pages via one-time VACUUM (may pause briefly)`);
+        await db.raw('VACUUM');
+        log.info('dashboard: VACUUM complete — database converted to incremental auto-vacuum');
+    }
+}
+/**
+ * Free up to 2000 freelist pages. incremental_vacuum frees ONE page per
+ * sqlite3_step, and knex's raw() steps no-result pragmas exactly once — so
+ * it must run on the underlying better-sqlite3 handle, whose .pragma()
+ * steps to completion. Returns false if the handle has no pragma method.
+ */
+async function incrementalVacuumChunk(db) {
+    const client = db.client;
+    const conn = (await client.acquireConnection());
+    try {
+        if (typeof conn.pragma !== 'function')
+            return false;
+        conn.pragma('incremental_vacuum(2000)');
+        return true;
+    }
+    finally {
+        client.releaseConnection(conn);
+    }
+}
+/** Run a single-row/single-column statement and return its value as a number. */
+async function pragmaNumber(db, statement) {
+    const rows = (await db.raw(statement));
+    const value = Object.values(rows?.[0] ?? {})[0];
+    return Number(value ?? 0);
+}

package/dist/src/dashboard/migrator_tables.js

@@ -72,6 +72,10 @@ export async function migrateEvents(db) {
   `);
     await db.raw(`CREATE INDEX IF NOT EXISTS idx_ss_events_created ON server_stats_events(created_at)`);
     await db.raw(`CREATE INDEX IF NOT EXISTS idx_ss_events_name ON server_stats_events(event_name)`);
+    // Without this index every cascaded delete from server_stats_requests
+    // full-scans the events table (synchronously, on the host event loop) —
+    // the other FK children (queries, traces, logs) all have one.
+    await db.raw(`CREATE INDEX IF NOT EXISTS idx_ss_events_request ON server_stats_events(request_id)`);
 }
 export async function migrateEmails(db) {
     await db.raw(`

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

@@ -20,18 +20,23 @@ export interface StorageStatsResult {
     fileSizeMb: number;
     walSizeMb: number;
     retentionDays: number;
+    /** Configured live-data size cap in MB; `0` means the cap is disabled. */
+    maxDbSizeMb: number;
     tables: Array<{
         name: string;
         rowCount: number;
     }>;
     lastCleanupAt: number | null;
 }
+/** The not-ready result returned before the SQLite connection exists. */
+export declare function emptyStorageStats(dbPath: string, retentionDays: number, maxDbSizeMb: number): StorageStatsResult;
 export interface StorageStatsOpts {
     db: Knex;
     cache: CoalesceCache;
     dbFilePath: string;
     dbPath: string;
     retentionDays: number;
+    maxDbSizeMb: number;
     lastCleanupAt: number | null;
     onResult: (stats: StorageStatsResult) => void;
 }

package/dist/src/dashboard/storage_stats.js

@@ -58,11 +58,24 @@ export async function countAllTables(db) {
         return result;
     });
 }
+/** The not-ready result returned before the SQLite connection exists. */
+export function emptyStorageStats(dbPath, retentionDays, maxDbSizeMb) {
+    return {
+        ready: false,
+        dbPath,
+        fileSizeMb: 0,
+        walSizeMb: 0,
+        retentionDays,
+        maxDbSizeMb,
+        tables: [],
+        lastCleanupAt: null,
+    };
+}
 /**
  * Build storage stats by querying file sizes and table row counts.
  */
 export function fetchStorageStats(opts) {
-    const { db, cache, dbFilePath, dbPath, retentionDays, lastCleanupAt, onResult } = opts;
+    const { db, cache, dbFilePath, dbPath, retentionDays, maxDbSizeMb, lastCleanupAt, onResult } = opts;
     return cache.coalesce('storageStats', async () => {
         const [fileSizeMb, walSizeMb] = await getFileSizes(dbFilePath);
         const tables = await countAllTables(db);
@@ -72,6 +85,7 @@ export function fetchStorageStats(opts) {
             fileSizeMb,
             walSizeMb,
             retentionDays,
+            maxDbSizeMb,
             tables,
             lastCleanupAt,
         };

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

@@ -284,6 +284,8 @@ export interface DevToolbarConfig {
     dashboardPath: string;
     /** Data retention period in days for historical persistence. */
     retentionDays: number;
+    /** Size cap in MB for the SQLite database's live data; `0` disables it. */
+    maxDbSizeMb: number;
     /** Path to the SQLite database file for historical persistence. */
     dbPath: string;
     /** Base path for the debug toolbar API endpoints. */

package/dist/src/define_config.js

@@ -33,6 +33,8 @@ function applyDashboardConfig(dashboard, result) {
             result.dashboardPath = dashboard.path;
         if (dashboard.retentionDays !== undefined)
             result.retentionDays = dashboard.retentionDays;
+        if (dashboard.maxDbSizeMb !== undefined)
+            result.maxDbSizeMb = dashboard.maxDbSizeMb;
     }
 }
 /** Advanced config field mappings. */