adonisjs-server-stats 1.5.4 → 1.6.2

package/dist/src/dashboard/dashboard_controller.js

@@ -2,24 +2,38 @@ import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { safeParseJson, safeParseJsonArray } from '../utils/json_helpers.js';
+import { log } from '../utils/logger.js';
 import { round, clamp } from '../utils/math_helpers.js';
 import { loadTransmitClient } from '../utils/transmit_client.js';
 import { CacheInspector } from './integrations/cache_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');
+const warnedDbReads = new Set();
+const SRC_DIR = dirname(fileURLToPath(import.meta.url));
+const EDGE_DIR = join(SRC_DIR, '..', 'edge');
+const STYLES_DIR = join(SRC_DIR, '..', 'styles');
+function paginatedResponse(data, total, page, perPage) {
+    return {
+        data,
+        meta: { total, page, perPage, lastPage: Math.max(1, Math.ceil(total / perPage)) },
+    };
+}
 function emptyPage(page, perPage) {
-    return { data: [], total: 0, page, perPage };
+    return { data: [], meta: { total: 0, page, perPage, lastPage: 1 } };
 }
 /**
  * Controller for the full-page dashboard.
  *
- * Serves the dashboard HTML page and all JSON API endpoints.
- * Delegates all data access to the DashboardStore.
+ * Serves the dashboard HTML page and dashboard-specific JSON API
+ * endpoints (overview, requests, grouped queries, query explain,
+ * cache, jobs, config, saved filters).
+ *
+ * Data resource endpoints (queries, events, emails, traces, routes,
+ * logs) are handled by the unified ApiController — see
+ * `src/controller/api_controller.ts`.
  */
 export default class DashboardController {
     dashboardStore;
-    debugStore;
     app;
     cacheInspector = null;
     queueInspector = null;
@@ -29,9 +43,8 @@ export default class DashboardController {
     cachedCss = null;
     cachedJs = null;
     cachedTransmitClient = null;
-    constructor(dashboardStore, debugStore, app) {
+    constructor(dashboardStore, app) {
         this.dashboardStore = dashboardStore;
-        this.debugStore = debugStore;
         this.app = app;
         this.configInspector = new ConfigInspector(app);
     }
@@ -42,38 +55,40 @@ export default class DashboardController {
         if (!this.checkAccess(ctx)) {
             return ctx.response.forbidden({ error: 'Access denied' });
         }
+        const config = this.app.config.get('server_stats');
+        const toolbarConfig = config?.devToolbar ?? {};
         if (!this.cachedCss) {
-            this.cachedCss = readFileSync(join(EDGE_DIR, 'client', 'dashboard.css'), 'utf-8');
+            const tokens = readFileSync(join(STYLES_DIR, 'tokens.css'), 'utf-8');
+            const components = readFileSync(join(STYLES_DIR, 'components.css'), 'utf-8');
+            const utilities = readFileSync(join(STYLES_DIR, 'utilities.css'), 'utf-8');
+            const dashboard = readFileSync(join(STYLES_DIR, 'dashboard.css'), 'utf-8');
+            this.cachedCss = tokens + '\n' + components + '\n' + utilities + '\n' + dashboard;
         }
         if (!this.cachedJs) {
-            this.cachedJs = readFileSync(join(EDGE_DIR, 'client', 'dashboard.js'), 'utf-8');
+            const renderer = toolbarConfig.renderer || 'preact';
+            const clientDir = renderer === 'vue' ? 'client-vue' : 'client';
+            this.cachedJs = readFileSync(join(EDGE_DIR, clientDir, 'dashboard.js'), 'utf-8');
         }
         if (this.cachedTransmitClient === null) {
             this.cachedTransmitClient = loadTransmitClient(this.app.makePath('package.json'));
             if (this.cachedTransmitClient) {
-                console.log('[server-stats] Transmit client loaded for dashboard');
+                log.info('Transmit client loaded for dashboard');
             }
             else {
-                console.log('[server-stats] Dashboard will use polling. Install @adonisjs/transmit-client for real-time updates.');
+                log.info('Dashboard will use polling. Install @adonisjs/transmit-client for real-time updates.');
             }
         }
-        const config = this.app.config.get('server_stats');
-        const toolbarConfig = config?.devToolbar || {};
         const dashPath = this.getDashboardPath();
         return ctx.view.render('ss::dashboard', {
             css: this.cachedCss,
             js: this.cachedJs,
             transmitClient: this.cachedTransmitClient,
-            dashboardPath: dashPath,
-            showTracing: !!toolbarConfig.tracing,
-            customPanes: toolbarConfig.panes || [],
             dashConfig: {
-                basePath: dashPath,
-                tracing: !!toolbarConfig.tracing,
-                panes: (toolbarConfig.panes || []).map((p) => ({
-                    id: p.id,
-                    label: p.label,
-                })),
+                baseUrl: '',
+                dashboardEndpoint: dashPath + '/api',
+                debugEndpoint: toolbarConfig.debugEndpoint || '/admin/api/debug',
+                channelName: 'server-stats/dashboard',
+                backUrl: '/',
             },
         });
     }
@@ -81,7 +96,7 @@ export default class DashboardController {
     // Overview
     // ---------------------------------------------------------------------------
     async overview({ request, response }) {
-        return this.withDb(response, emptyOverview(), async () => {
+        return this.withDb(response, 'overview', emptyOverview(), async () => {
             const range = request.qs().range || '1h';
             const [overview, widgets, sparklineData] = await Promise.all([
                 this.dashboardStore.getOverviewMetrics(range),
@@ -100,7 +115,9 @@ export default class DashboardController {
                     avgResponseTime: sparklineData.map((m) => m.avg_duration),
                     p95ResponseTime: sparklineData.map((m) => m.p95_duration),
                     requestsPerMinute: sparklineData.map((m) => m.request_count),
-                    errorRate: sparklineData.map((m) => m.request_count > 0 ? round((m.error_count / m.request_count) * 100) : 0),
+                    errorRate: sparklineData.map((m) => m.request_count > 0
+                        ? round((m.error_count / m.request_count) * 100)
+                        : 0),
                 },
                 ...widgets,
                 cacheStats,
@@ -110,7 +127,7 @@ export default class DashboardController {
     }
     async overviewChart({ request, response }) {
         const range = request.qs().range || '1h';
-        return this.withDb(response, { range, buckets: [] }, async () => {
+        return this.withDb(response, 'overviewChart', { range, buckets: [] }, async () => {
             const buckets = await this.dashboardStore.getChartData(range);
             return {
                 range,
@@ -132,18 +149,14 @@ export default class DashboardController {
         const qs = request.qs();
         const page = Math.max(1, Number(qs.page) || 1);
         const perPage = clamp(Number(qs.perPage) || 25, 1, 100);
-        return this.withDb(response, emptyPage(page, perPage), async () => {
+        return this.withDb(response, 'requests', 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,
+                search: qs.search || undefined,
             });
-            return {
-                data: result.data.map(formatRequest),
-                total: result.total,
-                page: result.page,
-                perPage: result.perPage,
-            };
+            return paginatedResponse(result.data.map(formatRequest), result.total, result.page, result.perPage);
         });
     }
     async requestDetail({ params, response }) {
@@ -164,34 +177,13 @@ export default class DashboardController {
             return response.notFound({ error: 'Not found' });
         }
     }
-    // ---------------------------------------------------------------------------
-    // Queries
-    // ---------------------------------------------------------------------------
-    async queries({ request, response }) {
-        const qs = request.qs();
-        const page = Math.max(1, Number(qs.page) || 1);
-        const perPage = clamp(Number(qs.perPage) || 25, 1, 100);
-        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,
-            });
-            return {
-                data: result.data.map(formatQuery),
-                total: result.total,
-                page: result.page,
-                perPage: result.perPage,
-            };
-        });
-    }
     async queriesGrouped({ request, response }) {
-        return this.withDb(response, { groups: [] }, async () => {
+        return this.withDb(response, 'queriesGrouped', { 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 search = qs.search || undefined;
+            const groups = await this.dashboardStore.getQueriesGrouped(limit, sort, search);
             const totalTime = groups.reduce((sum, g) => sum + (g.total_duration || 0), 0);
             return {
                 groups: groups.map((g) => ({
@@ -212,21 +204,31 @@ export default class DashboardController {
         }
         try {
             const db = this.dashboardStore.getDb();
+            if (!db)
+                return response.notFound({ error: 'Not found' });
             const id = Number(params.id);
-            const query = await db('server_stats_queries').where('id', id).first();
+            const query = await db('server_stats_queries')
+                .where('id', id)
+                .first();
             if (!query)
                 return response.notFound({ error: 'Query not found' });
             const sqlTrimmed = query.sql_text.trim().toUpperCase();
             if (!sqlTrimmed.startsWith('SELECT')) {
-                return response.badRequest({ error: 'EXPLAIN is only supported for SELECT queries' });
+                return response.badRequest({
+                    error: 'EXPLAIN is only supported for SELECT queries',
+                });
             }
             let appDb;
             try {
                 const lucid = await this.app.container.make('lucid.db');
-                appDb = lucid.connection().getWriteClient();
+                appDb = lucid
+                    .connection()
+                    .getWriteClient();
             }
             catch {
-                return response.serviceUnavailable({ error: 'App database connection not available' });
+                return response.serviceUnavailable({
+                    error: 'App database connection not available',
+                });
             }
             let bindings = [];
             if (query.bindings) {
@@ -239,7 +241,8 @@ export default class DashboardController {
             }
             const explainResult = await appDb.raw(`EXPLAIN (FORMAT JSON) ${query.sql_text}`, bindings);
             let plan = [];
-            const rawRows = explainResult?.rows ?? (Array.isArray(explainResult) ? explainResult : []);
+            const rawRows = explainResult?.rows ??
+                (Array.isArray(explainResult) ? explainResult : []);
             if (rawRows.length > 0 && rawRows[0]['QUERY PLAN']) {
                 plan = rawRows[0]['QUERY PLAN'];
             }
@@ -256,163 +259,6 @@ export default class DashboardController {
         }
     }
     // ---------------------------------------------------------------------------
-    // Events
-    // ---------------------------------------------------------------------------
-    async events({ request, response }) {
-        const qs = request.qs();
-        const page = Math.max(1, Number(qs.page) || 1);
-        const perPage = clamp(Number(qs.perPage) || 25, 1, 100);
-        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: result.total,
-                page: result.page,
-                perPage: result.perPage,
-            };
-        });
-    }
-    // ---------------------------------------------------------------------------
-    // Routes
-    // ---------------------------------------------------------------------------
-    async routes({ response }) {
-        const routes = this.debugStore.routes.getRoutes();
-        return response.json({
-            routes,
-            total: this.debugStore.routes.getRouteCount(),
-        });
-    }
-    // ---------------------------------------------------------------------------
-    // Logs
-    // ---------------------------------------------------------------------------
-    async logs({ request, response }) {
-        const qs = request.qs();
-        const page = Math.max(1, Number(qs.page) || 1);
-        const perPage = clamp(Number(qs.perPage) || 50, 1, 200);
-        // 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,
-                    requestId: l.request_id,
-                    data: safeParseJson(l.data),
-                    createdAt: l.created_at,
-                })),
-                total: result.total,
-                page: result.page,
-                perPage: result.perPage,
-            };
-        });
-    }
-    // ---------------------------------------------------------------------------
-    // Emails
-    // ---------------------------------------------------------------------------
-    async emails({ request, response }) {
-        const qs = request.qs();
-        const page = Math.max(1, Number(qs.page) || 1);
-        const perPage = clamp(Number(qs.perPage) || 25, 1, 100);
-        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,
-            };
-        });
-    }
-    async emailPreview({ params, response }) {
-        if (!this.dashboardStore.isReady()) {
-            return response.notFound({ error: 'Not found' });
-        }
-        try {
-            const html = await this.dashboardStore.getEmailHtml(Number(params.id));
-            if (!html)
-                return response.notFound({ error: 'Email not found' });
-            return response.header('Content-Type', 'text/html; charset=utf-8').send(html);
-        }
-        catch {
-            return response.notFound({ error: 'Not found' });
-        }
-    }
-    // ---------------------------------------------------------------------------
-    // Traces
-    // ---------------------------------------------------------------------------
-    async traces({ request, response }) {
-        const qs = request.qs();
-        const page = Math.max(1, Number(qs.page) || 1);
-        const perPage = clamp(Number(qs.perPage) || 25, 1, 100);
-        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,
-                    url: t.url,
-                    statusCode: t.status_code,
-                    totalDuration: t.total_duration,
-                    spanCount: t.span_count,
-                    warningCount: safeParseJsonArray(t.warnings).length,
-                    createdAt: t.created_at,
-                })),
-                total: result.total,
-                page: result.page,
-                perPage: result.perPage,
-            };
-        });
-    }
-    async traceDetail({ params, response }) {
-        if (!this.dashboardStore.isReady()) {
-            return response.notFound({ error: 'Not found' });
-        }
-        try {
-            const trace = await this.dashboardStore.getTraceDetail(Number(params.id));
-            if (!trace)
-                return response.notFound({ error: 'Trace not found' });
-            return response.json(formatTrace(trace));
-        }
-        catch {
-            return response.notFound({ error: 'Not found' });
-        }
-    }
-    // ---------------------------------------------------------------------------
     // Cache
     // ---------------------------------------------------------------------------
     async cacheStats({ request, response }) {
@@ -421,7 +267,8 @@ export default class DashboardController {
             return response.json({ available: false, stats: null, keys: [] });
         }
         const qs = request.qs();
-        const pattern = qs.pattern || '*';
+        const searchTerm = qs.search || qs.pattern || '';
+        const pattern = searchTerm ? `*${searchTerm}*` : '*';
         const cursor = qs.cursor || '0';
         const count = clamp(Number(qs.count) || 100, 1, 500);
         try {
@@ -456,34 +303,72 @@ export default class DashboardController {
             return response.notFound({ error: 'Key not found' });
         }
     }
+    async cacheKeyDelete({ params, response }) {
+        const inspector = await this.getInspector('cache');
+        if (!inspector) {
+            return response.notFound({ error: 'Cache not available' });
+        }
+        try {
+            const key = decodeURIComponent(params.key);
+            const deleted = await inspector.deleteKey(key);
+            if (!deleted)
+                return response.notFound({ error: 'Key not found' });
+            return response.json({ deleted: true });
+        }
+        catch {
+            return response.internalServerError({ error: 'Failed to delete cache key' });
+        }
+    }
     // ---------------------------------------------------------------------------
     // Jobs / Queue
     // ---------------------------------------------------------------------------
     async jobs({ request, response }) {
         const inspector = await this.getInspector('queue');
         if (!inspector) {
-            return response.json({ available: false, overview: null, jobs: [], total: 0 });
+            return response.json({
+                available: false,
+                overview: null,
+                stats: null,
+                jobs: [],
+                total: 0,
+            });
         }
         const qs = request.qs();
-        const status = qs.status || 'active';
+        const status = qs.status || 'all';
+        const searchTerm = qs.search || '';
         const page = Math.max(1, Number(qs.page) || 1);
-        const perPage = clamp(Number(qs.perPage) || 25, 1, 100);
+        const perPage = clamp(Number(qs.perPage) || Number(qs.limit) || 25, 1, 100);
         try {
             const [overview, jobList] = await Promise.all([
                 inspector.getOverview(),
                 inspector.listJobs(status, page, perPage),
             ]);
+            // Filter jobs by search term (name match) if provided
+            let filteredJobs = jobList.jobs;
+            let filteredTotal = jobList.total;
+            if (searchTerm) {
+                const term = searchTerm.toLowerCase();
+                filteredJobs = jobList.jobs.filter((j) => j.name?.toLowerCase().includes(term) || j.id?.toString().toLowerCase().includes(term));
+                filteredTotal = filteredJobs.length;
+            }
             return response.json({
                 available: true,
                 overview,
-                jobs: jobList.jobs,
-                total: jobList.total,
+                stats: overview,
+                jobs: filteredJobs,
+                total: filteredTotal,
                 page,
                 perPage,
             });
         }
         catch {
-            return response.json({ available: false, overview: null, jobs: [], total: 0 });
+            return response.json({
+                available: false,
+                overview: null,
+                stats: null,
+                jobs: [],
+                total: 0,
+            });
         }
     }
     async jobDetail({ params, response }) {
@@ -509,7 +394,9 @@ export default class DashboardController {
         try {
             const success = await inspector.retryJob(String(params.id));
             if (!success) {
-                return response.badRequest({ error: 'Job could not be retried (not in failed state)' });
+                return response.badRequest({
+                    error: 'Job could not be retried (not in failed state)',
+                });
             }
             return response.json({ success: true });
         }
@@ -524,7 +411,7 @@ export default class DashboardController {
         const configData = this.configInspector.getConfig();
         const envData = this.configInspector.getEnvVars();
         return response.json({
-            config: configData.config,
+            app: configData.config,
             env: envData.env,
         });
     }
@@ -532,7 +419,7 @@ export default class DashboardController {
     // Saved Filters
     // ---------------------------------------------------------------------------
     async savedFilters({ response }) {
-        return this.withDb(response, { filters: [] }, async () => {
+        return this.withDb(response, 'savedFilters', { filters: [] }, async () => {
             const filters = await this.dashboardStore.getSavedFilters();
             return {
                 filters: filters.map((f) => ({
@@ -589,13 +476,17 @@ export default class DashboardController {
      * 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) {
+    async withDb(response, label, emptyValue, fn) {
         if (!this.dashboardStore.isReady())
             return response.json(emptyValue);
         try {
             return response.json(await fn());
         }
-        catch {
+        catch (err) {
+            if (!warnedDbReads.has(label)) {
+                warnedDbReads.add(label);
+                log.warn(`dashboard ${label}: DB read failed — ${err?.message}`);
+            }
             return response.json(emptyValue);
         }
     }
@@ -623,14 +514,17 @@ export default class DashboardController {
             try {
                 const available = await CacheInspector.isAvailable(this.app);
                 this.cacheAvailable = available;
-                if (!available)
+                if (!available) {
+                    log.info('dashboard: Redis not detected — Cache panel disabled');
                     return null;
+                }
                 const redis = await this.app.container.make('redis');
                 this.cacheInspector = new CacheInspector(redis);
                 return this.cacheInspector;
             }
-            catch {
+            catch (err) {
                 this.cacheAvailable = false;
+                log.warn('dashboard: CacheInspector init failed — ' + err?.message);
                 return null;
             }
         }
@@ -642,14 +536,17 @@ export default class DashboardController {
             try {
                 const available = await QueueInspector.isAvailable(this.app);
                 this.queueAvailable = available;
-                if (!available)
+                if (!available) {
+                    log.info('dashboard: Queue not detected — Jobs panel disabled');
                     return null;
-                const queue = await this.app.container.make('queue');
+                }
+                const queue = await this.app.container.make('rlanz/queue');
                 this.queueInspector = new QueueInspector(queue);
                 return this.queueInspector;
             }
-            catch {
+            catch (err) {
                 this.queueAvailable = false;
+                log.warn('dashboard: QueueInspector init failed — ' + err?.message);
                 return null;
             }
         }
@@ -736,21 +633,6 @@ function formatTrace(t) {
         createdAt: t.created_at,
     };
 }
-function formatEmail(e) {
-    return {
-        id: e.id,
-        from: e.from_addr,
-        to: e.to_addr,
-        cc: e.cc,
-        bcc: e.bcc,
-        subject: e.subject,
-        mailer: e.mailer,
-        status: e.status,
-        messageId: e.message_id,
-        attachmentCount: e.attachment_count,
-        createdAt: e.created_at,
-    };
-}
 function emptyOverview() {
     return {
         avgResponseTime: 0,