adonisjs-server-stats 1.10.0 → 1.11.0

package/dist/src/provider/shutdown_helpers.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shutdown helper functions extracted from ServerStatsProvider.
+ */
+/** Timer references that need to be cleared on shutdown. */
+export interface TimerRefs {
+    intervalId: ReturnType<typeof setInterval> | null;
+    flushTimer: ReturnType<typeof setInterval> | null;
+    dashboardBroadcastTimer: ReturnType<typeof setInterval> | null;
+    debugBroadcastTimer: ReturnType<typeof setTimeout> | null;
+}
+/**
+ * Clear all active timers and null out the references.
+ * Returns the (now-nulled) timer refs for convenience.
+ */
+export declare function clearAllTimers(timers: TimerRefs): TimerRefs;
+/** Minimal interface for debug store persistence. */
+interface Persistable {
+    saveToDisk(path: string): Promise<void>;
+}
+/**
+ * Persist debug data to disk. Logs a warning on failure.
+ */
+export declare function persistDebugData(store: Persistable | null, path: string | null): Promise<void>;
+/**
+ * Unsubscribe from the Redis email bridge channel.
+ * Returns null so callers can clear their reference in one step.
+ */
+export declare function unsubscribeEmailBridge(redis: unknown, channel: string): null;
+/** Stoppable service interface. */
+interface Stoppable {
+    stop(): void | Promise<void>;
+}
+/**
+ * Clean up log stream, dashboard, and middleware resources.
+ */
+export declare function cleanupResources(deps: {
+    logStreamService: Stoppable | null;
+    dashboardLogStream: Stoppable | null;
+    dashboardStore: Stoppable | null;
+    debugStore: Stoppable | null;
+    engine: Stoppable | null;
+}): Promise<void>;
+export {};

package/dist/src/provider/shutdown_helpers.js

@@ -0,0 +1,70 @@
+/**
+ * Shutdown helper functions extracted from ServerStatsProvider.
+ */
+import { setOnRequestComplete, setDashboardPath, setExcludedPrefixes, } from '../middleware/request_tracking_middleware.js';
+import { log } from '../utils/logger.js';
+/**
+ * Clear all active timers and null out the references.
+ * Returns the (now-nulled) timer refs for convenience.
+ */
+export function clearAllTimers(timers) {
+    if (timers.intervalId) {
+        clearInterval(timers.intervalId);
+        timers.intervalId = null;
+    }
+    if (timers.flushTimer) {
+        clearInterval(timers.flushTimer);
+        timers.flushTimer = null;
+    }
+    if (timers.dashboardBroadcastTimer) {
+        clearInterval(timers.dashboardBroadcastTimer);
+        timers.dashboardBroadcastTimer = null;
+    }
+    if (timers.debugBroadcastTimer) {
+        clearTimeout(timers.debugBroadcastTimer);
+        timers.debugBroadcastTimer = null;
+    }
+    return timers;
+}
+/**
+ * Persist debug data to disk. Logs a warning on failure.
+ */
+export async function persistDebugData(store, path) {
+    if (!path || !store)
+        return;
+    try {
+        await store.saveToDisk(path);
+    }
+    catch (err) {
+        log.warn('could not save debug data on shutdown — ' + err?.message);
+    }
+}
+/**
+ * Unsubscribe from the Redis email bridge channel.
+ * Returns null so callers can clear their reference in one step.
+ */
+export function unsubscribeEmailBridge(redis, channel) {
+    if (!redis)
+        return null;
+    try {
+        ;
+        redis.unsubscribe(channel);
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+    return null;
+}
+/**
+ * Clean up log stream, dashboard, and middleware resources.
+ */
+export async function cleanupResources(deps) {
+    deps.logStreamService?.stop();
+    deps.dashboardLogStream?.stop();
+    setOnRequestComplete(null);
+    setDashboardPath(null);
+    setExcludedPrefixes([]);
+    await deps.dashboardStore?.stop();
+    deps.debugStore?.stop();
+    await deps.engine?.stop();
+}

package/dist/src/provider/toolbar_setup.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Dev toolbar and dashboard setup helpers extracted from provider.
+ */
+import type DebugController from '../controller/debug_controller.js';
+import type DashboardController from '../dashboard/dashboard_controller.js';
+import type { DashboardStore } from '../dashboard/dashboard_store.js';
+import type { DebugStore } from '../debug/debug_store.js';
+import type { DevToolbarConfig } from '../debug/types.js';
+import type { StatsEngine } from '../engine/stats_engine.js';
+import type { LogStreamService } from '../log_stream/log_stream_service.js';
+import type { ResolvedServerStatsConfig } from '../types.js';
+import type { ApplicationService } from '@adonisjs/core/types';
+export { initDashboardStore } from './dashboard_init.js';
+export interface ToolbarCoreResult {
+    debugStore: DebugStore;
+    debugController: DebugController;
+    persistPath: string | null;
+    flushTimer: ReturnType<typeof setInterval> | null;
+    debugBroadcastTimer: ReturnType<typeof setTimeout> | null;
+    transmitAvailable: boolean;
+    transmitChannels: string[];
+    dashboardStore: DashboardStore | null;
+    dashboardController: DashboardController | null;
+    dashboardLogStream: LogStreamService | null;
+    dashboardBroadcastTimer: ReturnType<typeof setInterval> | null;
+    emailBridgeRedis: unknown;
+    emitter: unknown;
+}
+interface ToolbarCoreOptions {
+    tc: DevToolbarConfig;
+    config: ResolvedServerStatsConfig;
+    app: ApplicationService;
+    resolve: (binding: string) => Promise<unknown>;
+    getDiagnostics: () => unknown;
+}
+/** Core dev toolbar setup: debug store, controllers, broadcasting, dashboard. */
+export declare function setupDevToolbarCore(opts: ToolbarCoreOptions): Promise<ToolbarCoreResult | null>;
+export interface ProviderFields {
+    debugStore: DebugStore | null;
+    debugController: DebugController | null;
+    persistPath: string | null;
+    flushTimer: ReturnType<typeof setInterval> | null;
+    debugBroadcastTimer: ReturnType<typeof setTimeout> | null;
+    transmitAvailable: boolean;
+    transmitChannels: string[];
+    dashboardStore: DashboardStore | null;
+    dashboardController: DashboardController | null;
+    dashboardLogStream: LogStreamService | null;
+    dashboardBroadcastTimer: ReturnType<typeof setInterval> | null;
+    emailBridgeRedis: unknown;
+    dashboardDepsAvailable: boolean;
+    engine: StatsEngine | null;
+    pinoHookActive: boolean;
+    app: ApplicationService;
+}
+/** Apply the toolbar core result back onto the provider instance. */
+export declare function applyToolbarResult(result: ToolbarCoreResult, tc: DevToolbarConfig, provider: ProviderFields): void;

package/dist/src/provider/toolbar_setup.js

@@ -0,0 +1,141 @@
+/**
+ * Dev toolbar and dashboard setup helpers extracted from provider.
+ */
+import { setTraceCollector } from '../middleware/request_tracking_middleware.js';
+import { log } from '../utils/logger.js';
+import { initDashboardStore } from './dashboard_init.js';
+import { setupFullEmailBridge } from './email_bridge.js';
+export { initDashboardStore } from './dashboard_init.js';
+/** Core dev toolbar setup: debug store, controllers, broadcasting, dashboard. */
+export async function setupDevToolbarCore(opts) {
+    const { tc, config, app, resolve, getDiagnostics } = opts;
+    const { DebugStore: DS } = await import('../debug/debug_store.js');
+    const debugStore = new DS(tc);
+    const container = app.container;
+    container.singleton('debug.store', () => debugStore);
+    const persistPath = await loadPersistedData(tc, app, debugStore);
+    const em = await resolve('emitter');
+    if (!em)
+        log.warn('emitter not available — query/event collection disabled');
+    await debugStore.start(em, await resolve('router'));
+    const emailBridgeRedis = await setupBridgeInternal(em, debugStore);
+    const debugController = await createDebugController(debugStore, config, getDiagnostics, app);
+    if (debugStore.traces)
+        setTraceCollector(debugStore.traces);
+    const flushTimer = persistPath ? createFlushTimer(debugStore, persistPath) : null;
+    const broadcast = await setupDebugBroadcastInternal(debugStore, resolve);
+    return {
+        debugStore,
+        debugController,
+        persistPath,
+        flushTimer,
+        debugBroadcastTimer: broadcast.timer,
+        transmitAvailable: broadcast.transmitAvailable,
+        transmitChannels: broadcast.channels,
+        dashboardStore: null,
+        dashboardController: null,
+        dashboardLogStream: null,
+        dashboardBroadcastTimer: null,
+        emailBridgeRedis,
+        emitter: em,
+    };
+}
+async function loadPersistedData(tc, app, debugStore) {
+    if (!tc.persistDebugData)
+        return null;
+    const path = typeof tc.persistDebugData === 'string'
+        ? app.makePath(tc.persistDebugData)
+        : app.makePath('.adonisjs', 'server-stats', 'debug-data.json');
+    await debugStore.loadFromDisk(path);
+    return path;
+}
+async function createDebugController(debugStore, config, getDiagnostics, app) {
+    const DC = (await import('../controller/debug_controller.js')).default;
+    return new DC(debugStore, config, {
+        getEngine: () => null,
+        getDashboardStore: () => null,
+        getProviderDiagnostics: getDiagnostics,
+        getApp: () => app,
+    });
+}
+function createFlushTimer(debugStore, persistPath) {
+    return setInterval(async () => {
+        try {
+            await debugStore.saveToDisk(persistPath);
+        }
+        catch { }
+    }, 30_000);
+}
+async function setupBridgeInternal(emitter, debugStore) {
+    if (!emitter)
+        return null;
+    try {
+        const { appImport } = await import('../utils/app_import.js');
+        const mod = await appImport('@adonisjs/redis/services/main');
+        const redis = mod.default;
+        return await setupFullEmailBridge(emitter, redis, 'adonisjs-server-stats:emails', { debugEmails: debugStore.emails ?? null, dashboardStore: null });
+    }
+    catch {
+        return null;
+    }
+}
+async function setupDebugBroadcastInternal(debugStore, resolve) {
+    const t = await resolve('transmit');
+    if (!t)
+        return { timer: null, transmitAvailable: false, channels: [] };
+    const ch = 'server-stats/debug';
+    const pending = new Set();
+    let timer = null;
+    debugStore.onNewItem((type) => {
+        pending.add(type);
+        if (timer)
+            return;
+        timer = setTimeout(() => {
+            timer = null;
+            const ts = [...pending];
+            pending.clear();
+            try {
+                ;
+                t.broadcast(ch, { types: ts });
+            }
+            catch { }
+        }, 200);
+    });
+    return { timer: null, transmitAvailable: true, channels: [ch] };
+}
+/** Apply the toolbar core result back onto the provider instance. */
+export function applyToolbarResult(result, tc, provider) {
+    provider.debugStore = result.debugStore;
+    provider.debugController = result.debugController;
+    provider.persistPath = result.persistPath;
+    provider.flushTimer = result.flushTimer;
+    provider.debugBroadcastTimer = result.debugBroadcastTimer;
+    if (result.transmitAvailable)
+        provider.transmitAvailable = true;
+    for (const ch of result.transmitChannels) {
+        if (!provider.transmitChannels.includes(ch))
+            provider.transmitChannels.push(ch);
+    }
+    provider.emailBridgeRedis = result.emailBridgeRedis;
+    if (!tc.dashboard || !provider.dashboardDepsAvailable)
+        return;
+    setImmediate(() => {
+        initDashboardStore({
+            tc,
+            emitter: result.emitter,
+            app: provider.app,
+            debugStore: result.debugStore,
+            engine: provider.engine,
+            pinoHookActive: provider.pinoHookActive,
+            transmitChannels: provider.transmitChannels,
+            onResult: (r) => {
+                provider.dashboardStore = r.dashboardStore;
+                provider.dashboardController = r.dashboardController;
+                provider.dashboardLogStream = r.dashboardLogStream;
+                provider.dashboardBroadcastTimer = r.dashboardBroadcastTimer;
+            },
+        }).catch((e) => {
+            log.warn(`dashboard setup failed: ${e?.message ?? e}`);
+        });
+    });
+}

package/dist/src/routes/dashboard_routes.d.ts

@@ -0,0 +1,14 @@
+import type { ApiController } from '../controller/api_controller.js';
+import type DashboardController from '../dashboard/dashboard_controller.js';
+import type { AdonisRouter } from './router_types.js';
+import type { HttpContext } from '@adonisjs/core/http';
+interface DashboardRoutesOpts {
+    router: AdonisRouter;
+    dashboardPath: string;
+    getDashboardController: () => DashboardController | null;
+    getApiController: () => ApiController | null;
+    middleware: Array<(ctx: HttpContext, next: () => Promise<void>) => Promise<void>>;
+}
+/** Register dashboard routes. */
+export declare function registerDashboardRoutes(opts: DashboardRoutesOpts): void;
+export {};

package/dist/src/routes/dashboard_routes.js

@@ -0,0 +1,197 @@
+function bindDash(getController, method) {
+    return async (ctx) => {
+        const controller = getController();
+        if (!controller)
+            return ctx.response.serviceUnavailable({ error: 'Dashboard is starting up, please retry' });
+        return controller[method].call(controller, ctx);
+    };
+}
+function bindApi(getApi, fn) {
+    return async (ctx) => {
+        const api = getApi();
+        if (!api)
+            return ctx.response.serviceUnavailable({ error: 'Dashboard is starting up, please retry' });
+        return fn(api, ctx);
+    };
+}
+function registerQueryRoutes(router, getApi) {
+    router
+        .get('/api/queries', bindApi(getApi, async (api, ctx) => {
+        const qs = ctx.request.qs();
+        return ctx.response.json(await api.getQueries({
+            page: Number(qs.page) || 1,
+            perPage: Number(qs.perPage) || 25,
+            search: qs.search || undefined,
+            filters: {
+                durationMin: qs.duration_min ? Number(qs.duration_min) : undefined,
+                model: qs.model || undefined,
+                method: qs.method || undefined,
+                connection: qs.connection || undefined,
+            },
+        }));
+    }))
+        .as('server-stats.queries');
+}
+function registerEventRoutes(router, getApi) {
+    router
+        .get('/api/events', bindApi(getApi, async (api, ctx) => {
+        const qs = ctx.request.qs();
+        return ctx.response.json(await api.getEvents({
+            page: Number(qs.page) || 1,
+            perPage: Number(qs.perPage) || 25,
+            search: qs.search || undefined,
+            filters: { eventName: qs.event_name || undefined },
+        }));
+    }))
+        .as('server-stats.events');
+}
+function registerRouteApiRoutes(router, getApi) {
+    router
+        .get('/api/routes', bindApi(getApi, (api, ctx) => ctx.response.json(api.getRoutes(ctx.request.qs().search || undefined))))
+        .as('server-stats.routes');
+}
+function registerLogRoutes(router, getApi) {
+    router
+        .get('/api/logs', bindApi(getApi, async (api, ctx) => {
+        const qs = ctx.request.qs();
+        return ctx.response.json(await api.getLogs({
+            page: Number(qs.page) || 1,
+            perPage: Number(qs.perPage) || 50,
+            search: qs.message || qs.search || undefined,
+            filters: {
+                level: qs.level || undefined,
+                requestId: qs.request_id || qs.requestId || undefined,
+            },
+        }));
+    }))
+        .as('server-stats.logs');
+}
+function registerEmailRoutes(router, getApi) {
+    router
+        .get('/api/emails', bindApi(getApi, async (api, ctx) => {
+        const qs = ctx.request.qs();
+        return ctx.response.json(await api.getEmails({
+            page: Number(qs.page) || 1,
+            perPage: Number(qs.perPage) || 25,
+            search: qs.search || undefined,
+            filters: {
+                from: qs.from || undefined,
+                to: qs.to || undefined,
+                subject: qs.subject || undefined,
+                status: qs.status || undefined,
+                mailer: qs.mailer || undefined,
+            },
+        }));
+    }))
+        .as('server-stats.emails');
+    router
+        .get('/api/emails/:id/preview', bindApi(getApi, async (api, ctx) => {
+        const html = await api.getEmailPreview(Number(ctx.params.id));
+        if (!html)
+            return ctx.response.notFound({ error: 'Email not found' });
+        return ctx.response.header('Content-Type', 'text/html; charset=utf-8').send(html);
+    }))
+        .as('server-stats.emails.preview');
+}
+function registerTraceRoutes(router, getApi) {
+    router
+        .get('/api/traces', bindApi(getApi, async (api, ctx) => {
+        const qs = ctx.request.qs();
+        return ctx.response.json(await api.getTraces({
+            page: Number(qs.page) || 1,
+            perPage: Number(qs.perPage) || 25,
+            search: qs.search || undefined,
+            filters: {
+                method: qs.method ? qs.method.toUpperCase() : undefined,
+                url: qs.url || undefined,
+                statusMin: qs.status_min ? Number(qs.status_min) : undefined,
+                statusMax: qs.status_max ? Number(qs.status_max) : undefined,
+            },
+        }));
+    }))
+        .as('server-stats.traces');
+    router
+        .get('/api/traces/:id', bindApi(getApi, async (api, ctx) => {
+        const trace = await api.getTraceDetail(Number(ctx.params.id));
+        if (!trace)
+            return ctx.response.notFound({ error: 'Trace not found' });
+        return ctx.response.json(trace);
+    }))
+        .as('server-stats.traces.show');
+}
+function registerDashboardPageRoutes(router, getDashboardController) {
+    router.get('/', bindDash(getDashboardController, 'page')).as('server-stats.dashboard');
+    router
+        .get('/api/overview', bindDash(getDashboardController, 'overview'))
+        .as('server-stats.overview');
+    router
+        .get('/api/overview/chart', bindDash(getDashboardController, 'overviewChart'))
+        .as('server-stats.overview.chart');
+    router
+        .get('/api/requests', bindDash(getDashboardController, 'requests'))
+        .as('server-stats.requests');
+    router
+        .get('/api/requests/:id', bindDash(getDashboardController, 'requestDetail'))
+        .as('server-stats.requests.show');
+}
+function registerQueryDashboardRoutes(router, getDashboardController) {
+    router
+        .get('/api/queries/grouped', bindDash(getDashboardController, 'queriesGrouped'))
+        .as('server-stats.queries.grouped');
+    router
+        .get('/api/queries/:id/explain', bindDash(getDashboardController, 'queryExplain'))
+        .as('server-stats.queries.explain');
+}
+function registerCacheRoutes(router, getDashboardController) {
+    router.get('/api/cache', bindDash(getDashboardController, 'cacheStats')).as('server-stats.cache');
+    router
+        .get('/api/cache/:key', bindDash(getDashboardController, 'cacheKey'))
+        .as('server-stats.cache.show')
+        .where('key', /.*/);
+    router
+        .delete('/api/cache/:key', bindDash(getDashboardController, 'cacheKeyDelete'))
+        .as('server-stats.cache.delete')
+        .where('key', /.*/);
+}
+function registerJobRoutes(router, getDashboardController) {
+    router.get('/api/jobs', bindDash(getDashboardController, 'jobs')).as('server-stats.jobs');
+    router
+        .get('/api/jobs/:id', bindDash(getDashboardController, 'jobDetail'))
+        .as('server-stats.jobs.show');
+    router
+        .post('/api/jobs/:id/retry', bindDash(getDashboardController, 'jobRetry'))
+        .as('server-stats.jobs.retry');
+}
+function registerConfigAndFilterRoutes(router, getDashboardController) {
+    router.get('/api/config', bindDash(getDashboardController, 'config')).as('server-stats.config');
+    router
+        .get('/api/filters', bindDash(getDashboardController, 'savedFilters'))
+        .as('server-stats.filters');
+    router
+        .post('/api/filters', bindDash(getDashboardController, 'createSavedFilter'))
+        .as('server-stats.filters.create');
+    router
+        .delete('/api/filters/:id', bindDash(getDashboardController, 'deleteSavedFilter'))
+        .as('server-stats.filters.delete');
+}
+/** Register dashboard routes. */
+export function registerDashboardRoutes(opts) {
+    const { router, dashboardPath, getDashboardController, getApiController, middleware } = opts;
+    const base = dashboardPath.replace(/\/+$/, '');
+    router
+        .group(() => {
+        registerDashboardPageRoutes(router, getDashboardController);
+        registerQueryRoutes(router, getApiController);
+        registerEventRoutes(router, getApiController);
+        registerRouteApiRoutes(router, getApiController);
+        registerLogRoutes(router, getApiController);
+        registerEmailRoutes(router, getApiController);
+        registerTraceRoutes(router, getApiController);
+        registerQueryDashboardRoutes(router, getDashboardController);
+        registerCacheRoutes(router, getDashboardController);
+        registerJobRoutes(router, getDashboardController);
+        registerConfigAndFilterRoutes(router, getDashboardController);
+    })
+        .prefix(base)
+        .use(middleware);
+}

package/dist/src/routes/debug_routes.d.ts

@@ -0,0 +1,14 @@
+import type { ApiController } from '../controller/api_controller.js';
+import type DebugController from '../controller/debug_controller.js';
+import type { AdonisRouter } from './router_types.js';
+import type { HttpContext } from '@adonisjs/core/http';
+interface DebugRoutesOpts {
+    router: AdonisRouter;
+    debugEndpoint: string;
+    getDebugController: () => DebugController | null;
+    getApiController: () => ApiController | null;
+    middleware: Array<(ctx: HttpContext, next: () => Promise<void>) => Promise<void>>;
+}
+/** Register debug panel API routes. */
+export declare function registerDebugRoutes(opts: DebugRoutesOpts): void;
+export {};

package/dist/src/routes/debug_routes.js

@@ -0,0 +1,101 @@
+function bindDebug(getController, method) {
+    return async (ctx) => {
+        const controller = getController();
+        if (!controller)
+            return ctx.response.serviceUnavailable({
+                error: 'Debug toolbar is starting up, please retry',
+            });
+        return controller[method].call(controller, ctx);
+    };
+}
+function bindApi(getApi, fn) {
+    return async (ctx) => {
+        const api = getApi();
+        if (!api)
+            return ctx.response.serviceUnavailable({
+                error: 'Debug toolbar is starting up, please retry',
+            });
+        return fn(api, ctx);
+    };
+}
+function registerDebugConfigRoutes(router, getDebugController) {
+    router.get('/config', bindDebug(getDebugController, 'config')).as('server-stats.debug.config');
+    router
+        .get('/diagnostics', bindDebug(getDebugController, 'diagnostics'))
+        .as('server-stats.debug.diagnostics');
+}
+function registerDebugQueryAndEventRoutes(router, getApiController) {
+    router
+        .get('/queries', bindApi(getApiController, async (api, ctx) => {
+        const queries = await api.getQueries({ source: 'memory' });
+        return ctx.response.json({ queries: queries.data, summary: api.getQuerySummary() });
+    }))
+        .as('server-stats.debug.queries');
+    router
+        .get('/events', bindApi(getApiController, async (api, ctx) => {
+        const result = await api.getEvents({ source: 'memory' });
+        return ctx.response.json({ events: result.data, total: result.meta.total });
+    }))
+        .as('server-stats.debug.events');
+    router
+        .get('/routes', bindApi(getApiController, (api, ctx) => {
+        const result = api.getRoutes();
+        return ctx.response.json({ routes: result.data, total: result.meta.total });
+    }))
+        .as('server-stats.debug.routes');
+}
+function registerDebugLogRoutes(router, getApiController) {
+    router
+        .get('/logs', bindApi(getApiController, async (api, ctx) => {
+        const result = await api.getLogs({ source: 'auto', perPage: 200 });
+        return ctx.response.json(result.data);
+    }))
+        .as('server-stats.debug.logs');
+}
+function registerDebugEmailRoutes(router, getApiController) {
+    router
+        .get('/emails', bindApi(getApiController, async (api, ctx) => {
+        const result = await api.getEmails({});
+        return ctx.response.json({ emails: result.data, total: result.meta.total });
+    }))
+        .as('server-stats.debug.emails');
+    router
+        .get('/emails/:id/preview', bindApi(getApiController, async (api, ctx) => {
+        const html = await api.getEmailPreview(Number(ctx.params.id));
+        if (!html)
+            return ctx.response.notFound({ error: 'Email not found' });
+        return ctx.response.header('Content-Type', 'text/html; charset=utf-8').send(html);
+    }))
+        .as('server-stats.debug.emailPreview');
+}
+function registerDebugTraceRoutes(router, getApiController) {
+    router
+        .get('/traces', bindApi(getApiController, async (api, ctx) => {
+        const result = await api.getTraces({ source: 'memory' });
+        return ctx.response.json({ traces: result.data, total: result.meta.total });
+    }))
+        .as('server-stats.debug.traces');
+    router
+        .get('/traces/:id', bindApi(getApiController, async (api, ctx) => {
+        const trace = await api.getTraceDetail(Number(ctx.params.id), 'memory');
+        if (!trace)
+            return ctx.response.notFound({ error: 'Trace not found' });
+        return ctx.response.json(trace);
+    }))
+        .as('server-stats.debug.traceDetail');
+}
+/** Register debug panel API routes. */
+export function registerDebugRoutes(opts) {
+    const { router, debugEndpoint, getDebugController, getApiController, middleware } = opts;
+    const base = debugEndpoint.replace(/\/+$/, '');
+    router
+        .group(() => {
+        registerDebugConfigRoutes(router, getDebugController);
+        registerDebugQueryAndEventRoutes(router, getApiController);
+        registerDebugLogRoutes(router, getApiController);
+        registerDebugEmailRoutes(router, getApiController);
+        registerDebugTraceRoutes(router, getApiController);
+    })
+        .prefix(base)
+        .use(middleware);
+}