@zintrust/queue-monitor 0.4.48 → 0.4.50

package/dist/QueueMonitoringService.d.ts

@@ -2,6 +2,7 @@ import type { IRequest, IResponse } from '@zintrust/core';
 import type { QueueDriver } from './driver';
 import type { LockAnalytics, QueueMonitorSnapshot } from './index';
 import type { JobSummary, Metrics } from './metrics';
+export declare const ALL_QUEUES = "__all__";
 type QueueSnapshotData = {
     type: string;
     ts: string;
@@ -20,11 +21,11 @@ type QueueMonitoringConfig = {
     pattern: string;
     intervalMs: number;
 };
+type QueueMonitoringCallback = (data: QueueSnapshotData) => void;
+export declare function getRecentJobsForSelection(queueName: string, metrics: Metrics, driver: QueueDriver, queueNames?: ReadonlyArray<string>): Promise<JobSummary[]>;
 export declare const QueueMonitoringService: Readonly<{
-    subscribe(callback: (data: QueueSnapshotData) => void): void;
-    unsubscribe(callback: (data: QueueSnapshotData) => void): void;
-    startPollingForClient(config: QueueMonitoringConfig): void;
-    stopPollingForClient(): void;
+    subscribe(callback: QueueMonitoringCallback, config: QueueMonitoringConfig): void;
+    unsubscribe(callback: QueueMonitoringCallback): void;
 }>;
 export declare const QueueMonitoringStream: (res: IResponse, req: IRequest, getSnapshot: () => Promise<QueueMonitorSnapshot>, getLocks: (pattern?: string) => Promise<LockAnalytics>, metrics: Metrics, driver: QueueDriver, settings: {
     basePath: string;

package/dist/QueueMonitoringService.js

@@ -1,80 +1,92 @@
-import { Logger, NodeSingletons } from '@zintrust/core';
-// Internal state
-const emitter = new NodeSingletons.EventEmitter();
-emitter.setMaxListeners(Infinity);
-let interval = null;
-let subscribers = 0;
-let currentConfig = null;
-const broadcastSnapshot = async () => {
+import { Logger } from '@zintrust/core';
+export const ALL_QUEUES = '__all__';
+const subscriptions = new Map();
+const isAllQueuesSelection = (queue) => queue === ALL_QUEUES;
+const sortJobsByTimestamp = (jobs) => jobs.sort((left, right) => right.timestamp - left.timestamp);
+export async function getRecentJobsForSelection(queueName, metrics, driver, queueNames) {
+    if (!isAllQueuesSelection(queueName)) {
+        return getRecentJobsForQueue(queueName, metrics, driver);
+    }
+    const names = Array.from(new Set((queueNames ?? (await driver.getQueues())).filter(Boolean)));
+    const jobsByQueue = await Promise.all(names.map(async (name) => getRecentJobsForQueue(name, metrics, driver)));
+    return sortJobsByTimestamp(jobsByQueue.flat()).slice(0, 100);
+}
+const buildSnapshotPayload = async (config) => {
+    const { getSnapshot, getLocks, metrics, driver, queue: configuredQueue, pattern } = config;
+    const snapshot = await getSnapshot();
+    let queue;
+    if (isAllQueuesSelection(configuredQueue)) {
+        queue = ALL_QUEUES;
+    }
+    else if (configuredQueue &&
+        snapshot.queues.some((candidate) => candidate.name === configuredQueue)) {
+        queue = configuredQueue;
+    }
+    else {
+        queue = snapshot.queues[0]?.name ?? null;
+    }
+    return {
+        type: 'snapshot',
+        ts: new Date().toISOString(),
+        queue,
+        snapshot,
+        jobs: queue
+            ? await getRecentJobsForSelection(queue, metrics, driver, snapshot.queues.map((candidate) => candidate.name))
+            : [],
+        locks: await getLocks(pattern),
+    };
+};
+const pushSnapshot = async (subscription) => {
     try {
-        if (subscribers <= 0 || !currentConfig)
-            return;
-        const { getSnapshot, getLocks, metrics, driver, queue: initialQueue, pattern } = currentConfig;
-        const snapshot = await getSnapshot();
-        let queue = initialQueue;
-        if (!queue && snapshot.queues.length > 0) {
-            queue = snapshot.queues[0].name;
-        }
-        const jobs = queue ? await getRecentJobsForQueue(queue, metrics, driver) : [];
-        const locks = await getLocks(pattern);
-        const payload = {
-            type: 'snapshot',
-            ts: new Date().toISOString(),
-            queue: queue || null,
-            snapshot,
-            jobs,
-            locks,
-        };
-        emitter.emit('snapshot', payload);
+        subscription.callback(await buildSnapshotPayload(subscription.config));
     }
     catch (err) {
-        Logger.error('QueueMonitoringService.broadcastSnapshot failed', err);
-        if (emitter.listenerCount('error') > 0) {
-            emitter.emit('error', err);
-        }
+        Logger.error('QueueMonitoringService.pushSnapshot failed', err);
     }
 };
-const startPolling = () => {
-    if (interval || !currentConfig)
+const startPolling = (subscription) => {
+    if (subscription.interval)
         return;
-    Logger.debug('Starting QueueMonitoringService polling');
-    // Initial fetch
-    void broadcastSnapshot();
-    interval = setInterval(() => {
-        void broadcastSnapshot();
-    }, currentConfig.intervalMs);
+    Logger.debug('Starting QueueMonitoringService polling', {
+        queue: subscription.config.queue || null,
+        pattern: subscription.config.pattern,
+    });
+    void pushSnapshot(subscription);
+    subscription.interval = setInterval(() => {
+        void pushSnapshot(subscription);
+    }, subscription.config.intervalMs);
 };
-const stopPolling = () => {
-    if (interval) {
-        Logger.debug('Stopping QueueMonitoringService polling');
-        clearInterval(interval);
-        interval = null;
-    }
+const stopPolling = (subscription) => {
+    if (!subscription.interval)
+        return;
+    Logger.debug('Stopping QueueMonitoringService polling', {
+        queue: subscription.config.queue || null,
+        pattern: subscription.config.pattern,
+    });
+    clearInterval(subscription.interval);
+    subscription.interval = null;
 };
 export const QueueMonitoringService = Object.freeze({
-    subscribe(callback) {
-        emitter.on('snapshot', callback);
-        subscribers++;
-    },
-    unsubscribe(callback) {
-        emitter.off('snapshot', callback);
-        subscribers--;
-        if (subscribers <= 0) {
-            stopPolling();
-            currentConfig = null;
-        }
-    },
-    startPollingForClient(config) {
-        if (subscribers === 1) {
-            currentConfig = config;
-            startPolling();
+    subscribe(callback, config) {
+        const existing = subscriptions.get(callback);
+        if (existing) {
+            stopPolling(existing);
+            subscriptions.delete(callback);
         }
+        const subscription = {
+            callback,
+            config,
+            interval: null,
+        };
+        subscriptions.set(callback, subscription);
+        startPolling(subscription);
     },
-    stopPollingForClient() {
-        if (subscribers <= 0) {
-            stopPolling();
-            currentConfig = null;
-        }
+    unsubscribe(callback) {
+        const subscription = subscriptions.get(callback);
+        if (!subscription)
+            return;
+        stopPolling(subscription);
+        subscriptions.delete(callback);
     },
 });
 //  settings: {
@@ -116,10 +128,7 @@ export const QueueMonitoringStream = (res, req, getSnapshot, getLocks, metrics,
     const onSnapshot = (data) => {
         send(data);
     };
-    // Subscribe to centralized service
-    QueueMonitoringService.subscribe(onSnapshot);
-    // Start polling for this client
-    QueueMonitoringService.startPollingForClient({
+    QueueMonitoringService.subscribe(onSnapshot, {
         getSnapshot,
         getLocks,
         getRecentJobsForQueue,
@@ -138,13 +147,15 @@ export const QueueMonitoringStream = (res, req, getSnapshot, getLocks, metrics,
         closed = true;
         clearInterval(hb);
         QueueMonitoringService.unsubscribe(onSnapshot);
-        QueueMonitoringService.stopPollingForClient();
     });
 };
 export async function getRecentJobsForQueue(queueName, metrics, driver) {
     const recent = await metrics.getRecentJobs(queueName);
     const failed = await metrics.getFailedJobs(queueName);
-    const all = [...recent, ...failed].sort((a, b) => b.timestamp - a.timestamp).slice(0, 100);
+    const all = sortJobsByTimestamp([...recent, ...failed].map((job) => ({
+        ...job,
+        queue: job.queue ?? queueName,
+    }))).slice(0, 100);
     if (all.length > 0) {
         return all;
     }
@@ -182,6 +193,7 @@ export async function getRecentJobsForQueue(queueName, metrics, driver) {
         return {
             id: job.id,
             name: job.name,
+            queue: queueName,
             data: job.data,
             attempts: job.attemptsMade,
             status,

package/dist/api/workerClient.d.ts

@@ -0,0 +1,20 @@
+type WorkerApiResponse<T> = {
+    ok: boolean;
+    error?: string;
+} & T;
+export declare const WorkerClient: Readonly<{
+    listWorkers(): Promise<string[]>;
+    getWorker(name: string): Promise<unknown>;
+    getStatus(name: string): Promise<unknown>;
+    getHealth(name: string): Promise<unknown>;
+    startWorker(name: string): Promise<WorkerApiResponse<{
+        message?: string;
+    }>>;
+    stopWorker(name: string): Promise<WorkerApiResponse<{
+        message?: string;
+    }>>;
+    restartWorker(name: string): Promise<WorkerApiResponse<{
+        message?: string;
+    }>>;
+}>;
+export {};

package/dist/api/workerClient.js

@@ -0,0 +1,45 @@
+import { ErrorFactory, Logger } from '@zintrust/core';
+import { WorkerConfig } from '../config/workerConfig.js';
+const requestJson = async (path, options = {}) => {
+    const baseUrl = WorkerConfig.getWorkerBaseUrl();
+    const url = `${baseUrl}${path}`;
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options.headers,
+        },
+    });
+    if (!response.ok) {
+        Logger.error('Worker API request failed', { url, status: response.status });
+        throw ErrorFactory.createWorkerError(`Worker API request failed (${response.status})`);
+    }
+    return (await response.json());
+};
+export const WorkerClient = Object.freeze({
+    async listWorkers() {
+        const response = await requestJson('/api/workers');
+        return response.workers ?? [];
+    },
+    async getWorker(name) {
+        const response = await requestJson(`/api/workers/${name}`);
+        return response.worker;
+    },
+    async getStatus(name) {
+        const response = await requestJson(`/api/workers/${name}/status`);
+        return response.status;
+    },
+    async getHealth(name) {
+        const response = await requestJson(`/api/workers/${name}/health`);
+        return response.health;
+    },
+    async startWorker(name) {
+        return requestJson(`/api/workers/${name}/start`, { method: 'POST' });
+    },
+    async stopWorker(name) {
+        return requestJson(`/api/workers/${name}/stop`, { method: 'POST' });
+    },
+    async restartWorker(name) {
+        return requestJson(`/api/workers/${name}/restart`, { method: 'POST' });
+    },
+});

package/dist/build-manifest.json

@@ -1,15 +1,15 @@
 {
   "name": "@zintrust/queue-monitor",
-  "version": "0.4.48",
-  "buildDate": "2026-04-03T09:57:53.962Z",
+  "version": "0.4.43",
+  "buildDate": "2026-04-01T18:15:53.560Z",
   "buildEnvironment": {
-    "node": "v20.20.1",
-    "platform": "linux",
-    "arch": "x64"
+    "node": "v22.22.1",
+    "platform": "darwin",
+    "arch": "arm64"
   },
   "git": {
-    "commit": "0ac23637",
-    "branch": "master"
+    "commit": "57e4d1b5",
+    "branch": "release"
   },
   "package": {
     "engines": {
@@ -32,6 +32,34 @@
       "size": 6190,
       "sha256": "068477c0b545686c9c35d6b42960b5ecf8d19ee4f3f5adec8ddeeb21113258b3"
     },
+    "api/workerClient.d.ts": {
+      "size": 597,
+      "sha256": "1d712bfa9127aa2df4f1fbd0efbb6d84069e1888ed73aca5542a41eee865d4bb"
+    },
+    "api/workerClient.js": {
+      "size": 1629,
+      "sha256": "60f993a42f4a9dd5000b01dae3b0f105a8f4348da8433a735b5cc1929a8f64ce"
+    },
+    "build-manifest.json": {
+      "size": 3865,
+      "sha256": "6b9eece186e37f5ed657a014c799e3783f30d0e16e0c2fb4e9fa8f2ffcbdd673"
+    },
+    "config/queueMonitor.d.ts": {
+      "size": 407,
+      "sha256": "4541f47e64c8ede1bfd8fc0cb7edb76c4e885311b28b1f51c9be7639e5d87eca"
+    },
+    "config/queueMonitor.js": {
+      "size": 689,
+      "sha256": "0b95e6b65d4b6ffdd69788cdfd19e0e76400a39ad69dce018d8827a3b298e419"
+    },
+    "config/workerConfig.d.ts": {
+      "size": 86,
+      "sha256": "b669205d50c8844455a2d9b34a54f48a71118eb6ac99bad5372683ab666f5a22"
+    },
+    "config/workerConfig.js": {
+      "size": 628,
+      "sha256": "ca1c6dbaa751893f0e6b7c8a7fd41a80f7d5e8fc9aaaa4877ca12821bb25f56f"
+    },
     "connection.d.ts": {
       "size": 107,
       "sha256": "653b300a25df08a2380bdc74ea38342190771386cb1847dc92802e6eef88a88f"
@@ -62,7 +90,7 @@
     },
     "index.js": {
       "size": 11889,
-      "sha256": "89c18a0da652cf8a7502b5c552250e419c66edb03c7d6ca358b54278d5cf53a9"
+      "sha256": "19a7bdc71cec34fe732dd0d7177ad366d271e31462f402911d4a2700d0ea8b2c"
     },
     "metrics.d.ts": {
       "size": 848,
@@ -72,6 +100,14 @@
       "size": 3448,
       "sha256": "022c97865d37933fd7ed92f47b86b0450056caffd629fce6add51c902529bfe5"
     },
+    "routes/workers.d.ts": {
+      "size": 477,
+      "sha256": "cfcc3527c47d1a796a3ced2d4777b339dd767f7feb3ecc66c5ce0a91d8ff1bc8"
+    },
+    "routes/workers.js": {
+      "size": 901,
+      "sha256": "1ec48c0becc8c0628b1780fb400e957c5fe50da79f73112436c33ecde7d7d574"
+    },
     "worker.d.ts": {
       "size": 332,
       "sha256": "97cddbc991c6e6724950090cd92f06671932ab848c16dd94a030d9fba3fbae26"
@@ -79,6 +115,14 @@
     "worker.js": {
       "size": 1233,
       "sha256": "da26c1b80da7473e1644a4e0f8d814097ce0adff14e36037164f9ae5855e656a"
+    },
+    "workers-ui.d.ts": {
+      "size": 214,
+      "sha256": "4f5fd3bbd077d0dee2cc6c73d2c736fc52119b0d3a5f4a1878a4f3d3d3edf299"
+    },
+    "workers-ui.js": {
+      "size": 24928,
+      "sha256": "ba2c5cbf890fe875cc5336c76bd29b146089bc8ba3a70de4a2c383f395f9be73"
     }
   }
 }

package/dist/config/queueMonitor.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Queue Monitor Configuration (default override)
+ *
+ * Keep this file declarative:
+ * - Core owns env parsing/default logic.
+ * - Projects can override config by editing values below.
+ */
+declare const _default: {
+    enabled: boolean;
+    basePath: string;
+    middleware: string[];
+    redis: {
+        host: string;
+        port: number;
+        password: string;
+    };
+};
+export default _default;

package/dist/config/queueMonitor.js

@@ -0,0 +1,21 @@
+import { Env } from '@zintrust/core';
+/**
+ * Queue Monitor Configuration (default override)
+ *
+ * Keep this file declarative:
+ * - Core owns env parsing/default logic.
+ * - Projects can override config by editing values below.
+ */
+export default {
+    enabled: Env.getBool('QUEUE_MONITOR_ENABLED', true),
+    basePath: Env.get('QUEUE_MONITOR_BASE_PATH', '/queue-monitor'),
+    middleware: Env.get('QUEUE_MONITOR_MIDDLEWARE', 'auth')
+        .split(',')
+        .map((m) => m.trim())
+        .filter((m) => m.length > 0),
+    redis: {
+        host: Env.get('REDIS_HOST', 'localhost'),
+        port: Env.getInt('REDIS_PORT', 6379),
+        password: Env.get('REDIS_PASSWORD', ''),
+    },
+};

package/dist/config/workerConfig.d.ts

@@ -0,0 +1,3 @@
+export declare const WorkerConfig: Readonly<{
+    getWorkerBaseUrl: () => string;
+}>;

package/dist/config/workerConfig.js

@@ -0,0 +1,19 @@
+import { Env } from '@zintrust/core';
+const normalizeBaseUrl = (value) => {
+    let end = value.length;
+    while (end > 0 && value.charAt(end - 1) === '/') {
+        end--;
+    }
+    return value.slice(0, end);
+};
+const withHttpScheme = (value) => value.startsWith('http://') || value.startsWith('https://') ? value : `http://${value}`;
+const resolveWorkerApiUrl = () => {
+    const workerApiUrl = Env.get('WORKER_API_URL');
+    if (workerApiUrl) {
+        return normalizeBaseUrl(withHttpScheme(workerApiUrl));
+    }
+    return '';
+};
+export const WorkerConfig = Object.freeze({
+    getWorkerBaseUrl: resolveWorkerApiUrl,
+});