@zintrust/workers 0.1.29 → 0.1.30

package/src/ResourceMonitor.ts

@@ -88,6 +88,15 @@ const safeUptime = (): number => {
   }
 };
 
+const safeProcessCpuUsage = (): NodeJS.CpuUsage => {
+  if (!process?.cpuUsage) return { user: 0, system: 0 };
+  try {
+    return process.cpuUsage();
+  } catch {
+    return { user: 0, system: 0 };
+  }
+};
+
 export type ResourceSnapshot = {
   timestamp: Date;
   cpu: {
@@ -182,6 +191,10 @@ let monitoringInterval: NodeJS.Timeout | null = null;
 const resourceHistory = new Map<string, ResourceSnapshot[]>();
 const alertHistory = new Map<string, ResourceAlert[]>();
 
+// 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 },
@@ -190,36 +203,64 @@ const THRESHOLDS = {
   costPerHour: { warning: 10, critical: 50 },
 };
 
-// Previous CPU usage for delta calculation
-let previousCpuUsage: NodeJS.CpuUsage | null = null;
-let previousCpuTimestamp: number | null = null;
+// Store previous CPU measurements for calculating real-time usage
+let previousCpuTimes: {
+  idle: number;
+  total: number;
+  timestamp: number;
+} | null = null;
 
 /**
- * Helper: Calculate CPU usage percentage
+ * Helper: Calculate CPU usage percentage (real-time)
  */
 const calculateCpuUsage = (): number => {
-  const currentCpuUsage = process.cpuUsage();
-  const currentTimestamp = Date.now();
+  const os = getOsModule();
+  if (!os?.cpus) return 0;
 
-  if (previousCpuUsage === null || previousCpuTimestamp === null) {
-    previousCpuUsage = currentCpuUsage;
-    previousCpuTimestamp = currentTimestamp;
-    return 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 as keyof typeof cpu.times];
+      }
+      totalIdle += cpu.times.idle;
+    });
 
-  const userDelta = currentCpuUsage.user - previousCpuUsage.user;
-  const systemDelta = currentCpuUsage.system - previousCpuUsage.system;
-  const timeDelta = (currentTimestamp - previousCpuTimestamp) * 1000; // Convert ms to microseconds
+    const now = Date.now();
 
-  previousCpuUsage = currentCpuUsage;
-  previousCpuTimestamp = currentTimestamp;
+    // If we have previous measurements, calculate real-time usage
+    if (previousCpuTimes) {
+      const timeDiff = now - previousCpuTimes.timestamp;
 
-  if (timeDelta === 0) return 0;
+      // Only calculate if enough time has passed (minimum 100ms)
+      if (timeDiff >= 100) {
+        const idleDiff = totalIdle - previousCpuTimes.idle;
+        const totalDiff = totalTick - previousCpuTimes.total;
 
-  const totalCpuDelta = userDelta + systemDelta;
-  const cpuPercentage = (totalCpuDelta / timeDelta) * 100;
+        // Calculate CPU usage percentage for this interval
+        const cpuPercentage = totalDiff > 0 ? ((totalDiff - idleDiff) / totalDiff) * 100 : 0;
 
-  return Math.min(100, Math.max(0, cpuPercentage));
+        // 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 as Error);
+    return 0;
+  }
 };
 
 /**
@@ -268,7 +309,7 @@ const captureSnapshot = (): ResourceSnapshot => {
       pid: process.pid,
       uptime: process.uptime(),
       memoryUsage: process.memoryUsage(),
-      cpuUsage: process.cpuUsage(),
+      cpuUsage: safeProcessCpuUsage(),
     },
   };
 };
@@ -439,17 +480,10 @@ const storeAlert = (alert: ResourceAlert): void => {
 
   history.push(alert);
 
-  // Keep only last 1000 alerts
-  if (history.length > 1000) {
-    history.shift();
+  // Trim alert history to prevent memory leaks
+  if (history.length > MAX_ALERT_HISTORY) {
+    alertHistory.set(alert.workerName, history.slice(-MAX_ALERT_HISTORY));
   }
-
-  Logger.warn(`Resource alert: ${alert.workerName}`, {
-    type: alert.alertType,
-    severity: alert.severity,
-    message: alert.message,
-    recommendation: alert.recommendation,
-  });
 };
 
 /**
@@ -500,7 +534,7 @@ const calculateTrend = (
 
   // 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: ResourceTrend['trend'];
@@ -566,10 +600,6 @@ export const ResourceMonitor = Object.freeze({
       return;
     }
 
-    // Initial snapshot
-    previousCpuUsage = process.cpuUsage();
-    previousCpuTimestamp = Date.now();
-
     monitoringInterval = setInterval(() => {
       const snapshot = captureSnapshot();
       // Store snapshot for later analysis
@@ -611,14 +641,16 @@ export const ResourceMonitor = Object.freeze({
 
     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,