@zintrust/queue-monitor 0.4.49 → 0.4.60

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { type RedisConfig } from './connection';
 import { type QueueDriver } from './driver';
 import { type Metrics } from './metrics';
 export type { JobPayload } from './driver';
+export { createMetrics, type JobStatus, type JobSummary, type Metrics } from './metrics';
 export { createWorker as createQueueWorker, type QueueWorker } from './worker';
 export type QueueMonitorConfig = {
     enabled?: boolean;
@@ -11,6 +12,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,10 @@
-import { Logger, queueConfig, resolveLockPrefix, Router, } from '@zintrust/core';
+import { isArray, 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 { createMetrics } from './metrics';
 export { createWorker as createQueueWorker } from './worker';
 const DEFAULTS = {
     enabled: true,
@@ -34,6 +35,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 (isArray(knownQueues)) {
+        return normalizeQueueNames(knownQueues);
+    }
+    return [];
+}
 // Helper function to scan lock keys with pagination
 const scanLockKeys = async (client, searchPattern, maxKeys) => {
     const keys = [];
@@ -148,7 +166,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 +195,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 +292,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;