@zintrust/queue-monitor 0.4.75 → 0.4.86

package/dist/QueueMonitoringService.js

@@ -1,8 +1,36 @@
 import { Logger } from '@zintrust/core';
 export const ALL_QUEUES = '__all__';
 const subscriptions = new Map();
+const channels = new Map();
+const objectIds = new WeakMap();
+let nextObjectId = 0;
 const isAllQueuesSelection = (queue) => queue === ALL_QUEUES;
 const sortJobsByTimestamp = (jobs) => jobs.toSorted((left, right) => right.timestamp - left.timestamp);
+const getObjectId = (value) => {
+    const existing = objectIds.get(value);
+    if (existing !== undefined)
+        return existing;
+    nextObjectId += 1;
+    objectIds.set(value, nextObjectId);
+    return nextObjectId;
+};
+const buildChannelKey = (config) => {
+    const snapshotId = getObjectId(config.getSnapshot);
+    const locksId = getObjectId(config.getLocks);
+    const jobsId = getObjectId(config.getRecentJobsForQueue);
+    const metricsId = getObjectId(config.metrics);
+    const driverId = getObjectId(config.driver);
+    return [
+        config.queue,
+        config.pattern,
+        String(config.intervalMs),
+        String(snapshotId),
+        String(locksId),
+        String(jobsId),
+        String(metricsId),
+        String(driverId),
+    ].join('::');
+};
 export async function getRecentJobsForSelection(queueName, metrics, driver, queueNames) {
     if (!isAllQueuesSelection(queueName)) {
         return getRecentJobsForQueue(queueName, metrics, driver);
@@ -36,48 +64,92 @@ const buildSnapshotPayload = async (config) => {
         locks: await getLocks(pattern),
     };
 };
-const pushSnapshot = async (subscription) => {
+const pushSnapshot = async (channel) => {
     try {
-        subscription.callback(await buildSnapshotPayload(subscription.config));
+        channel.pending ??= buildSnapshotPayload(channel.config);
+        const payload = await channel.pending;
+        channel.lastPayload = payload;
+        channel.callbacks.forEach((callback) => {
+            try {
+                callback(payload);
+            }
+            catch (err) {
+                Logger.error('QueueMonitoringService.pushSnapshot callback failed', err);
+            }
+        });
     }
     catch (err) {
         Logger.error('QueueMonitoringService.pushSnapshot failed', err);
     }
+    finally {
+        channel.pending = null;
+    }
 };
-const startPolling = (subscription) => {
-    if (subscription.interval)
+const startPolling = (channel) => {
+    if (channel.interval)
         return;
-    void pushSnapshot(subscription);
-    subscription.interval = setInterval(() => {
-        void pushSnapshot(subscription);
-    }, subscription.config.intervalMs);
+    void pushSnapshot(channel);
+    channel.interval = setInterval(() => {
+        void pushSnapshot(channel);
+    }, channel.config.intervalMs);
 };
-const stopPolling = (subscription) => {
-    if (!subscription.interval)
+const stopPolling = (channel) => {
+    if (!channel.interval)
         return;
-    clearInterval(subscription.interval);
-    subscription.interval = null;
+    clearInterval(channel.interval);
+    channel.interval = null;
+};
+const getOrCreateChannel = (config) => {
+    const key = buildChannelKey(config);
+    const existing = channels.get(key);
+    if (existing)
+        return existing;
+    const channel = {
+        key,
+        config,
+        callbacks: new Set(),
+        interval: null,
+        lastPayload: null,
+        pending: null,
+    };
+    channels.set(key, channel);
+    return channel;
 };
 export const QueueMonitoringService = Object.freeze({
     subscribe(callback, config) {
         const existing = subscriptions.get(callback);
         if (existing) {
-            stopPolling(existing);
+            const existingChannel = channels.get(existing.channelKey);
+            existingChannel?.callbacks.delete(callback);
+            if (existingChannel?.callbacks.size === 0) {
+                stopPolling(existingChannel);
+                channels.delete(existingChannel.key);
+            }
             subscriptions.delete(callback);
         }
+        const channel = getOrCreateChannel(config);
+        channel.callbacks.add(callback);
         const subscription = {
             callback,
             config,
-            interval: null,
+            channelKey: channel.key,
         };
         subscriptions.set(callback, subscription);
-        startPolling(subscription);
+        if (channel.lastPayload) {
+            callback(channel.lastPayload);
+        }
+        startPolling(channel);
     },
     unsubscribe(callback) {
         const subscription = subscriptions.get(callback);
         if (!subscription)
             return;
-        stopPolling(subscription);
+        const channel = channels.get(subscription.channelKey);
+        channel?.callbacks.delete(callback);
+        if (channel?.callbacks.size === 0) {
+            stopPolling(channel);
+            channels.delete(channel.key);
+        }
         subscriptions.delete(callback);
     },
 });

package/dist/build-manifest.json

@@ -1,14 +1,14 @@
 {
   "name": "@zintrust/queue-monitor",
-  "version": "0.4.75",
-  "buildDate": "2026-04-07T17:13:57.726Z",
+  "version": "0.4.86",
+  "buildDate": "2026-04-09T08:06:22.134Z",
   "buildEnvironment": {
     "node": "v20.20.2",
     "platform": "linux",
     "arch": "x64"
   },
   "git": {
-    "commit": "f910e7ec",
+    "commit": "a456e7ec",
     "branch": "master"
   },
   "package": {
@@ -29,8 +29,8 @@
       "sha256": "26a91f1b41d8a976a9e8fabaedc3fe6dc955c700499f0afc1a16fb91c9848665"
     },
     "QueueMonitoringService.js": {
-      "size": 6679,
-      "sha256": "edd069c1229071078223cd23cbb7bdae9cbb2431ae603ab35f0cfcb7cd1f6ffe"
+      "size": 8900,
+      "sha256": "0d00a27755a372ce77bb5921ce25fe024d3e57274cd48f963457f76bf5486e4b"
     },
     "connection.d.ts": {
       "size": 107,
@@ -62,7 +62,7 @@
     },
     "index.js": {
       "size": 12870,
-      "sha256": "b4ece7788fcd3f7f329c324f5c4cc0e807619d482211cb5d7ceb21303477461c"
+      "sha256": "ff398e2a1d48d2ed2d469a84277d069a6e7b171f48679d2d1b6b6d39a8e53b67"
     },
     "metrics.d.ts": {
       "size": 868,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/queue-monitor",
-  "version": "0.4.75",
+  "version": "0.4.86",
   "description": "Queue monitoring package for ZinTrust with BullMQ and Redis.",
   "private": false,
   "type": "module",
@@ -20,7 +20,7 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "^0.4.74"
+    "@zintrust/core": "^0.4.84"
   },
   "publishConfig": {
     "access": "public"