@zintrust/workers 0.1.28 → 0.1.30

package/dist/ResourceMonitor.js

@@ -93,6 +93,16 @@ const safeUptime = () => {
         return 0;
     }
 };
+const safeProcessCpuUsage = () => {
+    if (!process?.cpuUsage)
+        return { user: 0, system: 0 };
+    try {
+        return process.cpuUsage();
+    }
+    catch {
+        return { user: 0, system: 0 };
+    }
+};
 // Default cost configuration (AWS-like pricing)
 const DEFAULT_COST_CONFIG = {
     computeCostPerCoreHour: 0.0416, // ~$0.0416 per vCPU hour (t3.medium equivalent)
@@ -106,6 +116,9 @@ let costConfig = { ...DEFAULT_COST_CONFIG };
 let monitoringInterval = null;
 const resourceHistory = new Map();
 const alertHistory = new Map();
+// Memory management constants
+const MAX_HISTORY_SIZE = 1000; // Keep last 1000 snapshots per worker
+const MAX_ALERT_HISTORY = 100; // Keep last 100 alerts per worker
 // Resource thresholds
 const THRESHOLDS = {
     cpu: { warning: 70, critical: 90 },
@@ -113,30 +126,51 @@ const THRESHOLDS = {
     disk: { warning: 80, critical: 90 },
     costPerHour: { warning: 10, critical: 50 },
 };
-// Previous CPU usage for delta calculation
-let previousCpuUsage = null;
-let previousCpuTimestamp = null;
+// Store previous CPU measurements for calculating real-time usage
+let previousCpuTimes = null;
 /**
- * Helper: Calculate CPU usage percentage
+ * Helper: Calculate CPU usage percentage (real-time)
  */
 const calculateCpuUsage = () => {
-    const currentCpuUsage = process.cpuUsage();
-    const currentTimestamp = Date.now();
-    if (previousCpuUsage === null || previousCpuTimestamp === null) {
-        previousCpuUsage = currentCpuUsage;
-        previousCpuTimestamp = currentTimestamp;
+    const os = getOsModule();
+    if (!os?.cpus)
         return 0;
-    }
-    const userDelta = currentCpuUsage.user - previousCpuUsage.user;
-    const systemDelta = currentCpuUsage.system - previousCpuUsage.system;
-    const timeDelta = (currentTimestamp - previousCpuTimestamp) * 1000; // Convert ms to microseconds
-    previousCpuUsage = currentCpuUsage;
-    previousCpuTimestamp = currentTimestamp;
-    if (timeDelta === 0)
+    try {
+        const cpus = os.cpus();
+        let totalIdle = 0;
+        let totalTick = 0;
+        cpus.forEach((cpu) => {
+            for (const type in cpu.times) {
+                totalTick += cpu.times[type];
+            }
+            totalIdle += cpu.times.idle;
+        });
+        const now = Date.now();
+        // If we have previous measurements, calculate real-time usage
+        if (previousCpuTimes) {
+            const timeDiff = now - previousCpuTimes.timestamp;
+            // Only calculate if enough time has passed (minimum 100ms)
+            if (timeDiff >= 100) {
+                const idleDiff = totalIdle - previousCpuTimes.idle;
+                const totalDiff = totalTick - previousCpuTimes.total;
+                // Calculate CPU usage percentage for this interval
+                const cpuPercentage = totalDiff > 0 ? ((totalDiff - idleDiff) / totalDiff) * 100 : 0;
+                // Update previous measurements
+                previousCpuTimes = { idle: totalIdle, total: totalTick, timestamp: now };
+                return Math.min(100, Math.max(0, cpuPercentage));
+            }
+        }
+        // First measurement or not enough time passed
+        previousCpuTimes = { idle: totalIdle, total: totalTick, timestamp: now };
+        // For first call, return a reasonable estimate or use load average
+        const loadAvg = safeLoadAverage();
+        const cpuCount = safeCpuCount();
+        return Math.min(100, Math.max(0, (loadAvg[0] / cpuCount) * 100));
+    }
+    catch (error) {
+        Logger.error('Failed to calculate system CPU usage', error);
         return 0;
-    const totalCpuDelta = userDelta + systemDelta;
-    const cpuPercentage = (totalCpuDelta / timeDelta) * 100;
-    return Math.min(100, Math.max(0, cpuPercentage));
+    }
 };
 /**
  * Helper: Get memory usage
@@ -181,7 +215,7 @@ const captureSnapshot = () => {
             pid: process.pid,
             uptime: process.uptime(),
             memoryUsage: process.memoryUsage(),
-            cpuUsage: process.cpuUsage(),
+            cpuUsage: safeProcessCpuUsage(),
         },
     };
 };
@@ -333,16 +367,10 @@ const storeAlert = (alert) => {
         alertHistory.set(alert.workerName, history);
     }
     history.push(alert);
-    // Keep only last 1000 alerts
-    if (history.length > 1000) {
-        history.shift();
-    }
-    Logger.warn(`Resource alert: ${alert.workerName}`, {
-        type: alert.alertType,
-        severity: alert.severity,
-        message: alert.message,
-        recommendation: alert.recommendation,
-    });
+    // Trim alert history to prevent memory leaks
+    if (history.length > MAX_ALERT_HISTORY) {
+        alertHistory.set(alert.workerName, history.slice(-MAX_ALERT_HISTORY));
+    }
 };
 /**
  * Helper: Calculate trend
@@ -385,7 +413,7 @@ const calculateTrend = (workerName, metric, period) => {
     });
     // Simple linear regression for trend
     const firstValue = values[0];
-    const lastValue = values.at(-1) ?? values[0];
+    const lastValue = values[values.length - 1] ?? values[0];
     const changePercentage = ((lastValue - firstValue) / firstValue) * 100;
     let trend;
     if (Math.abs(changePercentage) < 5) {
@@ -445,9 +473,6 @@ export const ResourceMonitor = Object.freeze({
             Logger.warn('ResourceMonitor already running');
             return;
         }
-        // Initial snapshot
-        previousCpuUsage = process.cpuUsage();
-        previousCpuTimestamp = Date.now();
         monitoringInterval = setInterval(() => {
             const snapshot = captureSnapshot();
             // Store snapshot for later analysis
@@ -483,13 +508,15 @@ export const ResourceMonitor = Object.freeze({
             resourceHistory.set(workerName, history);
         }
         history.push(snapshot);
-        // Keep only last 1000 snapshots
-        if (history.length > 1000) {
-            history.shift();
+        // Trim resource history to prevent memory leaks
+        if (history.length > MAX_HISTORY_SIZE) {
+            resourceHistory.set(workerName, history.slice(-MAX_HISTORY_SIZE));
         }
         // Check thresholds
         const alerts = checkThresholds(workerName, snapshot, cost);
-        alerts.forEach(storeAlert);
+        alerts.forEach((element) => {
+            storeAlert(element);
+        });
         return {
             workerName,
             cpu: snapshot.cpu.usage,

package/dist/WorkerFactory.d.ts

@@ -24,9 +24,10 @@ export type WorkerFactoryConfig = {
     version?: string;
     queueName: string;
     processor: (job: Job) => Promise<unknown>;
-    processorPath?: string;
+    processorSpec?: string;
     options?: WorkerOptions;
     autoStart?: boolean;
+    activeStatus?: boolean;
     infrastructure?: {
         redis?: RedisConfigInput;
         persistence?: WorkerPersistenceConfig;
@@ -98,7 +99,7 @@ type ObservabilityConfigInput = ObservabilityConfig | {
     openTelemetry?: Partial<ObservabilityConfig['openTelemetry']>;
     datadog?: Partial<ObservabilityConfig['datadog']>;
 };
-type ProcessorResolver = (name: string) => WorkerFactoryConfig['processor'] | undefined | Promise<WorkerFactoryConfig['processor'] | undefined>;
+export type ProcessorResolver = (name: string) => WorkerFactoryConfig['processor'] | undefined | Promise<WorkerFactoryConfig['processor'] | undefined>;
 /**
  * Worker Factory - Sealed namespace
  */
@@ -107,7 +108,9 @@ export declare const WorkerFactory: Readonly<{
     registerProcessors: (processors: Record<string, WorkerFactoryConfig["processor"]>) => void;
     registerProcessorPaths: (paths: Record<string, string>) => void;
     registerProcessorResolver: (resolver: ProcessorResolver) => void;
+    registerProcessorSpec: (spec: string, processor: WorkerFactoryConfig["processor"]) => void;
     resolveProcessorPath: (modulePath: string) => Promise<WorkerFactoryConfig["processor"] | undefined>;
+    resolveProcessorSpec: (spec: string) => Promise<WorkerFactoryConfig["processor"] | undefined>;
     /**
      * Create new worker with full setup
      */
@@ -123,7 +126,9 @@ export declare const WorkerFactory: Readonly<{
     /**
      * Stop worker
      */
-    stop(name: string, persistenceOverride?: WorkerPersistenceConfig): Promise<void>;
+    stop(name: string, persistenceOverride?: WorkerPersistenceConfig, options?: {
+        skipPersistedUpdate?: boolean;
+    }): Promise<void>;
     /**
      * Restart worker
      */
@@ -140,6 +145,14 @@ export declare const WorkerFactory: Readonly<{
      * Update auto-start for persisted worker
      */
     setAutoStart(name: string, autoStart: boolean, persistenceOverride?: WorkerPersistenceConfig): Promise<void>;
+    /**
+     * Update active status for a worker
+     */
+    setWorkerActiveStatus(name: string, activeStatus: boolean, persistenceOverride?: WorkerPersistenceConfig): Promise<void>;
+    /**
+     * Get active status for a worker
+     */
+    getWorkerActiveStatus(name: string, persistenceOverride?: WorkerPersistenceConfig): Promise<boolean | null>;
     /**
      * Update persisted worker record and in-memory config if running.
      */
@@ -159,11 +172,13 @@ export declare const WorkerFactory: Readonly<{
         offset?: number;
         limit?: number;
         search?: string;
+        includeInactive?: boolean;
     }): Promise<string[]>;
     listPersistedRecords(persistenceOverride?: WorkerPersistenceConfig, options?: {
         offset?: number;
         limit?: number;
         search?: string;
+        includeInactive?: boolean;
     }): Promise<WorkerRecord[]>;
     /**
      * Start a worker from persisted storage when it is not registered.
@@ -189,5 +204,10 @@ export declare const WorkerFactory: Readonly<{
      * Shutdown all workers
      */
     shutdown(): Promise<void>;
+    /**
+     * Reset persistence connection state.
+     * Useful when connections become stale in long-running processes or serverless environments.
+     */
+    resetPersistence(): Promise<void>;
 }>;
 export {};