@zintrust/workers 0.1.31 → 0.1.52

package/dist/ClusterLock.js

@@ -131,8 +131,9 @@ export const ClusterLock = Object.freeze({
             Logger.warn('ClusterLock already initialized');
             return;
         }
-        redisClient = createRedisConnection(config);
-        startHeartbeat(redisClient);
+        const client = createRedisConnection(config);
+        redisClient = client;
+        startHeartbeat(client);
         Logger.info('ClusterLock initialized', { instanceId: getInstanceId() });
     },
     /**

package/dist/DeadLetterQueue.js

@@ -4,12 +4,13 @@
  * Sealed namespace for immutability
  */
 import { ErrorFactory, Logger, createRedisConnection } from '@zintrust/core';
+import { keyPrefix } from './config/workerConfig';
 // Redis key prefixes - using workers package prefix system
 const getDLQPrefix = () => {
-    return 'worker:dlq:';
+    return keyPrefix() + ':dlq:';
 };
 const getAuditPrefix = () => {
-    return 'worker:dlq:audit:';
+    return keyPrefix() + ':dlq:audit:';
 };
 // Internal state
 let redisClient = null;

package/dist/HealthMonitor.js

@@ -24,7 +24,7 @@ const persistStatusChange = async (name, status, lastError) => {
         Logger.error(`Failed to persist status change for ${name}`, err);
     }
 };
-const verifyWorkerHealth = async (worker, _name, _queueName) => {
+const verifyWorkerHealth = async (worker) => {
     // Check if isClosing exists (isClosing check safe for mocks)
     const workerAny = worker;
     const isClosingFn = workerAny['isClosing'];
@@ -40,9 +40,30 @@ const verifyWorkerHealth = async (worker, _name, _queueName) => {
     if (pingResult !== 'PONG') {
         throw ErrorFactory.createWorkerError(`Redis ping failed: ${pingResult}`);
     }
-    Logger.debug(`Worker health verification passed for ${_name} ${_queueName}`);
     return true;
 };
+const withTimeout = async (promise, timeoutMs, onTimeout) => {
+    let timeoutId = null;
+    return await new Promise((resolve, reject) => {
+        timeoutId = globalThis.setTimeout(() => {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+            reject(onTimeout());
+        }, timeoutMs);
+        timeoutId.unref();
+        promise
+            .then(resolve)
+            .catch(reject)
+            .finally(() => {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+        });
+    });
+};
 const updateState = (state, isHealthy, errorMsg, latency) => {
     const now = new Date();
     state.lastCheck = now;
@@ -108,17 +129,7 @@ const performCheck = async (state) => {
         if (!state.worker) {
             throw ErrorFactory.createWorkerError('Worker instance not available');
         }
-        isHealthy = await Promise.race([
-            verifyWorkerHealth(state.worker, state.name, state.queueName || 'unknown'),
-            new Promise((_, reject) => {
-                // eslint-disable-next-line
-                const id = setTimeout(() => {
-                    reject(ErrorFactory.createWorkerError('Health check timeout'));
-                }, config.checkTimeoutMs);
-                // Unref to prevent holding event loop if everything else finishes
-                id.unref();
-            }),
-        ]);
+        isHealthy = await withTimeout(verifyWorkerHealth(state.worker), config.checkTimeoutMs, () => ErrorFactory.createWorkerError('Health check timeout'));
     }
     catch (err) {
         isHealthy = false;

package/dist/Observability.js

@@ -16,6 +16,11 @@ const activeSpans = new Map();
 let spanSweepInterval = null;
 const MAX_ACTIVE_SPANS = 1000;
 const SPAN_TTL_MS = 5 * 60 * 1000;
+const isUnrefableTimer = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return 'unref' in value && typeof value.unref === 'function';
+};
 const cleanupStaleSpans = () => {
     const now = Date.now();
     for (const [spanId, entry] of activeSpans.entries()) {
@@ -155,6 +160,9 @@ export const Observability = Object.freeze({
             spanSweepInterval = setInterval(() => {
                 cleanupStaleSpans();
             }, SPAN_TTL_MS);
+            if (isUnrefableTimer(spanSweepInterval)) {
+                spanSweepInterval.unref();
+            }
         }
         Logger.info('Observability initialized', {
             prometheus: config.prometheus.enabled,

package/dist/WorkerFactory.d.ts

@@ -111,6 +111,10 @@ export declare const WorkerFactory: Readonly<{
     registerProcessorSpec: (spec: string, processor: WorkerFactoryConfig["processor"]) => void;
     resolveProcessorPath: (modulePath: string) => Promise<WorkerFactoryConfig["processor"] | undefined>;
     resolveProcessorSpec: (spec: string) => Promise<WorkerFactoryConfig["processor"] | undefined>;
+    /**
+     * Register a new worker configuration without starting it.
+     */
+    register(config: WorkerFactoryConfig): Promise<void>;
     /**
      * Create new worker with full setup
      */