@zintrust/queue-monitor 0.4.48 → 0.4.50

package/dist/dashboard-ui.js

@@ -239,7 +239,9 @@ const getDashboardBody = () => `
 const getDashboardScriptState = (options) => String.raw `
         const AUTO_REFRESH = ${options.autoRefresh ? 'true' : 'false'};
         const REFRESH_INTERVAL = ${Math.max(1000, Math.floor(options.refreshIntervalMs || 0))};
+    const STREAM_RESET_MS = Math.max(15000, REFRESH_INTERVAL * 4);
     const API_BASE = ${JSON.stringify(options.basePath)};
+    const ALL_QUEUES = '__all__';
         const THEME_KEY = 'zintrust-queue-monitor-theme';
         const AUTO_REFRESH_KEY = 'zintrust-queue-monitor-auto-refresh';
         const QUEUE_KEY = 'zintrust-queue-monitor-selected-queue';
@@ -250,6 +252,10 @@ const getDashboardScriptState = (options) => String.raw `
         let sseActive = false;
         let lastSseQueue = null;
         let lastSsePattern = null;
+        let reconnectTimer = null;
+        let streamWatchdogTimer = null;
+        let dashboardResetTimer = null;
+        let reconnectAttempts = 0;
         let currentTheme = null;
 `;
 const getDashboardScriptTheme = () => `
@@ -308,6 +314,8 @@ const getDashboardScriptAutoRefresh = () => `
                     eventSource = null;
                 }
                 sseActive = false;
+                clearSseTimers();
+                clearError();
             }
 
             if (autoRefreshEnabled && !sseActive) {
@@ -389,18 +397,40 @@ const getRenderStatsFunction = () => `
 const getUpdateQueueSelectFunction = () => `
         function updateQueueSelect(queues) {
             const select = document.getElementById('queue-select');
-            const currentSelection = select.value || currentQueue;
+            const storedQueue = localStorage.getItem(QUEUE_KEY);
+            const preferredQueue = currentQueue || select.value || storedQueue || '';
             select.innerHTML = '';
 
-            if (queues.length === 0) return
+            if (queues.length === 0) {
+                select.disabled = true;
+                select.innerHTML = '<option value="">No queues</option>';
+                return '';
+            }
+
+            const queueNames = queues.map(q => q.name);
+            const totalWaiting = queues.reduce((acc, queue) => acc + queue.counts.waiting, 0);
+            const totalFailed = queues.reduce((acc, queue) => acc + queue.counts.failed, 0);
+            const allOption = document.createElement('option');
+            allOption.value = ALL_QUEUES;
+            allOption.textContent = 'All queues (' + totalWaiting + ' waiting, ' + totalFailed + ' failed)';
+
+            const nextQueue = preferredQueue === ALL_QUEUES || queueNames.includes(preferredQueue)
+                ? preferredQueue
+                : queueNames[0];
+            select.disabled = false;
+            allOption.selected = nextQueue === ALL_QUEUES;
+            select.appendChild(allOption);
 
             queues.forEach(q => {
                 const opt = document.createElement('option');
                 opt.value = q.name;
                 opt.textContent = q.name + ' (' + q.counts.waiting + ' waiting, ' + q.counts.failed + ' failed)';
-                opt.selected = q.name === currentSelection;
+                opt.selected = q.name === nextQueue;
                 select.appendChild(opt);
             });
+
+            select.value = nextQueue;
+            return nextQueue;
         }`;
 const getRenderJobsFunction = () => `
         // Track expanded job IDs to preserve state during SSE updates
@@ -634,6 +664,12 @@ const getErrorAndTooltipFunctions = () => `
             el.style.display = 'block';
         }
 
+        function clearError() {
+            const el = document.getElementById('error-container');
+            el.textContent = '';
+            el.style.display = 'none';
+        }
+
         let tooltipEl = null;
         function showTooltip(e) {
             const info = e.target.getAttribute('data-info');
@@ -681,7 +717,7 @@ const getToggleDetailsFunctions = () => `
             const jobData = {
                 id: job.id,
                 name: job.name,
-                queue: currentQueue,
+                queue: job.queue || currentQueue,
                 status: job.status || (job.failedReason ? 'failed' : 'completed'),
                 attempts: job.attempts,
                 timestamp: new Date(job.timestamp).toISOString(),
@@ -776,6 +812,77 @@ const getDashboardScriptHelpers = () => `
             return patternInput && patternInput.value ? patternInput.value : '*';
         }
 
+        function clearSseTimers() {
+            if (reconnectTimer !== null) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+
+            if (streamWatchdogTimer !== null) {
+                clearTimeout(streamWatchdogTimer);
+                streamWatchdogTimer = null;
+            }
+
+            if (dashboardResetTimer !== null) {
+                clearTimeout(dashboardResetTimer);
+                dashboardResetTimer = null;
+            }
+        }
+
+        function scheduleDashboardReset(message) {
+            if (dashboardResetTimer !== null) return;
+
+            showError(message || 'Live updates stalled. Resetting dashboard...');
+            dashboardResetTimer = window.setTimeout(() => {
+                window.location.reload();
+            }, STREAM_RESET_MS);
+        }
+
+        function armStreamWatchdog() {
+            if (!autoRefreshEnabled) return;
+
+            if (streamWatchdogTimer !== null) {
+                clearTimeout(streamWatchdogTimer);
+            }
+
+            streamWatchdogTimer = window.setTimeout(() => {
+                if (eventSource) {
+                    eventSource.close();
+                    eventSource = null;
+                }
+                sseActive = false;
+                streamWatchdogTimer = null;
+                scheduleDashboardReset('Live updates stalled. Resetting dashboard...');
+            }, STREAM_RESET_MS);
+        }
+
+        function markStreamHealthy() {
+            reconnectAttempts = 0;
+            if (reconnectTimer !== null) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+            clearError();
+            armStreamWatchdog();
+        }
+
+        function scheduleReconnect() {
+            if (!autoRefreshEnabled || reconnectTimer !== null) return;
+
+            reconnectAttempts += 1;
+            const delay = Math.min(1000 * reconnectAttempts, 5000);
+            showError('Live updates disconnected. Reconnecting...');
+
+            reconnectTimer = window.setTimeout(() => {
+                reconnectTimer = null;
+                setupEventStream(currentQueue);
+            }, delay);
+
+            if (reconnectAttempts >= 4) {
+                scheduleDashboardReset('Live updates could not reconnect. Resetting dashboard...');
+            }
+        }
+
         function buildEventsUrl(queue, pattern) {
             const q = queue || '';
             const p = pattern || '*';
@@ -785,11 +892,12 @@ const getDashboardScriptHelpers = () => `
 const getDashboardScriptEventStream = () => `
         function setupEventStream(queueOverride) {
             if (!window.EventSource) return;
+            if (!autoRefreshEnabled) return;
 
-            const queue = queueOverride || currentQueue;
+            const queue = queueOverride === undefined ? currentQueue : queueOverride;
             const pattern = getLockPattern();
 
-            if (eventSource && queue === lastSseQueue && pattern === lastSsePattern) return;
+            if (eventSource && sseActive && queue === lastSseQueue && pattern === lastSsePattern) return;
 
             if (eventSource) {
                 eventSource.close();
@@ -799,10 +907,12 @@ const getDashboardScriptEventStream = () => `
             lastSseQueue = queue;
             lastSsePattern = pattern;
             eventSource = new EventSource(buildEventsUrl(queue, pattern));
+            armStreamWatchdog();
 
             eventSource.onopen = () => {
                 sseActive = true;
                 stopAutoRefresh();
+                markStreamHealthy();
             };
 
             eventSource.onmessage = (evt) => {
@@ -813,20 +923,31 @@ const getDashboardScriptEventStream = () => `
                     if (payload.type === 'snapshot') {
                         if (payload.snapshot) {
                             renderStats(payload.snapshot);
-                            updateQueueSelect(payload.snapshot.queues || []);
+                            const nextQueue = updateQueueSelect(payload.snapshot.queues || []);
+                            if (nextQueue !== currentQueue) {
+                                currentQueue = nextQueue;
+                                if (currentQueue) {
+                                    localStorage.setItem(QUEUE_KEY, currentQueue);
+                                } else {
+                                    localStorage.removeItem(QUEUE_KEY);
+                                }
+                            }
                         }
 
-                        if (payload.queue && payload.queue !== currentQueue) {
-                            currentQueue = payload.queue;
-                            localStorage.setItem(QUEUE_KEY, currentQueue);
-                            const select = document.getElementById('queue-select');
-                            if (select) select.value = currentQueue;
+                        if (!currentQueue) {
+                            renderJobs([]);
                         }
 
-                        if (payload.jobs) renderJobs(payload.jobs);
+                        if (payload.jobs && (!payload.queue || payload.queue === currentQueue)) {
+                            renderJobs(payload.jobs);
+                        }
                         if (payload.locks) renderLocks(payload.locks);
 
-                        document.getElementById('last-updated').textContent = new Date().toLocaleTimeString();
+                        const lastUpdated = document.getElementById('last-updated');
+                        if (lastUpdated) {
+                            lastUpdated.textContent = new Date().toLocaleTimeString();
+                        }
+                        markStreamHealthy();
                     }
                 } catch (err) {
                     console.error('Failed to parse SSE payload', err);
@@ -839,7 +960,7 @@ const getDashboardScriptEventStream = () => `
                     eventSource = null;
                 }
                 sseActive = false;
-                if (autoRefreshEnabled) startAutoRefresh();
+                scheduleReconnect();
             };
         }
 `;
@@ -932,8 +1053,13 @@ const getDashboardScriptBootstrap = () => `
         if (queueSelect) {
             queueSelect.addEventListener('change', (e) => {
                 currentQueue = e.target.value;
-                localStorage.setItem(QUEUE_KEY, currentQueue);
+                if (currentQueue) {
+                    localStorage.setItem(QUEUE_KEY, currentQueue);
+                } else {
+                    localStorage.removeItem(QUEUE_KEY);
+                }
                 console.log('Queue changed - SSE will update automatically');
+                clearError();
 
                 setupEventStream(currentQueue);
             });
@@ -961,6 +1087,7 @@ const getDashboardScriptBootstrap = () => `
         setupEventStream(currentQueue);
 
         window.addEventListener('beforeunload', () => {
+            clearSseTimers();
             if (eventSource) {
                 eventSource.close();
             }

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export type QueueMonitorConfig = {
     autoRefresh?: boolean;
     refreshIntervalMs?: number;
     redis?: RedisConfig;
+    knownQueues?: ReadonlyArray<string> | (() => Promise<ReadonlyArray<string>> | ReadonlyArray<string>);
 };
 export type QueueCounts = {
     waiting: number;

package/dist/index.js

@@ -1,9 +1,9 @@
-import { Logger, queueConfig, resolveLockPrefix, Router, } from '@zintrust/core';
+import { isNonEmptyString, Logger, queueConfig, resolveLockPrefix, Router, } from '@zintrust/core';
 import { createRedisConnection } from './connection';
 import { getDashboardHtml } from './dashboard-ui';
 import { createBullMQDriver } from './driver';
 import { createMetrics } from './metrics';
-import { getRecentJobsForQueue, QueueMonitoringStream } from './QueueMonitoringService';
+import { getRecentJobsForSelection, QueueMonitoringStream } from './QueueMonitoringService';
 export { createWorker as createQueueWorker } from './worker';
 const DEFAULTS = {
     enabled: true,
@@ -34,6 +34,23 @@ const HISTOGRAM_BUCKETS = [
     { label: '>60m', min: 3_600_000 },
 ];
 const MAX_LOCK_KEYS = 10_000;
+function normalizeQueueNames(queueNames) {
+    return Array.from(new Set(queueNames
+        .map((queueName) => queueName)
+        .filter(isNonEmptyString)
+        .map((name) => name.trim())))
+        .filter((name) => name.length > 0)
+        .sort((left, right) => left.localeCompare(right));
+}
+async function resolveKnownQueues(knownQueues) {
+    if (typeof knownQueues === 'function') {
+        return normalizeQueueNames(await knownQueues());
+    }
+    if (Array.isArray(knownQueues)) {
+        return normalizeQueueNames(knownQueues);
+    }
+    return [];
+}
 // Helper function to scan lock keys with pagination
 const scanLockKeys = async (client, searchPattern, maxKeys) => {
     const keys = [];
@@ -148,7 +165,7 @@ async function handleJobsEndpoint(req, res, metrics, driver) {
         res.status(400).json(fieldError('queue_name', 'Queue name must be provided'));
         return;
     }
-    const jobs = await getRecentJobsForQueue(queueName, metrics, driver);
+    const jobs = await getRecentJobsForSelection(queueName, metrics, driver);
     res.json(jobs);
 }
 async function handleRetryEndpoint(req, res, driver) {
@@ -177,9 +194,13 @@ function buildSettings(config) {
             : DEFAULTS.refreshIntervalMs,
     };
 }
-function createGetSnapshot(driver, startedAt) {
+function createGetSnapshot(driver, startedAt, knownQueues) {
     return async () => {
-        const queues = await driver.getQueues();
+        const [discoveredQueues, persistedQueues] = await Promise.all([
+            driver.getQueues(),
+            resolveKnownQueues(knownQueues),
+        ]);
+        const queues = Array.from(new Set([...persistedQueues, ...discoveredQueues])).sort((left, right) => left.localeCompare(right));
         const stats = await Promise.all(queues.map(async (name) => {
             const counts = await driver.getJobCounts(name);
             return { name, counts: counts };
@@ -270,7 +291,7 @@ export const QueueMonitor = Object.freeze({
         const driver = createBullMQDriver(redisConfig);
         const metrics = createMetrics(redisConfig);
         const startedAt = new Date().toISOString();
-        const getSnapshot = createGetSnapshot(driver, startedAt);
+        const getSnapshot = createGetSnapshot(driver, startedAt, config.knownQueues);
         const getLocks = createGetLocks(redisConfig);
         const registerRoutes = createRegisterRoutes(settings, metrics, driver, getSnapshot, getLocks);
         const close = async () => {

package/dist/metrics.d.ts

@@ -4,6 +4,7 @@ export type JobStatus = 'completed' | 'failed';
 export type JobSummary = {
     id: string | undefined;
     name: string;
+    queue?: string;
     data: unknown;
     attempts: number;
     status?: string;

package/dist/routes/workers.d.ts

@@ -0,0 +1,10 @@
+import { type IRouter } from '@zintrust/core';
+import { type WorkerUiOptions } from '../workers-ui';
+type RouteOptions = {
+    middleware?: ReadonlyArray<string>;
+} | undefined;
+export declare const registerWorkerUiRoutes: (router: IRouter, options: WorkerUiOptions, routeOptions: RouteOptions) => void;
+declare const _default: Readonly<{
+    registerWorkerUiRoutes: (router: IRouter, options: WorkerUiOptions, routeOptions: RouteOptions) => void;
+}>;
+export default _default;

package/dist/routes/workers.js

@@ -0,0 +1,20 @@
+import { Router } from '@zintrust/core';
+import { WorkerConfig } from '../config/workerConfig.js';
+import { getWorkersHtml } from '../workers-ui.js';
+const registerWorkerUiPage = (router, options, routeOptions) => {
+    const handler = (_req, res) => {
+        res.html(getWorkersHtml({
+            basePath: options.basePath,
+            apiBaseUrl: WorkerConfig.getWorkerBaseUrl(),
+            autoRefresh: options.autoRefresh,
+            refreshIntervalMs: options.refreshIntervalMs,
+        }));
+    };
+    Router.get(router, `${options.basePath}/workers`, handler, routeOptions);
+    Router.get(router, '/workers', handler, routeOptions);
+    Router.get(router, '/workers/', handler, routeOptions);
+};
+export const registerWorkerUiRoutes = (router, options, routeOptions) => {
+    registerWorkerUiPage(router, options, routeOptions);
+};
+export default Object.freeze({ registerWorkerUiRoutes });

package/dist/workers-ui.d.ts

@@ -0,0 +1,7 @@
+export type WorkerUiOptions = {
+    basePath: string;
+    apiBaseUrl?: string;
+    autoRefresh: boolean;
+    refreshIntervalMs: number;
+};
+export declare const getWorkersHtml: (options: WorkerUiOptions) => string;