adonisjs-server-stats 1.3.2 → 1.5.1

package/dist/src/dashboard/dashboard_controller.js

@@ -1,17 +1,21 @@
 import { readFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { safeParseJson, safeParseJsonArray } from '../utils/json_helpers.js';
+import { round, clamp } from '../utils/math_helpers.js';
+import { loadTransmitClient } from '../utils/transmit_client.js';
 import { CacheInspector } from './integrations/cache_inspector.js';
-import { QueueInspector } from './integrations/queue_inspector.js';
 import { ConfigInspector } from './integrations/config_inspector.js';
+import { QueueInspector } from './integrations/queue_inspector.js';
 const EDGE_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'edge');
+function emptyPage(page, perPage) {
+    return { data: [], total: 0, page, perPage };
+}
 /**
  * Controller for the full-page dashboard.
  *
  * Serves the dashboard HTML page and all JSON API endpoints.
- * Constructor-injected with the SQLite-backed DashboardStore,
- * the in-memory DebugStore, and the AdonisJS application instance.
+ * Delegates all data access to the DashboardStore.
  */
 export default class DashboardController {
     dashboardStore;
@@ -34,17 +38,10 @@ export default class DashboardController {
     // ---------------------------------------------------------------------------
     // Page
     // ---------------------------------------------------------------------------
-    /**
-     * GET {dashboardPath} — Render the dashboard Edge template.
-     *
-     * Reads the dashboard CSS/JS assets and passes them as template state
-     * along with configuration for tracing and custom panes.
-     */
     async page(ctx) {
         if (!this.checkAccess(ctx)) {
             return ctx.response.forbidden({ error: 'Access denied' });
         }
-        // Lazily read and cache the CSS/JS assets
         if (!this.cachedCss) {
             this.cachedCss = readFileSync(join(EDGE_DIR, 'client', 'dashboard.css'), 'utf-8');
         }
@@ -52,7 +49,13 @@ export default class DashboardController {
             this.cachedJs = readFileSync(join(EDGE_DIR, 'client', 'dashboard.js'), 'utf-8');
         }
         if (this.cachedTransmitClient === null) {
-            this.cachedTransmitClient = this.loadTransmitClient();
+            this.cachedTransmitClient = loadTransmitClient(this.app.makePath('package.json'));
+            if (this.cachedTransmitClient) {
+                console.log('[server-stats] Transmit client loaded for dashboard');
+            }
+            else {
+                console.log('[server-stats] Dashboard will use polling. Install @adonisjs/transmit-client for real-time updates.');
+            }
         }
         const config = this.app.config.get('server_stats');
         const toolbarConfig = config?.devToolbar || {};
@@ -77,26 +80,21 @@ export default class DashboardController {
     // ---------------------------------------------------------------------------
     // Overview
     // ---------------------------------------------------------------------------
-    /**
-     * GET {dashboardPath}/api/overview — Overview metrics cards.
-     */
     async overview({ request, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
-            return response.json(emptyOverview());
-        try {
+        return this.withDb(response, emptyOverview(), async () => {
             const range = request.qs().range || '1h';
-            // Use getOverviewMetrics for accurate stats (computed from raw requests)
-            const overview = await this.dashboardStore.getOverviewMetrics(range);
+            const [overview, widgets, sparklineData] = await Promise.all([
+                this.dashboardStore.getOverviewMetrics(range),
+                this.dashboardStore.getOverviewWidgets(range),
+                this.dashboardStore.getSparklineData(range),
+            ]);
             if (!overview)
-                return response.json(emptyOverview());
-            // Add sparklines from the pre-aggregated metrics table
-            const cutoff = minutesAgo(60);
-            const metrics = await db('server_stats_metrics')
-                .where('created_at', '>=', cutoff)
-                .orderBy('bucket', 'asc');
-            const sparklineData = metrics.slice(-15);
-            return response.json({
+                return emptyOverview();
+            const [cacheStats, jobQueueStatus] = await Promise.all([
+                this.fetchCacheOverview(),
+                this.fetchQueueOverview(),
+            ]);
+            return {
                 ...overview,
                 sparklines: {
                     avgResponseTime: sparklineData.map((m) => m.avg_duration),
@@ -104,26 +102,17 @@ export default class DashboardController {
                     requestsPerMinute: sparklineData.map((m) => m.request_count),
                     errorRate: sparklineData.map((m) => m.request_count > 0 ? round((m.error_count / m.request_count) * 100) : 0),
                 },
-            });
-        }
-        catch {
-            return response.json(emptyOverview());
-        }
+                ...widgets,
+                cacheStats,
+                jobQueueStatus,
+            };
+        });
     }
-    /**
-     * GET {dashboardPath}/api/overview/chart — Chart data with time range.
-     */
     async overviewChart({ request, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
-            return response.json({ buckets: [] });
         const range = request.qs().range || '1h';
-        const { cutoff } = parseRange(range);
-        try {
-            const buckets = await db('server_stats_metrics')
-                .where('bucket', '>=', cutoff)
-                .orderBy('bucket', 'asc');
-            return response.json({
+        return this.withDb(response, { range, buckets: [] }, async () => {
+            const buckets = await this.dashboardStore.getChartData(range);
+            return {
                 range,
                 buckets: buckets.map((b) => ({
                     bucket: b.bucket,
@@ -133,70 +122,42 @@ export default class DashboardController {
                     errorCount: b.error_count,
                     queryCount: b.query_count,
                 })),
-            });
-        }
-        catch {
-            return response.json({ buckets: [] });
-        }
+            };
+        });
     }
     // ---------------------------------------------------------------------------
     // Requests
     // ---------------------------------------------------------------------------
-    /**
-     * GET {dashboardPath}/api/requests — Paginated request history.
-     */
     async requests({ request, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
-            return response.json({ data: [], total: 0 });
         const qs = request.qs();
         const page = Math.max(1, Number(qs.page) || 1);
         const perPage = clamp(Number(qs.perPage) || 25, 1, 100);
-        try {
-            let query = db('server_stats_requests');
-            if (qs.method)
-                query = query.where('method', qs.method.toUpperCase());
-            if (qs.status)
-                query = query.where('status_code', Number(qs.status));
-            if (qs.url)
-                query = query.where('url', 'like', `%${qs.url}%`);
-            const countResult = await query.clone().count('* as total').first();
-            const total = countResult?.total ?? 0;
-            const data = await query
-                .orderBy('created_at', 'desc')
-                .limit(perPage)
-                .offset((page - 1) * perPage);
-            return response.json({
-                data: data.map(formatRequest),
-                total,
-                page,
-                perPage,
+        return this.withDb(response, emptyPage(page, perPage), async () => {
+            const result = await this.dashboardStore.getRequests(page, perPage, {
+                method: qs.method ? qs.method.toUpperCase() : undefined,
+                url: qs.url || undefined,
+                status: qs.status ? Number(qs.status) : undefined,
             });
-        }
-        catch {
-            return response.json({ data: [], total: 0 });
-        }
+            return {
+                data: result.data.map(formatRequest),
+                total: result.total,
+                page: result.page,
+                perPage: result.perPage,
+            };
+        });
     }
-    /**
-     * GET {dashboardPath}/api/requests/:id — Single request with trace.
-     */
     async requestDetail({ params, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
+        if (!this.dashboardStore.isReady()) {
             return response.notFound({ error: 'Not found' });
+        }
         try {
-            const id = Number(params.id);
-            const req = await db('server_stats_requests').where('id', id).first();
-            if (!req)
+            const detail = await this.dashboardStore.getRequestDetail(Number(params.id));
+            if (!detail)
                 return response.notFound({ error: 'Request not found' });
-            const [queries, trace] = await Promise.all([
-                db('server_stats_queries').where('request_id', id).orderBy('created_at', 'asc'),
-                db('server_stats_traces').where('request_id', id).first(),
-            ]);
             return response.json({
-                ...formatRequest(req),
-                queries: queries.map(formatQuery),
-                trace: trace ? formatTrace(trace) : null,
+                ...formatRequest(detail),
+                queries: (detail.queries || []).map(formatQuery),
+                trace: detail.trace ? formatTrace(detail.trace) : null,
             });
         }
         catch {
@@ -206,73 +167,33 @@ export default class DashboardController {
     // ---------------------------------------------------------------------------
     // Queries
     // ---------------------------------------------------------------------------
-    /**
-     * GET {dashboardPath}/api/queries — Paginated query history.
-     */
     async queries({ request, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
-            return response.json({ data: [], total: 0 });
         const qs = request.qs();
         const page = Math.max(1, Number(qs.page) || 1);
         const perPage = clamp(Number(qs.perPage) || 25, 1, 100);
-        try {
-            let query = db('server_stats_queries');
-            if (qs.duration_min)
-                query = query.where('duration', '>=', Number(qs.duration_min));
-            if (qs.model)
-                query = query.where('model', qs.model);
-            if (qs.method)
-                query = query.where('method', qs.method);
-            if (qs.connection)
-                query = query.where('connection', qs.connection);
-            const countResult = await query.clone().count('* as total').first();
-            const total = countResult?.total ?? 0;
-            const data = await query
-                .orderBy('created_at', 'desc')
-                .limit(perPage)
-                .offset((page - 1) * perPage);
-            return response.json({
-                data: data.map(formatQuery),
-                total,
-                page,
-                perPage,
+        return this.withDb(response, emptyPage(page, perPage), async () => {
+            const result = await this.dashboardStore.getQueries(page, perPage, {
+                durationMin: qs.duration_min ? Number(qs.duration_min) : undefined,
+                model: qs.model || undefined,
+                method: qs.method || undefined,
+                connection: qs.connection || undefined,
             });
-        }
-        catch {
-            return response.json({ data: [], total: 0 });
-        }
+            return {
+                data: result.data.map(formatQuery),
+                total: result.total,
+                page: result.page,
+                perPage: result.perPage,
+            };
+        });
     }
-    /**
-     * GET {dashboardPath}/api/queries/grouped — Grouped by normalized SQL.
-     */
     async queriesGrouped({ request, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
-            return response.json({ groups: [] });
-        const qs = request.qs();
-        const limit = clamp(Number(qs.limit) || 50, 1, 200);
-        const sort = qs.sort || 'total_duration';
-        try {
-            const validSorts = {
-                count: 'count',
-                avg_duration: 'avg_duration',
-                total_duration: 'total_duration',
-            };
-            const orderCol = validSorts[sort] || 'total_duration';
-            const groups = await db('server_stats_queries')
-                .select('sql_normalized')
-                .select(db.raw('COUNT(*) as count'))
-                .select(db.raw('AVG(duration) as avg_duration'))
-                .select(db.raw('MIN(duration) as min_duration'))
-                .select(db.raw('MAX(duration) as max_duration'))
-                .select(db.raw('SUM(duration) as total_duration'))
-                .groupBy('sql_normalized')
-                .orderBy(orderCol, 'desc')
-                .limit(limit);
-            // Calculate total time for percentage
+        return this.withDb(response, { groups: [] }, async () => {
+            const qs = request.qs();
+            const limit = clamp(Number(qs.limit) || 50, 1, 200);
+            const sort = qs.sort || 'total_duration';
+            const groups = await this.dashboardStore.getQueriesGrouped(limit, sort);
             const totalTime = groups.reduce((sum, g) => sum + (g.total_duration || 0), 0);
-            return response.json({
+            return {
                 groups: groups.map((g) => ({
                     sqlNormalized: g.sql_normalized,
                     count: g.count,
@@ -282,30 +203,23 @@ export default class DashboardController {
                     totalDuration: round(g.total_duration),
                     percentOfTotal: totalTime > 0 ? round((g.total_duration / totalTime) * 100) : 0,
                 })),
-            });
-        }
-        catch {
-            return response.json({ groups: [] });
-        }
+            };
+        });
     }
-    /**
-     * GET {dashboardPath}/api/queries/:id/explain — Run EXPLAIN on a query.
-     */
     async queryExplain({ params, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
+        if (!this.dashboardStore.isReady()) {
             return response.notFound({ error: 'Not found' });
+        }
         try {
+            const db = this.dashboardStore.getDb();
             const id = Number(params.id);
             const query = await db('server_stats_queries').where('id', id).first();
             if (!query)
                 return response.notFound({ error: 'Query not found' });
-            // Only allow EXPLAIN on SELECT queries
             const sqlTrimmed = query.sql_text.trim().toUpperCase();
             if (!sqlTrimmed.startsWith('SELECT')) {
                 return response.badRequest({ error: 'EXPLAIN is only supported for SELECT queries' });
             }
-            // Run EXPLAIN on the app's default database connection (not the stats connection)
             let appDb;
             try {
                 const lucid = await this.app.container.make('lucid.db');
@@ -314,7 +228,6 @@ export default class DashboardController {
             catch {
                 return response.serviceUnavailable({ error: 'App database connection not available' });
             }
-            // Parse stored bindings and pass them to the EXPLAIN query
             let bindings = [];
             if (query.bindings) {
                 try {
@@ -325,22 +238,15 @@ export default class DashboardController {
                 }
             }
             const explainResult = await appDb.raw(`EXPLAIN (FORMAT JSON) ${query.sql_text}`, bindings);
-            // PostgreSQL with Knex: result is { rows: [...] }
-            // Each row has a "QUERY PLAN" key containing the JSON plan
             let plan = [];
             const rawRows = explainResult?.rows ?? (Array.isArray(explainResult) ? explainResult : []);
             if (rawRows.length > 0 && rawRows[0]['QUERY PLAN']) {
-                // EXPLAIN (FORMAT JSON) returns a single row with a JSON array
                 plan = rawRows[0]['QUERY PLAN'];
             }
             else {
                 plan = rawRows;
             }
-            return response.json({
-                queryId: id,
-                sql: query.sql_text,
-                plan,
-            });
+            return response.json({ queryId: id, sql: query.sql_text, plan });
         }
         catch (error) {
             return response.internalServerError({
@@ -352,49 +258,31 @@ export default class DashboardController {
     // ---------------------------------------------------------------------------
     // Events
     // ---------------------------------------------------------------------------
-    /**
-     * GET {dashboardPath}/api/events — Paginated event history.
-     */
     async events({ request, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
-            return response.json({ data: [], total: 0 });
         const qs = request.qs();
         const page = Math.max(1, Number(qs.page) || 1);
         const perPage = clamp(Number(qs.perPage) || 25, 1, 100);
-        try {
-            let query = db('server_stats_events');
-            if (qs.event_name)
-                query = query.where('event_name', qs.event_name);
-            const countResult = await query.clone().count('* as total').first();
-            const total = countResult?.total ?? 0;
-            const data = await query
-                .orderBy('created_at', 'desc')
-                .limit(perPage)
-                .offset((page - 1) * perPage);
-            return response.json({
-                data: data.map((e) => ({
+        return this.withDb(response, emptyPage(page, perPage), async () => {
+            const result = await this.dashboardStore.getEvents(page, perPage, {
+                eventName: qs.event_name || undefined,
+            });
+            return {
+                data: result.data.map((e) => ({
                     id: e.id,
                     requestId: e.request_id,
                     eventName: e.event_name,
                     data: safeParseJson(e.data),
                     createdAt: e.created_at,
                 })),
-                total,
-                page,
-                perPage,
-            });
-        }
-        catch {
-            return response.json({ data: [], total: 0 });
-        }
+                total: result.total,
+                page: result.page,
+                perPage: result.perPage,
+            };
+        });
     }
     // ---------------------------------------------------------------------------
     // Routes
     // ---------------------------------------------------------------------------
-    /**
-     * GET {dashboardPath}/api/routes — Route table (delegates to DebugStore).
-     */
     async routes({ response }) {
         const routes = this.debugStore.routes.getRoutes();
         return response.json({
@@ -405,46 +293,34 @@ export default class DashboardController {
     // ---------------------------------------------------------------------------
     // Logs
     // ---------------------------------------------------------------------------
-    /**
-     * GET {dashboardPath}/api/logs — Paginated logs with structured search.
-     */
     async logs({ request, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
-            return response.json({ data: [], total: 0 });
         const qs = request.qs();
         const page = Math.max(1, Number(qs.page) || 1);
         const perPage = clamp(Number(qs.perPage) || 50, 1, 200);
-        try {
-            let query = db('server_stats_logs');
-            if (qs.level)
-                query = query.where('level', qs.level);
-            if (qs.message)
-                query = query.where('message', 'like', `%${qs.message}%`);
-            if (qs.request_id)
-                query = query.where('request_id', qs.request_id);
-            // Structured JSON field search: ?field=userId&operator=equals&value=5
-            if (qs.field && qs.value !== undefined) {
-                const operator = qs.operator || 'equals';
-                const jsonPath = `$.${qs.field}`;
-                if (operator === 'equals') {
-                    query = query.whereRaw(`json_extract(data, ?) = ?`, [jsonPath, qs.value]);
-                }
-                else if (operator === 'contains') {
-                    query = query.whereRaw(`json_extract(data, ?) LIKE ?`, [jsonPath, `%${qs.value}%`]);
-                }
-                else if (operator === 'starts_with') {
-                    query = query.whereRaw(`json_extract(data, ?) LIKE ?`, [jsonPath, `${qs.value}%`]);
-                }
-            }
-            const countResult = await query.clone().count('* as total').first();
-            const total = countResult?.total ?? 0;
-            const data = await query
-                .orderBy('created_at', 'desc')
-                .limit(perPage)
-                .offset((page - 1) * perPage);
-            return response.json({
-                data: data.map((l) => ({
+        // Build structured filters from query string
+        const structured = [];
+        if (qs.field && qs.value !== undefined) {
+            const op = qs.operator || 'equals';
+            const operatorMap = {
+                equals: 'equals',
+                contains: 'contains',
+                starts_with: 'startsWith',
+            };
+            structured.push({
+                field: qs.field,
+                operator: operatorMap[op] || 'equals',
+                value: qs.value,
+            });
+        }
+        return this.withDb(response, emptyPage(page, perPage), async () => {
+            const result = await this.dashboardStore.getLogs(page, perPage, {
+                level: qs.level || undefined,
+                search: qs.message || undefined,
+                requestId: qs.request_id || undefined,
+                structured: structured.length > 0 ? structured : undefined,
+            });
+            return {
+                data: result.data.map((l) => ({
                     id: l.id,
                     level: l.level,
                     message: l.message,
@@ -452,75 +328,43 @@ export default class DashboardController {
                     data: safeParseJson(l.data),
                     createdAt: l.created_at,
                 })),
-                total,
-                page,
-                perPage,
-            });
-        }
-        catch {
-            return response.json({ data: [], total: 0 });
-        }
+                total: result.total,
+                page: result.page,
+                perPage: result.perPage,
+            };
+        });
     }
     // ---------------------------------------------------------------------------
     // Emails
     // ---------------------------------------------------------------------------
-    /**
-     * GET {dashboardPath}/api/emails — Paginated email history.
-     */
     async emails({ request, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
-            return response.json({ data: [], total: 0 });
         const qs = request.qs();
         const page = Math.max(1, Number(qs.page) || 1);
         const perPage = clamp(Number(qs.perPage) || 25, 1, 100);
-        try {
-            let query = db('server_stats_emails');
-            if (qs.from)
-                query = query.where('from_addr', 'like', `%${qs.from}%`);
-            if (qs.to)
-                query = query.where('to_addr', 'like', `%${qs.to}%`);
-            if (qs.subject)
-                query = query.where('subject', 'like', `%${qs.subject}%`);
-            if (qs.status)
-                query = query.where('status', qs.status);
-            if (qs.mailer)
-                query = query.where('mailer', qs.mailer);
-            const countResult = await query.clone().count('* as total').first();
-            const total = countResult?.total ?? 0;
-            // Strip html/text from list for performance
-            const data = await query
-                .select('id', 'from_addr', 'to_addr', 'cc', 'bcc', 'subject', 'mailer', 'status', 'message_id', 'attachment_count', 'created_at')
-                .orderBy('created_at', 'desc')
-                .limit(perPage)
-                .offset((page - 1) * perPage);
-            return response.json({
-                data: data.map(formatEmail),
-                total,
-                page,
-                perPage,
-            });
-        }
-        catch {
-            return response.json({ data: [], total: 0 });
-        }
+        return this.withDb(response, emptyPage(page, perPage), async () => {
+            const result = await this.dashboardStore.getEmails(page, perPage, {
+                from: qs.from || undefined,
+                to: qs.to || undefined,
+                subject: qs.subject || undefined,
+                status: qs.status || undefined,
+                mailer: qs.mailer || undefined,
+            }, true);
+            return {
+                data: result.data.map(formatEmail),
+                total: result.total,
+                page: result.page,
+                perPage: result.perPage,
+            };
+        });
     }
-    /**
-     * GET {dashboardPath}/api/emails/:id/preview — Email HTML preview.
-     */
     async emailPreview({ params, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
+        if (!this.dashboardStore.isReady()) {
             return response.notFound({ error: 'Not found' });
+        }
         try {
-            const id = Number(params.id);
-            const email = await db('server_stats_emails')
-                .where('id', id)
-                .select('html', 'text_body')
-                .first();
-            if (!email)
+            const html = await this.dashboardStore.getEmailHtml(Number(params.id));
+            if (!html)
                 return response.notFound({ error: 'Email not found' });
-            const html = email.html || email.text_body || '<p>No content</p>';
             return response.header('Content-Type', 'text/html; charset=utf-8').send(html);
         }
         catch {
@@ -530,27 +374,14 @@ export default class DashboardController {
     // ---------------------------------------------------------------------------
     // Traces
     // ---------------------------------------------------------------------------
-    /**
-     * GET {dashboardPath}/api/traces — Paginated trace list (lightweight).
-     */
     async traces({ request, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
-            return response.json({ data: [], total: 0 });
         const qs = request.qs();
         const page = Math.max(1, Number(qs.page) || 1);
         const perPage = clamp(Number(qs.perPage) || 25, 1, 100);
-        try {
-            const countResult = await db('server_stats_traces').count('* as total').first();
-            const total = countResult?.total ?? 0;
-            // Strip spans and warnings from list for performance
-            const data = await db('server_stats_traces')
-                .select('id', 'request_id', 'method', 'url', 'status_code', 'total_duration', 'span_count', 'warnings', 'created_at')
-                .orderBy('created_at', 'desc')
-                .limit(perPage)
-                .offset((page - 1) * perPage);
-            return response.json({
-                data: data.map((t) => ({
+        return this.withDb(response, emptyPage(page, perPage), async () => {
+            const result = await this.dashboardStore.getTraces(page, perPage);
+            return {
+                data: result.data.map((t) => ({
                     id: t.id,
                     requestId: t.request_id,
                     method: t.method,
@@ -561,25 +392,18 @@ export default class DashboardController {
                     warningCount: safeParseJsonArray(t.warnings).length,
                     createdAt: t.created_at,
                 })),
-                total,
-                page,
-                perPage,
-            });
-        }
-        catch {
-            return response.json({ data: [], total: 0 });
-        }
+                total: result.total,
+                page: result.page,
+                perPage: result.perPage,
+            };
+        });
     }
-    /**
-     * GET {dashboardPath}/api/traces/:id — Single trace with full spans.
-     */
     async traceDetail({ params, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
+        if (!this.dashboardStore.isReady()) {
             return response.notFound({ error: 'Not found' });
+        }
         try {
-            const id = Number(params.id);
-            const trace = await db('server_stats_traces').where('id', id).first();
+            const trace = await this.dashboardStore.getTraceDetail(Number(params.id));
             if (!trace)
                 return response.notFound({ error: 'Trace not found' });
             return response.json(formatTrace(trace));
@@ -591,11 +415,8 @@ export default class DashboardController {
     // ---------------------------------------------------------------------------
     // Cache
     // ---------------------------------------------------------------------------
-    /**
-     * GET {dashboardPath}/api/cache — Cache stats and key list.
-     */
     async cacheStats({ request, response }) {
-        const inspector = await this.getCacheInspector();
+        const inspector = await this.getInspector('cache');
         if (!inspector) {
             return response.json({ available: false, stats: null, keys: [] });
         }
@@ -619,11 +440,8 @@ export default class DashboardController {
             return response.json({ available: false, stats: null, keys: [] });
         }
     }
-    /**
-     * GET {dashboardPath}/api/cache/:key — Single cache key detail.
-     */
     async cacheKey({ params, response }) {
-        const inspector = await this.getCacheInspector();
+        const inspector = await this.getInspector('cache');
         if (!inspector) {
             return response.notFound({ error: 'Cache not available' });
         }
@@ -641,11 +459,8 @@ export default class DashboardController {
     // ---------------------------------------------------------------------------
     // Jobs / Queue
     // ---------------------------------------------------------------------------
-    /**
-     * GET {dashboardPath}/api/jobs — Job list with status filter.
-     */
     async jobs({ request, response }) {
-        const inspector = await this.getQueueInspector();
+        const inspector = await this.getInspector('queue');
         if (!inspector) {
             return response.json({ available: false, overview: null, jobs: [], total: 0 });
         }
@@ -671,11 +486,8 @@ export default class DashboardController {
             return response.json({ available: false, overview: null, jobs: [], total: 0 });
         }
     }
-    /**
-     * GET {dashboardPath}/api/jobs/:id — Single job detail.
-     */
     async jobDetail({ params, response }) {
-        const inspector = await this.getQueueInspector();
+        const inspector = await this.getInspector('queue');
         if (!inspector) {
             return response.notFound({ error: 'Queue not available' });
         }
@@ -689,11 +501,8 @@ export default class DashboardController {
             return response.notFound({ error: 'Job not found' });
         }
     }
-    /**
-     * POST {dashboardPath}/api/jobs/:id/retry — Retry a failed job.
-     */
     async jobRetry({ params, response }) {
-        const inspector = await this.getQueueInspector();
+        const inspector = await this.getInspector('queue');
         if (!inspector) {
             return response.notFound({ error: 'Queue not available' });
         }
@@ -711,9 +520,6 @@ export default class DashboardController {
     // ---------------------------------------------------------------------------
     // Config
     // ---------------------------------------------------------------------------
-    /**
-     * GET {dashboardPath}/api/config — Sanitized app config and env vars.
-     */
     async config({ response }) {
         const configData = this.configInspector.getConfig();
         const envData = this.configInspector.getEnvVars();
@@ -725,17 +531,10 @@ export default class DashboardController {
     // ---------------------------------------------------------------------------
     // Saved Filters
     // ---------------------------------------------------------------------------
-    /**
-     * GET {dashboardPath}/api/filters — List saved filter presets.
-     */
     async savedFilters({ response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
-            return response.json({ filters: [] });
-        try {
-            const filters = await db('server_stats_saved_filters')
-                .orderBy('created_at', 'desc');
-            return response.json({
+        return this.withDb(response, { filters: [] }, async () => {
+            const filters = await this.dashboardStore.getSavedFilters();
+            return {
                 filters: filters.map((f) => ({
                     id: f.id,
                     name: f.name,
@@ -743,53 +542,38 @@ export default class DashboardController {
                     filterConfig: safeParseJson(f.filter_config),
                     createdAt: f.created_at,
                 })),
-            });
-        }
-        catch {
-            return response.json({ filters: [] });
-        }
+            };
+        });
     }
-    /**
-     * POST {dashboardPath}/api/filters — Create a saved filter preset.
-     */
     async createSavedFilter({ request, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
+        if (!this.dashboardStore.isReady()) {
             return response.serviceUnavailable({ error: 'Database not available' });
+        }
         try {
             const body = request.body();
-            const name = body.name;
-            const section = body.section;
-            const filterConfig = body.filterConfig;
+            const { name, section, filterConfig } = body;
             if (!name || !section || !filterConfig) {
-                return response.badRequest({ error: 'Missing required fields: name, section, filterConfig' });
+                return response.badRequest({
+                    error: 'Missing required fields: name, section, filterConfig',
+                });
             }
-            const [id] = await db('server_stats_saved_filters').insert({
-                name,
-                section,
-                filter_config: typeof filterConfig === 'string' ? filterConfig : JSON.stringify(filterConfig),
-            });
-            return response.json({
-                id,
-                name,
-                section,
-                filterConfig: typeof filterConfig === 'string' ? safeParseJson(filterConfig) : filterConfig,
-            });
+            const configObj = typeof filterConfig === 'string' ? safeParseJson(filterConfig) : filterConfig;
+            const result = await this.dashboardStore.createSavedFilter(name, section, configObj);
+            if (!result) {
+                return response.serviceUnavailable({ error: 'Database not available' });
+            }
+            return response.json(result);
         }
         catch {
             return response.internalServerError({ error: 'Failed to create filter' });
         }
     }
-    /**
-     * DELETE {dashboardPath}/api/filters/:id — Delete a saved filter preset.
-     */
     async deleteSavedFilter({ params, response }) {
-        const db = this.dashboardStore.getDb();
-        if (!db)
+        if (!this.dashboardStore.isReady()) {
             return response.serviceUnavailable({ error: 'Database not available' });
+        }
         try {
-            const id = Number(params.id);
-            const deleted = await db('server_stats_saved_filters').where('id', id).del();
+            const deleted = await this.dashboardStore.deleteSavedFilter(Number(params.id));
             if (!deleted)
                 return response.notFound({ error: 'Filter not found' });
             return response.json({ success: true });
@@ -802,8 +586,19 @@ export default class DashboardController {
     // Private helpers
     // ---------------------------------------------------------------------------
     /**
-     * Check if the current request is authorized via shouldShow.
+     * Wraps a store call with null-guard + try/catch boilerplate.
+     * Returns emptyValue if the store is not ready or the fn throws.
      */
+    async withDb(response, emptyValue, fn) {
+        if (!this.dashboardStore.isReady())
+            return response.json(emptyValue);
+        try {
+            return response.json(await fn());
+        }
+        catch {
+            return response.json(emptyValue);
+        }
+    }
     checkAccess(ctx) {
         const config = this.app.config.get('server_stats');
         if (!config?.shouldShow)
@@ -815,81 +610,90 @@ export default class DashboardController {
             return false;
         }
     }
-    /**
-     * Get the configured dashboard path.
-     */
     getDashboardPath() {
         const config = this.app.config.get('server_stats');
         return config?.devToolbar?.dashboardPath ?? '/__stats';
     }
-    /**
-     * Try to locate and read the @adonisjs/transmit-client build file.
-     * Returns the file contents wrapped to expose `window.Transmit`, or
-     * an empty string if the package is not installed.
-     */
-    loadTransmitClient() {
-        try {
-            const req = createRequire(this.app.makePath('package.json'));
-            const clientPath = req.resolve('@adonisjs/transmit-client/build/index.js');
-            const src = readFileSync(clientPath, 'utf-8');
-            console.log('[server-stats] Transmit client loaded from:', clientPath, `(${src.length} bytes)`);
-            // The file is ESM with `export { Transmit }`. Wrap it in an IIFE
-            // that captures the export and assigns it to window.Transmit.
-            return `(function(){var __exports={};(function(){${src.replace(/^export\s*\{[^}]*\}\s*;?\s*$/m, '')}\n__exports.Transmit=Transmit;})();window.Transmit=__exports.Transmit;})()`;
-        }
-        catch (err) {
-            console.log('[server-stats] Transmit client not available:', err?.message || 'unknown error');
-            console.log('[server-stats] Dashboard will use polling. Install @adonisjs/transmit-client for real-time updates.');
-            return '';
+    async getInspector(type) {
+        if (type === 'cache') {
+            if (this.cacheAvailable === false)
+                return null;
+            if (this.cacheInspector)
+                return this.cacheInspector;
+            try {
+                const available = await CacheInspector.isAvailable(this.app);
+                this.cacheAvailable = available;
+                if (!available)
+                    return null;
+                const redis = await this.app.container.make('redis');
+                this.cacheInspector = new CacheInspector(redis);
+                return this.cacheInspector;
+            }
+            catch {
+                this.cacheAvailable = false;
+                return null;
+            }
+        }
+        else {
+            if (this.queueAvailable === false)
+                return null;
+            if (this.queueInspector)
+                return this.queueInspector;
+            try {
+                const available = await QueueInspector.isAvailable(this.app);
+                this.queueAvailable = available;
+                if (!available)
+                    return null;
+                const queue = await this.app.container.make('queue');
+                this.queueInspector = new QueueInspector(queue);
+                return this.queueInspector;
+            }
+            catch {
+                this.queueAvailable = false;
+                return null;
+            }
         }
     }
-    /**
-     * Lazily initialize and return the CacheInspector (if Redis is available).
-     */
-    async getCacheInspector() {
-        if (this.cacheAvailable === false)
-            return null;
-        if (this.cacheInspector)
-            return this.cacheInspector;
+    /** Fetch cache overview stats for the overview page. */
+    async fetchCacheOverview() {
         try {
-            const available = await CacheInspector.isAvailable(this.app);
-            this.cacheAvailable = available;
-            if (!available)
+            const inspector = await this.getInspector('cache');
+            if (!inspector)
                 return null;
-            const redis = await this.app.container.make('redis');
-            this.cacheInspector = new CacheInspector(redis);
-            return this.cacheInspector;
+            const stats = await inspector.getStats();
+            return {
+                available: true,
+                totalKeys: stats.totalKeys,
+                hitRate: stats.hitRate,
+                memoryUsedHuman: stats.memoryUsedHuman,
+            };
         }
         catch {
-            this.cacheAvailable = false;
             return null;
         }
     }
-    /**
-     * Lazily initialize and return the QueueInspector (if Bull Queue is available).
-     */
-    async getQueueInspector() {
-        if (this.queueAvailable === false)
-            return null;
-        if (this.queueInspector)
-            return this.queueInspector;
+    /** Fetch queue overview stats for the overview page. */
+    async fetchQueueOverview() {
         try {
-            const available = await QueueInspector.isAvailable(this.app);
-            this.queueAvailable = available;
-            if (!available)
+            const inspector = await this.getInspector('queue');
+            if (!inspector)
                 return null;
-            const queue = await this.app.container.make('queue');
-            this.queueInspector = new QueueInspector(queue);
-            return this.queueInspector;
+            const overview = await inspector.getOverview();
+            return {
+                available: true,
+                active: overview.active,
+                waiting: overview.waiting,
+                failed: overview.failed,
+                completed: overview.completed,
+            };
         }
         catch {
-            this.queueAvailable = false;
             return null;
         }
     }
 }
 // ---------------------------------------------------------------------------
-// Formatting helpers
+// Formatting helpers (snake_case DB rows → camelCase API response)
 // ---------------------------------------------------------------------------
 function formatRequest(r) {
     return {
@@ -962,47 +766,12 @@ function emptyOverview() {
         slowestEndpoints: [],
         queryStats: { total: 0, avgDuration: 0, perRequest: 0 },
         recentErrors: [],
+        topEvents: [],
+        emailActivity: { sent: 0, queued: 0, failed: 0 },
+        logLevelBreakdown: { error: 0, warn: 0, info: 0, debug: 0 },
+        statusDistribution: { '2xx': 0, '3xx': 0, '4xx': 0, '5xx': 0 },
+        slowestQueries: [],
+        cacheStats: null,
+        jobQueueStatus: null,
     };
 }
-// ---------------------------------------------------------------------------
-// Utility functions
-// ---------------------------------------------------------------------------
-function round(n) {
-    return Math.round(n * 100) / 100;
-}
-function clamp(value, min, max) {
-    return Math.max(min, Math.min(max, value));
-}
-function minutesAgo(minutes) {
-    const d = new Date(Date.now() - minutes * 60_000);
-    return d.toISOString().replace('T', ' ').slice(0, 19);
-}
-function parseRange(range) {
-    const rangeMap = {
-        '5m': 5,
-        '15m': 15,
-        '30m': 30,
-        '1h': 60,
-        '6h': 360,
-        '24h': 1440,
-        '7d': 10080,
-    };
-    const minutes = rangeMap[range] ?? 60;
-    return { cutoff: minutesAgo(minutes) };
-}
-function safeParseJson(value) {
-    if (value === null || value === undefined)
-        return null;
-    if (typeof value !== 'string')
-        return value;
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return value;
-    }
-}
-function safeParseJsonArray(value) {
-    const parsed = safeParseJson(value);
-    return Array.isArray(parsed) ? parsed : [];
-}