adonisjs-server-stats 1.12.3 → 1.14.0

package/dist/react/index.js

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

package/dist/react/useApiClient-CtEG7rHs.js

@@ -0,0 +1,11 @@
+import { useRef as t, useEffect as u, useCallback as c } from "react";
+import { ApiClient as i } from "adonisjs-server-stats/core";
+function o(e = "", n) {
+  const r = t(null);
+  return u(() => {
+    r.current = null;
+  }, [e, n]), c(() => (r.current || (r.current = new i({ baseUrl: e, authToken: n })), r.current), [e, n]);
+}
+export {
+  o as u
+};

package/dist/src/collectors/adonisjs_queue_collector.d.ts

@@ -0,0 +1,21 @@
+import type { MetricCollector } from './collector.js';
+import type { QueueStoreReader } from '../dashboard/integrations/adonisjs_queue_store.js';
+/**
+ * Options for {@link adonisQueueCollector}.
+ */
+export interface AdonisQueueCollectorOptions {
+}
+/** Internal deps seam — NOT part of the public API; for unit tests only. */
+interface AdonisQueueCollectorDeps {
+    resolveReader?: () => Promise<QueueStoreReader | null>;
+}
+/**
+ * Monitors an @adonisjs/queue job queue for active, waiting, delayed, and failed jobs.
+ *
+ * Auto-detects the driver (database or redis) from the host app's queue config.
+ * Returns zeros if @adonisjs/queue is unavailable or the store cannot be reached.
+ *
+ * **Peer dependencies:** `@adonisjs/queue`
+ */
+export declare function adonisQueueCollector(_opts?: AdonisQueueCollectorOptions, deps?: AdonisQueueCollectorDeps): MetricCollector;
+export {};

package/dist/src/collectors/adonisjs_queue_collector.js

@@ -0,0 +1,61 @@
+import { resolveFromAppImport } from '../dashboard/integrations/adonisjs_queue_store.js';
+import { log, dim, bold } from '../utils/logger.js';
+/** Default metrics returned when queue data is unavailable. */
+const QUEUE_DEFAULTS = {
+    queueActive: 0,
+    queueWaiting: 0,
+    queueDelayed: 0,
+    queueFailed: 0,
+    queueWorkerCount: 0,
+};
+/**
+ * Monitors an @adonisjs/queue job queue for active, waiting, delayed, and failed jobs.
+ *
+ * Auto-detects the driver (database or redis) from the host app's queue config.
+ * Returns zeros if @adonisjs/queue is unavailable or the store cannot be reached.
+ *
+ * **Peer dependencies:** `@adonisjs/queue`
+ */
+export function adonisQueueCollector(_opts, deps) {
+    let warnedNotInstalled = false;
+    return {
+        name: 'queue',
+        label: 'queue — @adonisjs/queue (auto-detected driver)',
+        getConfig() {
+            return {
+                driver: 'auto',
+                source: '@adonisjs/queue',
+            };
+        },
+        async collect() {
+            try {
+                const resolve = deps?.resolveReader ?? resolveFromAppImport;
+                const reader = await resolve();
+                if (!reader) {
+                    if (!warnedNotInstalled) {
+                        warnedNotInstalled = true;
+                        log.block(`Queue collector ${bold('skipped')} — @adonisjs/queue is not installed or not reachable`, [
+                            dim('Queue metrics will return zeros until the package is available.'),
+                            `Run ${bold('node ace add @adonisjs/queue')} to install it.`,
+                        ]);
+                    }
+                    return QUEUE_DEFAULTS;
+                }
+                const [counts, workerCount] = await Promise.all([
+                    reader.getCounts(),
+                    reader.getWorkerCount(),
+                ]);
+                return {
+                    queueActive: counts.active,
+                    queueWaiting: counts.waiting,
+                    queueDelayed: counts.delayed,
+                    queueFailed: counts.failed,
+                    queueWorkerCount: workerCount,
+                };
+            }
+            catch {
+                return QUEUE_DEFAULTS;
+            }
+        },
+    };
+}

package/dist/src/collectors/auto_detect.js

@@ -64,15 +64,21 @@ async function registerOptionalCollectors(collectors, entries) {
         pkg: '@adonisjs/redis',
     });
     const hasBullMQ = await isInstalled('bullmq');
+    const hasAdonisQueue = hasBullMQ ? false : await isInstalled('@adonisjs/queue');
     if (hasBullMQ) {
         const { queueCollector } = await import('./queue_collector.js');
         collectors.push(queueCollector({ queueName: 'default', connection: { host: '127.0.0.1', port: 6379 } }));
     }
+    else if (hasAdonisQueue) {
+        const { adonisQueueCollector } = await import('./adonisjs_queue_collector.js');
+        collectors.push(adonisQueueCollector());
+    }
+    const queueEnabled = hasBullMQ || hasAdonisQueue;
     pushOptionalEntry(entries, {
         name: 'queue',
         description: 'jobs, wait time, throughput',
-        enabled: hasBullMQ,
-        pkg: 'bullmq',
+        enabled: queueEnabled,
+        pkg: hasBullMQ ? 'bullmq' : hasAdonisQueue ? '@adonisjs/queue' : 'bullmq',
     });
 }
 function printBootLog(entries) {

package/dist/src/collectors/index.d.ts

@@ -8,6 +8,8 @@ export type { DbPoolCollectorOptions } from './db_pool_collector.js';
 export { redisCollector } from './redis_collector.js';
 export { queueCollector } from './queue_collector.js';
 export type { QueueCollectorOptions, QueueRedisConnection } from './queue_collector.js';
+export { adonisQueueCollector } from './adonisjs_queue_collector.js';
+export type { AdonisQueueCollectorOptions } from './adonisjs_queue_collector.js';
 export { logCollector, getLogStreamService } from './log_collector.js';
 export type { LogCollectorOptions } from './log_collector.js';
 export { appCollector } from './app_collector.js';

package/dist/src/collectors/index.js

@@ -4,6 +4,7 @@ export { httpCollector, getRequestMetrics } from './http_collector.js';
 export { dbPoolCollector } from './db_pool_collector.js';
 export { redisCollector } from './redis_collector.js';
 export { queueCollector } from './queue_collector.js';
+export { adonisQueueCollector } from './adonisjs_queue_collector.js';
 export { logCollector, getLogStreamService } from './log_collector.js';
 export { appCollector } from './app_collector.js';
 export { autoDetectCollectors } from './auto_detect.js';

package/dist/src/collectors/queue_collector.js

@@ -7,12 +7,9 @@ const QUEUE_DEFAULTS = {
     queueFailed: 0,
     queueWorkerCount: 0,
 };
-/** Fetch job counts from a BullMQ queue. */
-async function fetchQueueCounts(queueName, connection) {
-    const { Queue } = await import('bullmq');
-    const queue = new Queue(queueName, { connection });
+/** Fetch job counts from a long-lived BullMQ queue instance. */
+async function fetchQueueCounts(queue) {
     const [counts, workers] = await Promise.all([queue.getJobCounts(), queue.getWorkers()]);
-    await queue.close();
     return {
         queueActive: counts.active ?? 0,
         queueWaiting: counts.waiting ?? 0,
@@ -62,9 +59,28 @@ export function queueCollector(opts) {
         connectionError: false,
         missingConnection: false,
     };
+    // The BullMQ Queue owns a Redis connection. Create it once and reuse it
+    // across every poll tick so a rejected getJobCounts()/getWorkers() can never
+    // leak a connection (the previous per-tick `new Queue(...)` leaked one on
+    // every failure because close() was skipped). The queue is created lazily on
+    // first collect so a missing `bullmq` peer dependency degrades gracefully.
+    let queue = null;
+    async function getQueue(connection) {
+        if (queue)
+            return queue;
+        const { Queue } = await import('bullmq');
+        queue = new Queue(queueName, { connection });
+        return queue;
+    }
     return {
         name: 'queue',
         label: `queue — ${queueName} @ ${opts.connection?.host ?? '?'}:${opts.connection?.port ?? '?'}`,
+        async stop() {
+            if (queue) {
+                await queue.close().catch(() => { });
+                queue = null;
+            }
+        },
         getConfig() {
             return {
                 queueName,
@@ -84,7 +100,7 @@ export function queueCollector(opts) {
                 return QUEUE_DEFAULTS;
             }
             try {
-                return await fetchQueueCounts(queueName, opts.connection);
+                return await fetchQueueCounts(await getQueue(opts.connection));
             }
             catch (error) {
                 handleQueueError(error, queueName, opts.connection, warned);

package/dist/src/config/deprecation_migration.js

@@ -39,6 +39,10 @@ const SIMPLE_DEPRECATIONS = [
         newName: 'authorize',
         before: () => ['shouldShow: (ctx) => ...'],
         after: () => ['authorize: (ctx) => ...'],
+        note: () => [
+            'Your `shouldShow` guard still fully protects the dashboard — nothing breaks.',
+            '`authorize` is just the new name for the same access check.',
+        ],
     },
     {
         key: 'channelName',
@@ -171,6 +175,7 @@ export function logDeprecationWarnings(config) {
                 new: dep.newName,
                 before: dep.before(config),
                 after: dep.after(config),
+                note: dep.note?.(config),
             });
         }
     }
@@ -192,6 +197,12 @@ export function logDeprecationWarnings(config) {
         for (const line of entry.after) {
             lines.push(`      ${dim('after:')}   ${line}`);
         }
+        if (entry.note) {
+            lines.push('');
+            for (const line of entry.note) {
+                lines.push(`      ${dim(line)}`);
+            }
+        }
         lines.push('');
     }
     lines.push(`    ${dim('No rush — the old names still work. They will be removed in the next major version.')}`);

package/dist/src/dashboard/cache_handlers.js

@@ -1,4 +1,18 @@
 import { clamp } from '../utils/math_helpers.js';
+/**
+ * Optional allow-list prefix for single-key cache operations (get/delete).
+ * Restricts which Redis keys the dashboard may read or delete so an attacker
+ * can't target arbitrary keys (sessions, rate-limit counters). Empty/unset
+ * means unrestricted (back-compat default for local dev).
+ */
+function getCacheKeyPrefix() {
+    return (process.env.SERVER_STATS_CACHE_KEY_PREFIX ?? '').trim();
+}
+/** Check whether a cache key is permitted under the configured prefix. */
+function isKeyAllowed(key) {
+    const prefix = getCacheKeyPrefix();
+    return prefix === '' || key.startsWith(prefix);
+}
 /**
  * Handle GET /cache-stats — list cache keys and overall stats.
  */
@@ -26,8 +40,11 @@ export async function handleCacheKey(inspectors, { params, response }) {
     const inspector = await inspectors.getCacheInspector();
     if (!inspector)
         return response.notFound({ error: 'Cache not available' });
+    const key = decodeURIComponent(params.key);
+    if (!isKeyAllowed(key))
+        return response.forbidden({ error: 'Cache key not permitted' });
     try {
-        const detail = await inspector.getKey(decodeURIComponent(params.key));
+        const detail = await inspector.getKey(key);
         return detail ? response.json(detail) : response.notFound({ error: 'Key not found' });
     }
     catch {
@@ -41,8 +58,11 @@ export async function handleCacheKeyDelete(inspectors, { params, response }) {
     const inspector = await inspectors.getCacheInspector();
     if (!inspector)
         return response.notFound({ error: 'Cache not available' });
+    const key = decodeURIComponent(params.key);
+    if (!isKeyAllowed(key))
+        return response.forbidden({ error: 'Cache key not permitted' });
     try {
-        return (await inspector.deleteKey(decodeURIComponent(params.key)))
+        return (await inspector.deleteKey(key))
             ? response.json({ deleted: true })
             : response.notFound({ error: 'Key not found' });
     }

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

@@ -11,6 +11,7 @@ export declare class FlushManager {
     pendingEmails: EmailRecord[];
     private flushTimer;
     private flushing;
+    private inFlight;
     private db;
     constructor(getDb: () => Knex | null);
     persistRequest(input: PersistRequestInput, dashboardPath: string): void;
@@ -21,5 +22,6 @@ export declare class FlushManager {
     private backpressure;
     private scheduleFlush;
     flush(): Promise<void>;
+    private runFlush;
     private takeSnapshot;
 }

package/dist/src/dashboard/flush_manager.js

@@ -9,6 +9,7 @@ export class FlushManager {
     pendingEmails = [];
     flushTimer = null;
     flushing = false;
+    inFlight = null;
     db;
     constructor(getDb) {
         this.db = getDb;
@@ -43,6 +44,10 @@ export class FlushManager {
             clearTimeout(this.flushTimer);
             this.flushTimer = null;
         }
+        // Await any in-flight (timer-triggered) flush first, otherwise the final
+        // flush below early-returns and queued data is lost at shutdown.
+        if (this.inFlight)
+            await this.inFlight.catch(() => { });
         await this.flush().catch(() => { });
     }
     backpressure(q) {
@@ -67,6 +72,18 @@ export class FlushManager {
         if (this.flushing || !db)
             return;
         this.flushing = true;
+        // Track the in-flight flush so stop() can await it before issuing a final
+        // flush, instead of racing the flushing guard and dropping queued data.
+        const run = this.runFlush(db);
+        this.inFlight = run;
+        try {
+            await run;
+        }
+        finally {
+            this.inFlight = null;
+        }
+    }
+    async runFlush(db) {
         const snap = this.takeSnapshot();
         if (!snap) {
             this.flushing = false;

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

@@ -1,9 +1,9 @@
 import { CacheInspector } from './integrations/cache_inspector.js';
-import { QueueInspector } from './integrations/queue_inspector.js';
 import type { ApplicationService } from '@adonisjs/core/types';
+import type { QueueInspectorContract } from './integrations/queue_inspector_contract.js';
 /**
  * Manages lazy initialization and availability detection for
- * cache (Redis) and queue (BullMQ) inspectors.
+ * cache (Redis) and queue (BullMQ / @adonisjs/queue) inspectors.
  *
  * Extracted from DashboardController to reduce file size and complexity.
  */
@@ -16,8 +16,8 @@ export declare class InspectorManager {
     constructor(app: ApplicationService);
     /** Lazy-init the cache inspector. Returns null if Redis is unavailable. */
     getCacheInspector(): Promise<CacheInspector | null>;
-    /** Lazy-init the queue inspector. Returns null if BullMQ is unavailable. */
-    getQueueInspector(): Promise<QueueInspector | null>;
+    /** Lazy-init the queue inspector. Returns null if neither BullMQ nor @adonisjs/queue is available. */
+    getQueueInspector(): Promise<QueueInspectorContract | null>;
     /** Fetch cache overview stats for the overview page. */
     fetchCacheOverview(): Promise<{
         available: boolean;

package/dist/src/dashboard/inspector_manager.js

@@ -1,9 +1,10 @@
 import { log } from '../utils/logger.js';
 import { CacheInspector } from './integrations/cache_inspector.js';
 import { QueueInspector } from './integrations/queue_inspector.js';
+import { AdonisQueueInspector } from './integrations/adonisjs_queue_inspector.js';
 /**
  * Manages lazy initialization and availability detection for
- * cache (Redis) and queue (BullMQ) inspectors.
+ * cache (Redis) and queue (BullMQ / @adonisjs/queue) inspectors.
  *
  * Extracted from DashboardController to reduce file size and complexity.
  */
@@ -39,22 +40,31 @@ export class InspectorManager {
             return null;
         }
     }
-    /** Lazy-init the queue inspector. Returns null if BullMQ is unavailable. */
+    /** Lazy-init the queue inspector. Returns null if neither BullMQ nor @adonisjs/queue is available. */
     async getQueueInspector() {
         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;
+            // Try BullMQ (@rlanz/bull-queue) first.
+            if (await QueueInspector.isAvailable(this.app)) {
+                const queue = await this.app.container.make('rlanz/queue');
+                this.queueInspector = new QueueInspector(queue);
+                this.queueAvailable = true;
+                log.info('dashboard: BullMQ detected — Jobs panel enabled');
+                return this.queueInspector;
             }
-            const queue = await this.app.container.make('rlanz/queue');
-            this.queueInspector = new QueueInspector(queue);
-            return this.queueInspector;
+            // Fall back to @adonisjs/queue.
+            if (await AdonisQueueInspector.isAvailable(this.app)) {
+                this.queueInspector = new AdonisQueueInspector(this.app);
+                this.queueAvailable = true;
+                log.info('dashboard: @adonisjs/queue detected — Jobs panel enabled');
+                return this.queueInspector;
+            }
+            this.queueAvailable = false;
+            log.info('dashboard: Queue not detected — Jobs panel disabled');
+            return null;
         }
         catch (err) {
             this.queueAvailable = false;

package/dist/src/dashboard/integrations/adonisjs_queue_inspector.d.ts

@@ -0,0 +1,42 @@
+import type { ApplicationService } from '@adonisjs/core/types';
+import type { QueueInspectorContract } from './queue_inspector_contract.js';
+import type { QueueOverview, QueueJobDetail, QueueJobListResult, JobStatus } from './queue_inspector_contract.js';
+import type { QueueStoreReader } from './adonisjs_queue_store.js';
+/**
+ * Inspects @adonisjs/queue jobs via the shared store reader.
+ *
+ * Supports both the database (Lucid/Knex) and Redis drivers.
+ * All methods catch errors and return safe defaults.
+ */
+export declare class AdonisQueueInspector implements QueueInspectorContract {
+    #private;
+    _resolveReader: (app: ApplicationService) => Promise<QueueStoreReader | null>;
+    constructor(app: ApplicationService, ...args: unknown[]);
+    /**
+     * Detect whether `@adonisjs/queue` is registered in the application container.
+     */
+    static isAvailable(app: ApplicationService): Promise<boolean>;
+    /**
+     * Get an overview of job counts by status across all queues.
+     * The @adonisjs/queue driver has no concept of paused queues, so `paused` is always 0.
+     */
+    getOverview(): Promise<QueueOverview>;
+    /**
+     * List jobs filtered by status with pagination.
+     *
+     * @param status   Job status to filter by, or `'all'` for every status.
+     * @param page     Page number (1-based).
+     * @param perPage  Jobs per page.
+     */
+    listJobs(status?: JobStatus | 'all', page?: number, perPage?: number): Promise<QueueJobListResult>;
+    /**
+     * Get full detail for a single job by ID.
+     */
+    getJob(id: string): Promise<QueueJobDetail | null>;
+    /**
+     * Retry a failed job.
+     *
+     * @returns `true` if the job was successfully requeued.
+     */
+    retryJob(id: string): Promise<boolean>;
+}

package/dist/src/dashboard/integrations/adonisjs_queue_inspector.js

@@ -0,0 +1,135 @@
+import { resolveFromApplication } from './adonisjs_queue_store.js';
+// ---------------------------------------------------------------------------
+// AdonisQueueInspector
+// ---------------------------------------------------------------------------
+/**
+ * Inspects @adonisjs/queue jobs via the shared store reader.
+ *
+ * Supports both the database (Lucid/Knex) and Redis drivers.
+ * All methods catch errors and return safe defaults.
+ */
+export class AdonisQueueInspector {
+    #app;
+    #readerPromise = null;
+    constructor(app, ...args) {
+        this.#app = app;
+        // Allow an optional second arg to inject a fake resolver in tests.
+        if (typeof args[0] === 'function') {
+            this._resolveReader = args[0];
+        }
+        else {
+            this._resolveReader = (a) => resolveFromApplication(a);
+        }
+    }
+    /**
+     * Detect whether `@adonisjs/queue` is registered in the application container.
+     */
+    static async isAvailable(app) {
+        try {
+            await app.container.make('queue.manager');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    /**
+     * Lazily resolve and cache the store reader.
+     *
+     * Memoizes the *promise* (not a boolean flag) so concurrent callers —
+     * e.g. `getOverview()` + `listJobs()` fired together via `Promise.all` —
+     * all await the same in-flight resolution instead of racing on a half-set
+     * flag and getting a still-null reader.
+     */
+    async #getReader() {
+        if (!this.#readerPromise) {
+            this.#readerPromise = this._resolveReader(this.#app);
+        }
+        return this.#readerPromise;
+    }
+    // ---------------------------------------------------------------------------
+    // QueueInspectorContract implementation
+    // ---------------------------------------------------------------------------
+    /**
+     * Get an overview of job counts by status across all queues.
+     * The @adonisjs/queue driver has no concept of paused queues, so `paused` is always 0.
+     */
+    async getOverview() {
+        const defaults = {
+            active: 0,
+            waiting: 0,
+            delayed: 0,
+            completed: 0,
+            failed: 0,
+            paused: 0,
+        };
+        try {
+            const reader = await this.#getReader();
+            if (!reader)
+                return defaults;
+            const counts = await reader.getCounts();
+            return {
+                active: counts.active,
+                waiting: counts.waiting,
+                delayed: counts.delayed,
+                completed: counts.completed,
+                failed: counts.failed,
+                paused: 0,
+            };
+        }
+        catch {
+            return defaults;
+        }
+    }
+    /**
+     * List jobs filtered by status with pagination.
+     *
+     * @param status   Job status to filter by, or `'all'` for every status.
+     * @param page     Page number (1-based).
+     * @param perPage  Jobs per page.
+     */
+    async listJobs(status = 'all', page = 1, perPage = 25) {
+        try {
+            const reader = await this.#getReader();
+            if (!reader)
+                return { jobs: [], total: 0 };
+            return await reader.listJobs(status === 'paused' ? 'all' : status, page, perPage);
+        }
+        catch {
+            return { jobs: [], total: 0 };
+        }
+    }
+    /**
+     * Get full detail for a single job by ID.
+     */
+    async getJob(id) {
+        try {
+            const reader = await this.#getReader();
+            if (!reader)
+                return null;
+            return await reader.getJob(id);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Retry a failed job.
+     *
+     * @returns `true` if the job was successfully requeued.
+     */
+    async retryJob(id) {
+        try {
+            const reader = await this.#getReader();
+            if (!reader)
+                return false;
+            return await reader.retryJob(id);
+        }
+        catch {
+            return false;
+        }
+    }
+}