adonisjs-server-stats 1.9.0 → 1.10.3

package/dist/src/dashboard/dashboard_controller.js

@@ -1,126 +1,62 @@
-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 { clamp } from '../utils/math_helpers.js';
+import { handleCacheStats, handleCacheKey, handleCacheKeyDelete } from './cache_handlers.js';
+import { DashboardPageAssets } from './dashboard_page_assets.js';
+import { handleSavedFilters, handleCreateSavedFilter, handleDeleteSavedFilter, } from './filter_handlers.js';
+import { paginatedResponse, emptyPage, emptyOverview, formatRequest, formatQuery, formatTrace, formatLog, mapChartBucket, buildSparklines, formatGroupedQuery, } from './format_helpers.js';
+import { InspectorManager } from './inspector_manager.js';
 import { ConfigInspector } from './integrations/config_inspector.js';
-import { QueueInspector } from './integrations/queue_inspector.js';
+import { handleJobs, handleJobDetail, handleJobRetry } from './jobs_handlers.js';
+import { handleQueryExplain } from './query_explain_handler.js';
 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: [], meta: { total: 0, page, perPage, lastPage: 1 } };
-}
-/**
- * Controller for the full-page dashboard.
- *
- * 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;
     app;
-    cacheInspector = null;
-    queueInspector = null;
     configInspector;
-    cacheAvailable = null;
-    queueAvailable = null;
-    cachedCss = null;
-    cachedJs = null;
-    cachedTransmitClient = null;
+    inspectors;
+    pageAssets;
     constructor(dashboardStore, app) {
         this.dashboardStore = dashboardStore;
         this.app = app;
         this.configInspector = new ConfigInspector(app);
+        this.inspectors = new InspectorManager(app);
+        this.pageAssets = new DashboardPageAssets();
     }
-    // ---------------------------------------------------------------------------
-    // Page
-    // ---------------------------------------------------------------------------
     async page(ctx) {
-        if (!this.checkAccess(ctx)) {
+        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) {
-            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) {
-            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) {
-                log.info('Transmit client loaded for dashboard');
-            }
-            else {
-                log.info('Dashboard will use polling. Install @adonisjs/transmit-client for real-time updates.');
-            }
-        }
-        const dashPath = this.getDashboardPath();
+        const tc = config?.devToolbar ?? {};
+        const renderer = tc.renderer || 'preact';
+        const dp = this.getDashboardPath();
         return ctx.view.render('ss::dashboard', {
-            css: this.cachedCss,
-            js: this.cachedJs,
-            transmitClient: this.cachedTransmitClient,
+            css: this.pageAssets.getCss(),
+            js: this.pageAssets.getJs(renderer),
+            transmitClient: this.pageAssets.getTransmitClient(this.app.makePath('package.json')),
             dashConfig: {
                 baseUrl: '',
-                dashboardEndpoint: dashPath + '/api',
-                debugEndpoint: toolbarConfig.debugEndpoint || '/admin/api/debug',
+                dashboardEndpoint: dp + '/api',
+                debugEndpoint: tc.debugEndpoint || '/admin/api/debug',
                 channelName: 'server-stats/dashboard',
                 backUrl: '/',
             },
         });
     }
-    // ---------------------------------------------------------------------------
-    // Overview
-    // ---------------------------------------------------------------------------
     async overview({ request, response }) {
         return this.withDb(response, 'overview', emptyOverview(), async () => {
             const range = request.qs().range || '1h';
-            // Sequential awaits — with a single-connection SQLite pool, Promise.all
-            // creates concurrent pendingAcquires that thrash tarn's scheduler.
             const overview = await this.dashboardStore.getOverviewMetrics(range);
             if (!overview)
                 return emptyOverview();
             const widgets = await this.dashboardStore.getOverviewWidgets(range);
             const sparklineData = await this.dashboardStore.getSparklineData(range);
-            // Cache and queue inspectors use Redis/BullMQ (not SQLite), so
-            // Promise.all is fine here — different connection pools.
             const [cacheStats, jobQueueStatus] = await Promise.all([
-                this.fetchCacheOverview(),
-                this.fetchQueueOverview(),
+                this.inspectors.fetchCacheOverview(),
+                this.inspectors.fetchQueueOverview(),
             ]);
             return {
                 ...overview,
-                sparklines: {
-                    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),
-                },
+                sparklines: buildSparklines(sparklineData),
                 ...widgets,
                 cacheStats,
                 jobQueueStatus,
@@ -131,22 +67,9 @@ export default class DashboardController {
         const range = request.qs().range || '1h';
         return this.withDb(response, 'overviewChart', { range, buckets: [] }, async () => {
             const buckets = await this.dashboardStore.getChartData(range);
-            return {
-                range,
-                buckets: buckets.map((b) => ({
-                    bucket: b.bucket,
-                    requestCount: b.request_count,
-                    avgDuration: b.avg_duration,
-                    p95Duration: b.p95_duration,
-                    errorCount: b.error_count,
-                    queryCount: b.query_count,
-                })),
-            };
+            return { range, buckets: buckets.map(mapChartBucket) };
         });
     }
-    // ---------------------------------------------------------------------------
-    // Requests
-    // ---------------------------------------------------------------------------
     async requests({ request, response }) {
         const qs = request.qs();
         const page = Math.max(1, Number(qs.page) || 1);
@@ -162,9 +85,8 @@ export default class DashboardController {
         });
     }
     async requestDetail({ params, response }) {
-        if (!this.dashboardStore.isReady()) {
+        if (!this.dashboardStore.isReady())
             return response.notFound({ error: 'Not found' });
-        }
         try {
             const detail = await this.dashboardStore.getRequestDetail(Number(params.id));
             if (!detail)
@@ -173,6 +95,7 @@ export default class DashboardController {
                 ...formatRequest(detail),
                 queries: (detail.queries || []).map(formatQuery),
                 trace: detail.trace ? formatTrace(detail.trace) : null,
+                logs: (detail.logs || []).map(formatLog),
             });
         }
         catch {
@@ -183,301 +106,49 @@ export default class DashboardController {
         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 search = qs.search || undefined;
-            const groups = await this.dashboardStore.getQueriesGrouped(limit, sort, search);
+            const groups = await this.dashboardStore.getQueriesGrouped(limit, qs.sort || 'total_duration', qs.search || undefined);
             const totalTime = groups.reduce((sum, g) => sum + (g.total_duration || 0), 0);
             return {
-                groups: groups.map((g) => ({
-                    sqlNormalized: g.sql_normalized,
-                    count: g.count,
-                    avgDuration: round(g.avg_duration),
-                    minDuration: round(g.min_duration),
-                    maxDuration: round(g.max_duration),
-                    totalDuration: round(g.total_duration),
-                    percentOfTotal: totalTime > 0 ? round((g.total_duration / totalTime) * 100) : 0,
-                })),
+                groups: groups.map((g) => formatGroupedQuery(g, totalTime)),
             };
         });
     }
-    async queryExplain({ params, response }) {
-        if (!this.dashboardStore.isReady()) {
-            return response.notFound({ error: 'Not found' });
-        }
-        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();
-            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',
-                });
-            }
-            let appDb;
-            try {
-                const lucid = await this.app.container.make('lucid.db');
-                appDb = lucid
-                    .connection()
-                    .getWriteClient();
-            }
-            catch {
-                return response.serviceUnavailable({
-                    error: 'App database connection not available',
-                });
-            }
-            let bindings = [];
-            if (query.bindings) {
-                try {
-                    bindings = JSON.parse(query.bindings);
-                }
-                catch {
-                    // If bindings can't be parsed, run without them
-                }
-            }
-            const explainResult = await appDb.raw(`EXPLAIN (FORMAT JSON) ${query.sql_text}`, bindings);
-            let plan = [];
-            const rawRows = explainResult?.rows ??
-                (Array.isArray(explainResult) ? explainResult : []);
-            if (rawRows.length > 0 && rawRows[0]['QUERY PLAN']) {
-                plan = rawRows[0]['QUERY PLAN'];
-            }
-            else {
-                plan = rawRows;
-            }
-            return response.json({ queryId: id, sql: query.sql_text, plan });
-        }
-        catch (error) {
-            return response.internalServerError({
-                error: 'EXPLAIN failed',
-                message: error?.message ?? 'Unknown error',
-            });
-        }
+    async queryExplain(ctx) {
+        return handleQueryExplain(this.dashboardStore, this.app, ctx);
     }
-    // ---------------------------------------------------------------------------
-    // Cache
-    // ---------------------------------------------------------------------------
-    async cacheStats({ request, response }) {
-        const inspector = await this.getInspector('cache');
-        if (!inspector) {
-            return response.json({ available: false, stats: null, keys: [] });
-        }
-        const qs = request.qs();
-        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 {
-            const [stats, keyList] = await Promise.all([
-                inspector.getStats(),
-                inspector.listKeys(pattern, cursor, count),
-            ]);
-            return response.json({
-                available: true,
-                stats,
-                keys: keyList.keys,
-                cursor: keyList.cursor,
-            });
-        }
-        catch {
-            return response.json({ available: false, stats: null, keys: [] });
-        }
+    async cacheStats(ctx) {
+        return handleCacheStats(this.inspectors, ctx);
     }
-    async cacheKey({ params, response }) {
-        const inspector = await this.getInspector('cache');
-        if (!inspector) {
-            return response.notFound({ error: 'Cache not available' });
-        }
-        try {
-            const key = decodeURIComponent(params.key);
-            const detail = await inspector.getKey(key);
-            if (!detail)
-                return response.notFound({ error: 'Key not found' });
-            return response.json(detail);
-        }
-        catch {
-            return response.notFound({ error: 'Key not found' });
-        }
+    async cacheKey(ctx) {
+        return handleCacheKey(this.inspectors, ctx);
     }
-    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' });
-        }
+    async cacheKeyDelete(ctx) {
+        return handleCacheKeyDelete(this.inspectors, ctx);
     }
-    // ---------------------------------------------------------------------------
-    // Jobs / Queue
-    // ---------------------------------------------------------------------------
-    async jobs({ request, response }) {
-        const inspector = await this.getInspector('queue');
-        if (!inspector) {
-            return response.json({
-                available: false,
-                overview: null,
-                stats: null,
-                jobs: [],
-                total: 0,
-            });
-        }
-        const qs = request.qs();
-        const status = qs.status || 'all';
-        const searchTerm = qs.search || '';
-        const page = Math.max(1, Number(qs.page) || 1);
-        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,
-                stats: overview,
-                jobs: filteredJobs,
-                total: filteredTotal,
-                page,
-                perPage,
-            });
-        }
-        catch {
-            return response.json({
-                available: false,
-                overview: null,
-                stats: null,
-                jobs: [],
-                total: 0,
-            });
-        }
+    async jobs(ctx) {
+        return handleJobs(this.inspectors, ctx);
     }
-    async jobDetail({ params, response }) {
-        const inspector = await this.getInspector('queue');
-        if (!inspector) {
-            return response.notFound({ error: 'Queue not available' });
-        }
-        try {
-            const detail = await inspector.getJob(String(params.id));
-            if (!detail)
-                return response.notFound({ error: 'Job not found' });
-            return response.json(detail);
-        }
-        catch {
-            return response.notFound({ error: 'Job not found' });
-        }
+    async jobDetail(ctx) {
+        return handleJobDetail(this.inspectors, ctx);
     }
-    async jobRetry({ params, response }) {
-        const inspector = await this.getInspector('queue');
-        if (!inspector) {
-            return response.notFound({ error: 'Queue not available' });
-        }
-        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.json({ success: true });
-        }
-        catch {
-            return response.internalServerError({ error: 'Retry failed' });
-        }
+    async jobRetry(ctx) {
+        return handleJobRetry(this.inspectors, ctx);
     }
-    // ---------------------------------------------------------------------------
-    // Config
-    // ---------------------------------------------------------------------------
     async config({ response }) {
-        const configData = this.configInspector.getConfig();
-        const envData = this.configInspector.getEnvVars();
         return response.json({
-            app: configData.config,
-            env: envData.env,
+            app: this.configInspector.getConfig().config,
+            env: this.configInspector.getEnvVars().env,
         });
     }
-    // ---------------------------------------------------------------------------
-    // Saved Filters
-    // ---------------------------------------------------------------------------
     async savedFilters({ response }) {
-        return this.withDb(response, 'savedFilters', { filters: [] }, async () => {
-            const filters = await this.dashboardStore.getSavedFilters();
-            return {
-                filters: filters.map((f) => ({
-                    id: f.id,
-                    name: f.name,
-                    section: f.section,
-                    filterConfig: safeParseJson(f.filter_config),
-                    createdAt: f.created_at,
-                })),
-            };
-        });
+        return this.withDb(response, 'savedFilters', { filters: [] }, () => handleSavedFilters(this.dashboardStore));
     }
-    async createSavedFilter({ request, response }) {
-        if (!this.dashboardStore.isReady()) {
-            return response.serviceUnavailable({ error: 'Database not available' });
-        }
-        try {
-            const body = request.body();
-            const { name, section, filterConfig } = body;
-            if (!name || !section || !filterConfig) {
-                return response.badRequest({
-                    error: 'Missing required fields: name, section, 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' });
-        }
+    async createSavedFilter(ctx) {
+        return handleCreateSavedFilter(this.dashboardStore, ctx);
     }
-    async deleteSavedFilter({ params, response }) {
-        if (!this.dashboardStore.isReady()) {
-            return response.serviceUnavailable({ error: 'Database not available' });
-        }
-        try {
-            const deleted = await this.dashboardStore.deleteSavedFilter(Number(params.id));
-            if (!deleted)
-                return response.notFound({ error: 'Filter not found' });
-            return response.json({ success: true });
-        }
-        catch {
-            return response.internalServerError({ error: 'Failed to delete filter' });
-        }
+    async deleteSavedFilter(ctx) {
+        return handleDeleteSavedFilter(this.dashboardStore, ctx);
     }
-    // ---------------------------------------------------------------------------
-    // Private helpers
-    // ---------------------------------------------------------------------------
-    /**
-     * 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, label, emptyValue, fn) {
         if (!this.dashboardStore.isReady())
             return response.json(emptyValue);
@@ -504,158 +175,7 @@ export default class DashboardController {
         }
     }
     getDashboardPath() {
-        const config = this.app.config.get('server_stats');
-        return config?.devToolbar?.dashboardPath ?? '/__stats';
-    }
-    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) {
-                    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 (err) {
-                this.cacheAvailable = false;
-                log.warn('dashboard: CacheInspector init failed — ' + err?.message);
-                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) {
-                    log.info('dashboard: Queue not detected — Jobs panel disabled');
-                    return null;
-                }
-                const queue = await this.app.container.make('rlanz/queue');
-                this.queueInspector = new QueueInspector(queue);
-                return this.queueInspector;
-            }
-            catch (err) {
-                this.queueAvailable = false;
-                log.warn('dashboard: QueueInspector init failed — ' + err?.message);
-                return null;
-            }
-        }
-    }
-    /** Fetch cache overview stats for the overview page. */
-    async fetchCacheOverview() {
-        try {
-            const inspector = await this.getInspector('cache');
-            if (!inspector)
-                return null;
-            const stats = await inspector.getStats();
-            return {
-                available: true,
-                totalKeys: stats.totalKeys,
-                hitRate: stats.hitRate,
-                memoryUsedHuman: stats.memoryUsedHuman,
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    /** Fetch queue overview stats for the overview page. */
-    async fetchQueueOverview() {
-        try {
-            const inspector = await this.getInspector('queue');
-            if (!inspector)
-                return null;
-            const overview = await inspector.getOverview();
-            return {
-                available: true,
-                active: overview.active,
-                waiting: overview.waiting,
-                failed: overview.failed,
-                completed: overview.completed,
-            };
-        }
-        catch {
-            return null;
-        }
+        return (this.app.config.get('server_stats')?.devToolbar?.dashboardPath ??
+            '/__stats');
     }
 }
-// ---------------------------------------------------------------------------
-// Formatting helpers (snake_case DB rows → camelCase API response)
-// ---------------------------------------------------------------------------
-function formatRequest(r) {
-    return {
-        id: r.id,
-        method: r.method,
-        url: r.url,
-        statusCode: r.status_code,
-        duration: r.duration,
-        spanCount: r.span_count,
-        warningCount: r.warning_count,
-        createdAt: r.created_at,
-    };
-}
-function formatQuery(q) {
-    return {
-        id: q.id,
-        requestId: q.request_id,
-        sql: q.sql_text,
-        sqlNormalized: q.sql_normalized,
-        bindings: safeParseJson(q.bindings),
-        duration: q.duration,
-        method: q.method,
-        model: q.model,
-        connection: q.connection,
-        inTransaction: !!q.in_transaction,
-        createdAt: q.created_at,
-    };
-}
-function formatTrace(t) {
-    return {
-        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,
-        spans: safeParseJson(t.spans) ?? [],
-        warnings: safeParseJsonArray(t.warnings),
-        createdAt: t.created_at,
-    };
-}
-function emptyOverview() {
-    return {
-        avgResponseTime: 0,
-        p95ResponseTime: 0,
-        requestsPerMinute: 0,
-        errorRate: 0,
-        sparklines: {
-            avgResponseTime: [],
-            p95ResponseTime: [],
-            requestsPerMinute: [],
-            errorRate: [],
-        },
-        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,
-    };
-}