pms_md 1.0.0

package/node-monitor/src/monitors/serverHealthMonitor.js

@@ -0,0 +1,320 @@
+/**
+ * Server Health Monitor
+ * Monitors server uptime and provides health check endpoints
+ */
+
+const cron = require('node-cron');
+
+class ServerHealthMonitor {
+  constructor(config, logger, notificationManager) {
+    this.config = config;
+    this.logger = logger;
+    this.notificationManager = notificationManager;
+    this.startTime = Date.now();
+    this.isHealthy = true;
+    this.healthChecks = [];
+    this.cronJob = null;
+    this.consecutiveFailures = 0;
+    this.lastHealthStatus = true;
+  }
+
+  /**
+   * Start health monitoring
+   */
+  start() {
+    if (!this.config.healthCheck.enabled) {
+      return;
+    }
+
+    this.logger.logInfo('Server health monitoring started');
+
+    // Schedule periodic health checks
+    const intervalMinutes = Math.max(1, Math.floor(this.config.intervals.health / 60000));
+    const cronExpression = `*/${intervalMinutes} * * * *`;
+
+    this.cronJob = cron.schedule(cronExpression, async () => {
+      await this.performHealthCheck();
+    });
+
+    // Perform initial health check
+    this.performHealthCheck();
+  }
+
+  /**
+   * Stop health monitoring
+   */
+  stop() {
+    if (this.cronJob) {
+      this.cronJob.stop();
+      this.logger.logInfo('Server health monitoring stopped');
+    }
+  }
+
+  /**
+   * Register a custom health check
+   */
+  registerHealthCheck(name, checkFunction) {
+    this.healthChecks.push({
+      name,
+      check: checkFunction
+    });
+    this.logger.logInfo(`Registered health check: ${name}`);
+  }
+
+  /**
+   * Perform health check
+   */
+  async performHealthCheck() {
+    const results = {
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+      uptime: this.getUptime(),
+      checks: {}
+    };
+
+    let allHealthy = true;
+
+    // Run all registered health checks
+    for (const healthCheck of this.healthChecks) {
+      try {
+        const checkResult = await Promise.race([
+          healthCheck.check(),
+          this.timeout(this.config.healthCheck.timeout)
+        ]);
+
+        results.checks[healthCheck.name] = {
+          status: checkResult ? 'pass' : 'fail',
+          ...(typeof checkResult === 'object' && checkResult)
+        };
+
+        if (!checkResult) {
+          allHealthy = false;
+        }
+      } catch (error) {
+        results.checks[healthCheck.name] = {
+          status: 'fail',
+          error: error.message
+        };
+        allHealthy = false;
+      }
+    }
+
+    results.status = allHealthy ? 'healthy' : 'unhealthy';
+    this.isHealthy = allHealthy;
+
+    // Handle health status changes
+    await this.handleHealthStatusChange(allHealthy, results);
+
+    return results;
+  }
+
+  /**
+   * Handle health status changes
+   */
+  async handleHealthStatusChange(isHealthy, results) {
+    if (!isHealthy) {
+      this.consecutiveFailures++;
+
+      // Send alert if threshold reached
+      if (this.consecutiveFailures >= this.config.thresholds.consecutiveFailures) {
+        if (this.lastHealthStatus) {
+          // Status changed from healthy to unhealthy
+          await this.notificationManager.sendCritical(
+            'Server Health Check Failed',
+            `Server health checks have failed ${this.consecutiveFailures} consecutive times`,
+            {
+              consecutiveFailures: this.consecutiveFailures,
+              failedChecks: Object.entries(results.checks)
+                .filter(([_, check]) => check.status === 'fail')
+                .map(([name]) => name)
+                .join(', '),
+              uptime: this.getUptimeFormatted()
+            }
+          );
+        }
+      }
+
+      this.lastHealthStatus = false;
+    } else {
+      // Recovery
+      if (!this.lastHealthStatus && this.consecutiveFailures >= this.config.thresholds.consecutiveFailures) {
+        await this.notificationManager.sendRecovery(
+          'Server Health Restored',
+          'All health checks are now passing',
+          {
+            previousFailures: this.consecutiveFailures,
+            uptime: this.getUptimeFormatted()
+          }
+        );
+      }
+
+      this.consecutiveFailures = 0;
+      this.lastHealthStatus = true;
+    }
+  }
+
+  /**
+   * Get health check endpoint middleware
+   */
+  healthCheckEndpoint() {
+    return async (req, res) => {
+      const healthStatus = await this.performHealthCheck();
+      const statusCode = healthStatus.status === 'healthy' ? 200 : 503;
+      
+      res.status(statusCode).json(healthStatus);
+    };
+  }
+
+  /**
+   * Get basic health info endpoint
+   */
+  healthInfoEndpoint() {
+    return (req, res) => {
+      res.json({
+        status: this.isHealthy ? 'healthy' : 'unhealthy',
+        uptime: this.getUptimeFormatted(),
+        timestamp: new Date().toISOString(),
+        application: {
+          name: this.config.app.name,
+          version: this.config.app.version,
+          environment: this.config.app.environment
+        },
+        process: {
+          pid: process.pid,
+          nodeVersion: process.version,
+          platform: process.platform
+        }
+      });
+    };
+  }
+
+  /**
+   * Get uptime in seconds
+   */
+  getUptime() {
+    return Math.floor((Date.now() - this.startTime) / 1000);
+  }
+
+  /**
+   * Get formatted uptime
+   */
+  getUptimeFormatted() {
+    const uptime = this.getUptime();
+    const days = Math.floor(uptime / 86400);
+    const hours = Math.floor((uptime % 86400) / 3600);
+    const minutes = Math.floor((uptime % 3600) / 60);
+    const seconds = uptime % 60;
+
+    const parts = [];
+    if (days > 0) parts.push(`${days}d`);
+    if (hours > 0) parts.push(`${hours}h`);
+    if (minutes > 0) parts.push(`${minutes}m`);
+    parts.push(`${seconds}s`);
+
+    return parts.join(' ');
+  }
+
+  /**
+   * Timeout helper
+   */
+  timeout(ms) {
+    return new Promise((_, reject) => 
+      setTimeout(() => reject(new Error('Health check timeout')), ms)
+    );
+  }
+
+  /**
+   * Get current health status
+   */
+  getStatus() {
+    return {
+      isHealthy: this.isHealthy,
+      uptime: this.getUptime(), // Return numeric seconds instead of formatted string
+      uptimeFormatted: this.getUptimeFormatted(), // Also include formatted version
+      consecutiveFailures: this.consecutiveFailures,
+      registeredChecks: this.healthChecks.length
+    };
+  }
+
+  /**
+   * Handle graceful shutdown
+   */
+  async handleShutdown(signal) {
+    this.logger.logWarning('shutdown', `Received ${signal} signal, shutting down gracefully`);
+    
+    await this.notificationManager.sendWarning(
+      'Server Shutdown Initiated',
+      `Server received ${signal} signal and is shutting down`,
+      {
+        signal,
+        uptime: this.getUptimeFormatted(),
+        timestamp: new Date().toISOString()
+      }
+    );
+
+    this.stop();
+  }
+
+  /**
+   * Setup graceful shutdown handlers
+   */
+  setupGracefulShutdown(server) {
+    const signals = ['SIGTERM', 'SIGINT'];
+    
+    signals.forEach(signal => {
+      process.on(signal, async () => {
+        await this.handleShutdown(signal);
+        
+        // Close server
+        server.close(() => {
+          this.logger.logInfo('Server closed');
+          process.exit(0);
+        });
+
+        // Force close after timeout
+        setTimeout(() => {
+          this.logger.logWarning('forced_shutdown', 'Forcing shutdown after timeout');
+          process.exit(1);
+        }, 10000);
+      });
+    });
+
+    // Handle uncaught exceptions
+    process.on('uncaughtException', async (error) => {
+      this.logger.logSystemError('uncaught_exception', 'Uncaught Exception', {
+        error: error.message,
+        stack: error.stack
+      });
+
+      await this.notificationManager.sendCritical(
+        'Uncaught Exception',
+        error.message,
+        {
+          stack: error.stack,
+          uptime: this.getUptimeFormatted()
+        }
+      );
+
+      process.exit(1);
+    });
+
+    // Handle unhandled promise rejections
+    process.on('unhandledRejection', async (reason, promise) => {
+      this.logger.logSystemError('unhandled_rejection', 'Unhandled Promise Rejection', {
+        reason: String(reason),
+        promise: String(promise)
+      });
+
+      await this.notificationManager.sendCritical(
+        'Unhandled Promise Rejection',
+        String(reason),
+        {
+          uptime: this.getUptimeFormatted()
+        }
+      );
+    });
+  }
+}
+
+module.exports = ServerHealthMonitor;
+

package/node-monitor/src/monitors/systemResourceMonitor.js

@@ -0,0 +1,357 @@
+/**
+ * System Resource Monitor
+ * Monitors CPU, memory, and other system resources
+ */
+
+const os = require('os');
+const cron = require('node-cron');
+
+class SystemResourceMonitor {
+  constructor(config, logger, notificationManager) {
+    this.config = config;
+    this.logger = logger;
+    this.notificationManager = notificationManager;
+    this.cronJob = null;
+    this.metrics = {
+      cpu: [],
+      memory: []
+    };
+    this.maxMetricsHistory = 60; // Keep last 60 readings
+    this.consecutiveHighCpu = 0;
+    this.consecutiveHighMemory = 0;
+    this.lastCpuAlert = 0;
+    this.lastMemoryAlert = 0;
+  }
+
+  /**
+   * Start system monitoring
+   */
+  start() {
+    if (!this.config.system.enabled) {
+      return;
+    }
+
+    this.logger.logInfo('System resource monitoring started');
+
+    // Schedule periodic checks
+    const intervalMinutes = Math.max(1, Math.floor(this.config.intervals.system / 60000));
+    const cronExpression = `*/${intervalMinutes} * * * *`;
+
+    this.cronJob = cron.schedule(cronExpression, async () => {
+      await this.collectMetrics();
+    });
+
+    // Collect initial metrics
+    this.collectMetrics();
+  }
+
+  /**
+   * Stop system monitoring
+   */
+  stop() {
+    if (this.cronJob) {
+      this.cronJob.stop();
+      this.logger.logInfo('System resource monitoring stopped');
+    }
+  }
+
+  /**
+   * Collect system metrics
+   */
+  async collectMetrics() {
+    const metrics = {
+      timestamp: new Date().toISOString(),
+      cpu: null,
+      memory: null,
+      eventLoop: null
+    };
+
+    // Collect CPU metrics
+    if (this.config.system.trackCpu) {
+      metrics.cpu = await this.getCpuUsage();
+      this.addMetric('cpu', metrics.cpu);
+      await this.checkCpuThreshold(metrics.cpu);
+    }
+
+    // Collect memory metrics
+    if (this.config.system.trackMemory) {
+      metrics.memory = this.getMemoryUsage();
+      this.addMetric('memory', metrics.memory);
+      await this.checkMemoryThreshold(metrics.memory);
+    }
+
+    // Collect event loop lag (if enabled)
+    if (this.config.system.trackEventLoop) {
+      metrics.eventLoop = this.getEventLoopLag();
+    }
+
+    this.logger.logInfo('System metrics collected', metrics);
+
+    return metrics;
+  }
+
+  /**
+   * Get CPU usage percentage
+   */
+  async getCpuUsage() {
+    const startUsage = process.cpuUsage();
+    const startTime = Date.now();
+
+    // Wait 100ms to measure CPU usage
+    await new Promise(resolve => setTimeout(resolve, 100));
+
+    const endUsage = process.cpuUsage(startUsage);
+    const endTime = Date.now();
+
+    const elapsedTime = (endTime - startTime) * 1000; // Convert to microseconds
+    const totalUsage = endUsage.user + endUsage.system;
+    const cpuPercent = (totalUsage / elapsedTime) * 100;
+
+    // Get system-wide CPU info
+    const cpus = os.cpus();
+    const systemCpuUsage = this.getSystemCpuUsage(cpus);
+
+    return {
+      process: Math.round(cpuPercent * 100) / 100,
+      system: Math.round(systemCpuUsage * 100) / 100,
+      cores: cpus.length
+    };
+  }
+
+  /**
+   * Get system-wide CPU usage
+   */
+  getSystemCpuUsage(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 idle = totalIdle / cpus.length;
+    const total = totalTick / cpus.length;
+    const usage = 100 - (100 * idle / total);
+
+    return usage;
+  }
+
+  /**
+   * Get memory usage
+   */
+  getMemoryUsage() {
+    const totalMemory = os.totalmem();
+    const freeMemory = os.freemem();
+    const usedMemory = totalMemory - freeMemory;
+
+    const processMemory = process.memoryUsage();
+
+    return {
+      system: {
+        total: this.formatBytes(totalMemory),
+        used: this.formatBytes(usedMemory),
+        free: this.formatBytes(freeMemory),
+        usagePercent: Math.round((usedMemory / totalMemory) * 100 * 100) / 100
+      },
+      process: {
+        rss: this.formatBytes(processMemory.rss),
+        heapTotal: this.formatBytes(processMemory.heapTotal),
+        heapUsed: this.formatBytes(processMemory.heapUsed),
+        external: this.formatBytes(processMemory.external),
+        heapUsagePercent: Math.round((processMemory.heapUsed / processMemory.heapTotal) * 100 * 100) / 100
+      }
+    };
+  }
+
+  /**
+   * Get event loop lag
+   */
+  getEventLoopLag() {
+    const start = Date.now();
+    
+    setImmediate(() => {
+      const lag = Date.now() - start;
+      return lag;
+    });
+
+    return 0; // Simplified for now
+  }
+
+  /**
+   * Format bytes to human-readable format
+   */
+  formatBytes(bytes) {
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    if (bytes === 0) return '0 Bytes';
+    
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    const value = Math.round((bytes / Math.pow(1024, i)) * 100) / 100;
+    
+    return `${value} ${sizes[i]}`;
+  }
+
+  /**
+   * Add metric to history
+   */
+  addMetric(type, value) {
+    this.metrics[type].push({
+      timestamp: Date.now(),
+      value
+    });
+
+    // Keep only recent metrics
+    if (this.metrics[type].length > this.maxMetricsHistory) {
+      this.metrics[type].shift();
+    }
+  }
+
+  /**
+   * Check CPU threshold
+   */
+  async checkCpuThreshold(cpuMetrics) {
+    const threshold = this.config.thresholds.cpu;
+    const systemUsage = cpuMetrics.system;
+
+    if (systemUsage >= threshold) {
+      this.consecutiveHighCpu++;
+
+      if (this.consecutiveHighCpu >= this.config.thresholds.consecutiveFailures) {
+        const now = Date.now();
+        const cooldown = this.config.notifications.cooldown;
+
+        if (now - this.lastCpuAlert >= cooldown) {
+          await this.notificationManager.sendWarning(
+            'High CPU Usage Detected',
+            `System CPU usage is at ${systemUsage.toFixed(2)}%, exceeding threshold of ${threshold}%`,
+            {
+              systemCpu: `${systemUsage.toFixed(2)}%`,
+              processCpu: `${cpuMetrics.process.toFixed(2)}%`,
+              threshold: `${threshold}%`,
+              consecutiveOccurrences: this.consecutiveHighCpu,
+              cores: cpuMetrics.cores
+            }
+          );
+
+          this.lastCpuAlert = now;
+        }
+      }
+    } else {
+      // Recovery
+      if (this.consecutiveHighCpu >= this.config.thresholds.consecutiveFailures) {
+        await this.notificationManager.sendRecovery(
+          'CPU Usage Normalized',
+          `System CPU usage has returned to normal levels: ${systemUsage.toFixed(2)}%`,
+          {
+            currentCpu: `${systemUsage.toFixed(2)}%`,
+            threshold: `${threshold}%`
+          }
+        );
+      }
+      this.consecutiveHighCpu = 0;
+    }
+  }
+
+  /**
+   * Check memory threshold
+   */
+  async checkMemoryThreshold(memoryMetrics) {
+    const threshold = this.config.thresholds.memory;
+    const systemUsage = memoryMetrics.system.usagePercent;
+
+    if (systemUsage >= threshold) {
+      this.consecutiveHighMemory++;
+
+      if (this.consecutiveHighMemory >= this.config.thresholds.consecutiveFailures) {
+        const now = Date.now();
+        const cooldown = this.config.notifications.cooldown;
+
+        if (now - this.lastMemoryAlert >= cooldown) {
+          await this.notificationManager.sendWarning(
+            'High Memory Usage Detected',
+            `System memory usage is at ${systemUsage.toFixed(2)}%, exceeding threshold of ${threshold}%`,
+            {
+              systemMemory: `${systemUsage.toFixed(2)}%`,
+              used: memoryMetrics.system.used,
+              total: memoryMetrics.system.total,
+              processHeap: memoryMetrics.process.heapUsed,
+              threshold: `${threshold}%`,
+              consecutiveOccurrences: this.consecutiveHighMemory
+            }
+          );
+
+          this.lastMemoryAlert = now;
+        }
+      }
+    } else {
+      // Recovery
+      if (this.consecutiveHighMemory >= this.config.thresholds.consecutiveFailures) {
+        await this.notificationManager.sendRecovery(
+          'Memory Usage Normalized',
+          `System memory usage has returned to normal levels: ${systemUsage.toFixed(2)}%`,
+          {
+            currentMemory: `${systemUsage.toFixed(2)}%`,
+            threshold: `${threshold}%`
+          }
+        );
+      }
+      this.consecutiveHighMemory = 0;
+    }
+  }
+
+  /**
+   * Get current metrics
+   */
+  getCurrentMetrics() {
+    return {
+      cpu: this.metrics.cpu[this.metrics.cpu.length - 1]?.value || null,
+      memory: this.metrics.memory[this.metrics.memory.length - 1]?.value || null
+    };
+  }
+
+  /**
+   * Get metrics history
+   */
+  getMetricsHistory() {
+    return {
+      cpu: this.metrics.cpu,
+      memory: this.metrics.memory
+    };
+  }
+
+  /**
+   * Get system info
+   */
+  getSystemInfo() {
+    return {
+      platform: os.platform(),
+      arch: os.arch(),
+      hostname: os.hostname(),
+      cpus: os.cpus().length,
+      totalMemory: this.formatBytes(os.totalmem()),
+      uptime: this.formatUptime(os.uptime()),
+      nodeVersion: process.version
+    };
+  }
+
+  /**
+   * Format uptime
+   */
+  formatUptime(seconds) {
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor((seconds % 86400) / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+
+    const parts = [];
+    if (days > 0) parts.push(`${days}d`);
+    if (hours > 0) parts.push(`${hours}h`);
+    if (minutes > 0) parts.push(`${minutes}m`);
+
+    return parts.join(' ') || '0m';
+  }
+}
+
+module.exports = SystemResourceMonitor;
+