aetherframework-cluster 1.0.0

package/src/middleware/process-monitor.js

@@ -0,0 +1,925 @@
+// packages/cluster/src/middleware/process-monitor.js
+import { EventEmitter } from 'events';
+import os from 'os';
+
+/**
+ * Process Monitor Middleware - Monitors system and process metrics
+ * Provides real-time monitoring of CPU, memory, and process statistics
+ */
+class ProcessMonitorMiddleware extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      path: options.path || '/cluster/monitor',
+      auth: options.auth || null,
+      updateInterval: options.updateInterval || 5000, // 5 seconds
+      historySize: options.historySize || 100,
+      enableMetrics: options.enableMetrics !== false,
+      enableAlerts: options.enableAlerts !== false,
+      ...options
+    };
+    
+    this.metrics = {
+      cpu: [],
+      memory: [],
+      process: [],
+      system: []
+    };
+    
+    this.alerts = [];
+    this.monitoringInterval = null;
+    this.lastUpdate = null;
+    
+    // Alert thresholds
+    this.thresholds = {
+      cpu: options.cpuThreshold || 0.8, // 80%
+      memory: options.memoryThreshold || 0.8, // 80%
+      heapUsed: options.heapThreshold || 0.9, // 90%
+      eventLoopDelay: options.eventLoopThreshold || 100, // 100ms
+      ...options.thresholds
+    };
+    
+    // Initialize monitoring
+    if (this.options.enableMetrics) {
+      this.startMonitoring();
+    }
+  }
+  
+  /**
+   * Get middleware function for HTTP framework integration
+   * @returns {Function} Middleware function
+   */
+  middleware() {
+    return async (ctx, next) => {
+      // Only handle monitor routes
+      if (!ctx.path.startsWith(this.options.path)) {
+        return next();
+      }
+      
+      // Check authentication if required
+      if (this.options.auth && !this.checkAuth(ctx)) {
+        ctx.status = 401;
+        ctx.body = {
+          status: 'error',
+          message: 'Unauthorized',
+          timestamp: new Date().toISOString()
+        };
+        return;
+      }
+      
+      try {
+        // Handle different monitor endpoints
+        if (ctx.path === this.options.path) {
+          await this.handleMonitorOverview(ctx);
+        } else if (ctx.path === `${this.options.path}/metrics`) {
+          await this.handleMetrics(ctx);
+        } else if (ctx.path === `${this.options.path}/metrics/:metric`) {
+          await this.handleMetricDetail(ctx);
+        } else if (ctx.path === `${this.options.path}/alerts`) {
+          await this.handleAlerts(ctx);
+        } else if (ctx.path === `${this.options.path}/system`) {
+          await this.handleSystemInfo(ctx);
+        } else if (ctx.path === `${this.options.path}/process`) {
+          await this.handleProcessInfo(ctx);
+        } else if (ctx.path === `${this.options.path}/history`) {
+          await this.handleHistory(ctx);
+        } else if (ctx.path === `${this.options.path}/reset`) {
+          await this.handleReset(ctx);
+        } else {
+          ctx.status = 404;
+          ctx.body = {
+            status: 'error',
+            message: 'Monitor endpoint not found',
+            timestamp: new Date().toISOString()
+          };
+        }
+      } catch (error) {
+        console.error('Process monitor middleware error:', error);
+        
+        ctx.status = 500;
+        ctx.body = {
+          status: 'error',
+          timestamp: new Date().toISOString(),
+          message: 'Failed to get monitor data',
+          error: error.message,
+          stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+        };
+      }
+    };
+  }
+  
+  /**
+   * Handle monitor overview request
+   * @param {Object} ctx - Context object
+   */
+  async handleMonitorOverview(ctx) {
+    const metrics = this.collectMetrics();
+    const alerts = this.getActiveAlerts();
+    
+    ctx.status = 200;
+    ctx.body = {
+      status: 'success',
+      timestamp: new Date().toISOString(),
+      overview: {
+        cpu: {
+          usage: metrics.cpu.usage,
+          cores: metrics.cpu.cores,
+          loadAverage: metrics.cpu.loadAverage,
+          threshold: this.thresholds.cpu,
+          status: metrics.cpu.usage > this.thresholds.cpu ? 'warning' : 'normal'
+        },
+        memory: {
+          usage: metrics.memory.usage,
+          total: metrics.memory.total,
+          free: metrics.memory.free,
+          threshold: this.thresholds.memory,
+          status: metrics.memory.usage > this.thresholds.memory ? 'warning' : 'normal'
+        },
+        process: {
+          uptime: metrics.process.uptime,
+          memory: metrics.process.memory,
+          cpu: metrics.process.cpu,
+          eventLoop: metrics.process.eventLoop,
+          status: this.getProcessStatus(metrics.process)
+        },
+        system: {
+          platform: metrics.system.platform,
+          arch: metrics.system.arch,
+          uptime: metrics.system.uptime,
+          hostname: metrics.system.hostname
+        }
+      },
+      alerts: {
+        active: alerts.length,
+        critical: alerts.filter(a => a.severity === 'critical').length,
+        warning: alerts.filter(a => a.severity === 'warning').length,
+        info: alerts.filter(a => a.severity === 'info').length
+      },
+      history: {
+        cpu: this.metrics.cpu.length,
+        memory: this.metrics.memory.length,
+        process: this.metrics.process.length,
+        system: this.metrics.system.length
+      }
+    };
+  }
+  
+  /**
+   * Handle metrics request
+   * @param {Object} ctx - Context object
+   */
+  async handleMetrics(ctx) {
+    const query = ctx.query || {};
+    const limit = parseInt(query.limit) || 50;
+    const offset = parseInt(query.offset) || 0;
+    
+    const metrics = {
+      cpu: this.metrics.cpu.slice(-limit - offset).slice(0, limit),
+      memory: this.metrics.memory.slice(-limit - offset).slice(0, limit),
+      process: this.metrics.process.slice(-limit - offset).slice(0, limit),
+      system: this.metrics.system.slice(-limit - offset).slice(0, limit)
+    };
+    
+    ctx.status = 200;
+    ctx.body = {
+      status: 'success',
+      timestamp: new Date().toISOString(),
+      metrics,
+      pagination: {
+        limit,
+        offset,
+        total: {
+          cpu: this.metrics.cpu.length,
+          memory: this.metrics.memory.length,
+          process: this.metrics.process.length,
+          system: this.metrics.system.length
+        }
+      }
+    };
+  }
+  
+  /**
+   * Handle metric detail request
+   * @param {Object} ctx - Context object
+   */
+  async handleMetricDetail(ctx) {
+    const metric = ctx.params.metric;
+    const query = ctx.query || {};
+    const limit = parseInt(query.limit) || 100;
+    const offset = parseInt(query.offset) || 0;
+    
+    if (!['cpu', 'memory', 'process', 'system'].includes(metric)) {
+      ctx.status = 400;
+      ctx.body = {
+        status: 'error',
+        message: 'Invalid metric type',
+        timestamp: new Date().toISOString(),
+        validMetrics: ['cpu', 'memory', 'process', 'system']
+      };
+      return;
+    }
+    
+    const metricData = this.metrics[metric];
+    const data = metricData.slice(-limit - offset).slice(0, limit);
+    
+    ctx.status = 200;
+    ctx.body = {
+      status: 'success',
+      timestamp: new Date().toISOString(),
+      metric,
+      data,
+      summary: this.getMetricSummary(metric, data),
+      pagination: {
+        limit,
+        offset,
+        total: metricData.length
+      }
+    };
+  }
+  
+  /**
+   * Handle alerts request
+   * @param {Object} ctx - Context object
+   */
+  async handleAlerts(ctx) {
+    const query = ctx.query || {};
+    const severity = query.severity;
+    const resolved = query.resolved === 'true';
+    const limit = parseInt(query.limit) || 50;
+    const offset = parseInt(query.offset) || 0;
+    
+    let alerts = this.alerts;
+    
+    // Filter by severity
+    if (severity) {
+      alerts = alerts.filter(alert => alert.severity === severity);
+    }
+    
+    // Filter by resolved status
+    alerts = alerts.filter(alert => alert.resolved === resolved);
+    
+    // Apply pagination
+    const paginatedAlerts = alerts.slice(-limit - offset).slice(0, limit);
+    
+    ctx.status = 200;
+    ctx.body = {
+      status: 'success',
+      timestamp: new Date().toISOString(),
+      alerts: paginatedAlerts,
+      summary: {
+        total: this.alerts.length,
+        active: this.alerts.filter(a => !a.resolved).length,
+        critical: this.alerts.filter(a => a.severity === 'critical' && !a.resolved).length,
+        warning: this.alerts.filter(a => a.severity === 'warning' && !a.resolved).length,
+        info: this.alerts.filter(a => a.severity === 'info' && !a.resolved).length
+      },
+      pagination: {
+        limit,
+        offset,
+        total: alerts.length
+      }
+    };
+  }
+  
+  /**
+   * Handle system info request
+   * @param {Object} ctx - Context object
+   */
+  async handleSystemInfo(ctx) {
+    const systemInfo = this.getSystemInfo();
+    
+    ctx.status = 200;
+    ctx.body = {
+      status: 'success',
+      timestamp: new Date().toISOString(),
+      system: systemInfo
+    };
+  }
+  
+  /**
+   * Handle process info request
+   * @param {Object} ctx - Context object
+   */
+  async handleProcessInfo(ctx) {
+    const processInfo = this.getProcessInfo();
+    
+    ctx.status = 200;
+    ctx.body = {
+      status: 'success',
+      timestamp: new Date().toISOString(),
+      process: processInfo
+    };
+  }
+  
+  /**
+   * Handle history request
+   * @param {Object} ctx - Context object
+   */
+  async handleHistory(ctx) {
+    const query = ctx.query || {};
+    const duration = parseInt(query.duration) || 3600000; // 1 hour in milliseconds
+    const now = Date.now();
+    
+    const filteredMetrics = {
+      cpu: this.metrics.cpu.filter(m => now - m.timestamp <= duration),
+      memory: this.metrics.memory.filter(m => now - m.timestamp <= duration),
+      process: this.metrics.process.filter(m => now - m.timestamp <= duration),
+      system: this.metrics.system.filter(m => now - m.timestamp <= duration)
+    };
+    
+    ctx.status = 200;
+    ctx.body = {
+      status: 'success',
+      timestamp: new Date().toISOString(),
+      duration,
+      metrics: filteredMetrics,
+      summary: {
+        cpu: this.getMetricSummary('cpu', filteredMetrics.cpu),
+        memory: this.getMetricSummary('memory', filteredMetrics.memory),
+        process: this.getMetricSummary('process', filteredMetrics.process)
+      }
+    };
+  }
+  
+  /**
+   * Handle reset request
+   * @param {Object} ctx - Context object
+   */
+  async handleReset(ctx) {
+    // Check authentication if required
+    if (this.options.auth && !this.checkAuth(ctx)) {
+      ctx.status = 401;
+      ctx.body = {
+        status: 'error',
+        message: 'Unauthorized',
+        timestamp: new Date().toISOString()
+      };
+      return;
+    }
+    
+    this.resetMetrics();
+    
+    ctx.status = 200;
+    ctx.body = {
+      status: 'success',
+      message: 'Metrics reset successfully',
+      timestamp: new Date().toISOString()
+    };
+  }
+  
+  /**
+   * Start monitoring
+   */
+  startMonitoring() {
+    if (this.monitoringInterval) {
+      console.warn('Process monitor already started');
+      return;
+    }
+    
+    console.log('🚀 Starting process monitor...');
+    
+    // Collect initial metrics
+    this.collectAndStoreMetrics();
+    
+    // Start periodic monitoring
+    this.monitoringInterval = setInterval(() => {
+      this.collectAndStoreMetrics();
+    }, this.options.updateInterval);
+    
+    console.log(`✅ Process monitor started with ${this.options.updateInterval}ms interval`);
+  }
+  
+  /**
+   * Stop monitoring
+   */
+  stopMonitoring() {
+    if (this.monitoringInterval) {
+      clearInterval(this.monitoringInterval);
+      this.monitoringInterval = null;
+      console.log('🛑 Process monitor stopped');
+    }
+  }
+  
+  /**
+   * Collect and store metrics
+   */
+  collectAndStoreMetrics() {
+    try {
+      const metrics = this.collectMetrics();
+      const timestamp = Date.now();
+      
+      // Store metrics
+      this.metrics.cpu.push({
+        timestamp,
+        usage: metrics.cpu.usage,
+        loadAverage: metrics.cpu.loadAverage,
+        cores: metrics.cpu.cores
+      });
+      
+      this.metrics.memory.push({
+        timestamp,
+        usage: metrics.memory.usage,
+        total: metrics.memory.total,
+        free: metrics.memory.free,
+        used: metrics.memory.used
+      });
+      
+      this.metrics.process.push({
+        timestamp,
+        memory: metrics.process.memory,
+        cpu: metrics.process.cpu,
+        eventLoop: metrics.process.eventLoop,
+        uptime: metrics.process.uptime
+      });
+      
+      this.metrics.system.push({
+        timestamp,
+        platform: metrics.system.platform,
+        arch: metrics.system.arch,
+        uptime: metrics.system.uptime,
+        hostname: metrics.system.hostname
+      });
+      
+      // Limit history size
+      this.limitHistory();
+      
+      // Check for alerts
+      this.checkAlerts(metrics);
+      
+      this.lastUpdate = timestamp;
+      this.emit('metrics:collected', { metrics, timestamp });
+      
+    } catch (error) {
+      console.error('Error collecting metrics:', error);
+      this.emit('metrics:error', { error });
+    }
+  }
+  
+  /**
+   * Collect current metrics
+   * @returns {Object} Collected metrics
+   */
+  collectMetrics() {
+    const cpuUsage = this.getCpuUsage();
+    const memoryUsage = this.getMemoryUsage();
+    const processInfo = this.getProcessInfo();
+    const systemInfo = this.getSystemInfo();
+    
+    return {
+      cpu: {
+        usage: cpuUsage,
+        loadAverage: os.loadavg(),
+        cores: os.cpus().length,
+        timestamp: Date.now()
+      },
+      memory: {
+        usage: memoryUsage.usage,
+        total: memoryUsage.total,
+        free: memoryUsage.free,
+        used: memoryUsage.used,
+        timestamp: Date.now()
+      },
+      process: {
+        memory: processInfo.memory,
+        cpu: processInfo.cpu,
+        eventLoop: processInfo.eventLoop,
+        uptime: processInfo.uptime,
+        timestamp: Date.now()
+      },
+      system: {
+        platform: systemInfo.platform,
+        arch: systemInfo.arch,
+        uptime: systemInfo.uptime,
+        hostname: systemInfo.hostname,
+        timestamp: Date.now()
+      }
+    };
+  }
+  
+  /**
+   * Get CPU usage
+   * @returns {number} CPU usage percentage
+   */
+  getCpuUsage() {
+    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;
+    });
+    
+    return 1 - (totalIdle / totalTick);
+  }
+  
+  /**
+   * Get memory usage
+   * @returns {Object} Memory usage information
+   */
+  getMemoryUsage() {
+    const total = os.totalmem();
+    const free = os.freemem();
+    const used = total - free;
+    const usage = used / total;
+    
+    return {
+      total,
+      free,
+      used,
+      usage,
+      totalGB: (total / 1024 / 1024 / 1024).toFixed(2),
+      freeGB: (free / 1024 / 1024 / 1024).toFixed(2),
+      usedGB: (used / 1024 / 1024 / 1024).toFixed(2),
+      usagePercent: (usage * 100).toFixed(2)
+    };
+  }
+  
+  /**
+   * Get process information
+   * @returns {Object} Process information
+   */
+  getProcessInfo() {
+    const memoryUsage = process.memoryUsage();
+    const cpuUsage = process.cpuUsage();
+    const eventLoop = this.getEventLoopDelay();
+    
+    return {
+      pid: process.pid,
+      uptime: process.uptime(),
+      memory: {
+        rss: memoryUsage.rss,
+        heapTotal: memoryUsage.heapTotal,
+        heapUsed: memoryUsage.heapUsed,
+        external: memoryUsage.external,
+        arrayBuffers: memoryUsage.arrayBuffers,
+        rssMB: (memoryUsage.rss / 1024 / 1024).toFixed(2),
+        heapUsedMB: (memoryUsage.heapUsed / 1024 / 1024).toFixed(2),
+        heapTotalMB: (memoryUsage.heapTotal / 1024 / 1024).toFixed(2)
+      },
+      cpu: {
+        user: cpuUsage.user,
+        system: cpuUsage.system,
+        userMS: (cpuUsage.user / 1000).toFixed(2),
+        systemMS: (cpuUsage.system / 1000).toFixed(2)
+      },
+      eventLoop: {
+        delay: eventLoop,
+        threshold: this.thresholds.eventLoopDelay,
+        status: eventLoop > this.thresholds.eventLoopDelay ? 'slow' : 'normal'
+      },
+      versions: process.versions,
+      argv: process.argv,
+      execArgv: process.execArgv,
+      env: process.env.NODE_ENV || 'development'
+    };
+  }
+  
+  /**
+   * Get system information
+   * @returns {Object} System information
+   */
+  getSystemInfo() {
+    return {
+      platform: os.platform(),
+      arch: os.arch(),
+      release: os.release(),
+      type: os.type(),
+      uptime: os.uptime(),
+      hostname: os.hostname(),
+      cpus: os.cpus().length,
+      totalMemory: os.totalmem(),
+      freeMemory: os.freemem(),
+      loadAverage: os.loadavg(),
+      networkInterfaces: os.networkInterfaces()
+    };
+  }
+  
+  /**
+   * Get event loop delay
+   * @returns {number} Event loop delay in milliseconds
+   */
+  getEventLoopDelay() {
+    const start = process.hrtime.bigint();
+    // Do a small synchronous operation
+    for (let i = 0; i < 1000000; i++) {}
+    const end = process.hrtime.bigint();
+    
+    // Convert nanoseconds to milliseconds
+    return Number(end - start) / 1000000;
+  }
+  
+  /**
+   * Check for alerts based on metrics
+   * @param {Object} metrics - Current metrics
+   */
+  checkAlerts(metrics) {
+    const alerts = [];
+    
+    // Check CPU threshold
+    if (metrics.cpu.usage > this.thresholds.cpu) {
+      alerts.push({
+        type: 'cpu',
+        severity: 'warning',
+        message: `High CPU usage: ${(metrics.cpu.usage * 100).toFixed(2)}%`,
+        threshold: this.thresholds.cpu,
+        value: metrics.cpu.usage,
+        timestamp: Date.now(),
+        resolved: false
+      });
+    }
+    
+    // Check memory threshold
+    if (metrics.memory.usage > this.thresholds.memory) {
+      alerts.push({
+        type: 'memory',
+        severity: 'warning',
+        message: `High memory usage: ${(metrics.memory.usage * 100).toFixed(2)}%`,
+        threshold: this.thresholds.memory,
+        value: metrics.memory.usage,
+        timestamp: Date.now(),
+        resolved: false
+      });
+    }
+    
+    // Check heap usage threshold
+    const heapUsage = metrics.process.memory.heapUsed / metrics.process.memory.heapTotal;
+    if (heapUsage > this.thresholds.heapUsed) {
+      alerts.push({
+        type: 'heap',
+        severity: 'critical',
+        message: `High heap usage: ${(heapUsage * 100).toFixed(2)}%`,
+        threshold: this.thresholds.heapUsed,
+        value: heapUsage,
+        timestamp: Date.now(),
+        resolved: false
+      });
+    }
+    
+    // Check event loop delay
+    if (metrics.process.eventLoop.delay > this.thresholds.eventLoopDelay) {
+      alerts.push({
+        type: 'eventLoop',
+        severity: 'warning',
+        message: `High event loop delay: ${metrics.process.eventLoop.delay.toFixed(2)}ms`,
+        threshold: this.thresholds.eventLoopDelay,
+        value: metrics.process.eventLoop.delay,
+        timestamp: Date.now(),
+        resolved: false
+      });
+    }
+    
+    // Add new alerts
+    alerts.forEach(alert => {
+      this.alerts.push(alert);
+      this.emit('alert:created', alert);
+    });
+    
+    // Check for resolved alerts
+    this.checkResolvedAlerts(metrics);
+  }
+  
+  /**
+   * Check for resolved alerts
+   * @param {Object} metrics - Current metrics
+   */
+  checkResolvedAlerts(metrics) {
+    const now = Date.now();
+    
+    this.alerts.forEach(alert => {
+      if (!alert.resolved) {
+        let isResolved = false;
+        
+        switch (alert.type) {
+          case 'cpu':
+            isResolved = metrics.cpu.usage <= this.thresholds.cpu * 0.8; // Resolved when below 80% of threshold
+            break;
+          case 'memory':
+            isResolved = metrics.memory.usage <= this.thresholds.memory * 0.8;
+            break;
+          case 'heap':
+            const heapUsage = metrics.process.memory.heapUsed / metrics.process.memory.heapTotal;
+            isResolved = heapUsage <= this.thresholds.heapUsed * 0.8;
+            break;
+          case 'eventLoop':
+            isResolved = metrics.process.eventLoop.delay <= this.thresholds.eventLoopDelay * 0.8;
+            break;
+        }
+        
+        if (isResolved) {
+          alert.resolved = true;
+          alert.resolvedAt = now;
+          alert.resolutionTime = now - alert.timestamp;
+          this.emit('alert:resolved', alert);
+        }
+      }
+    });
+  }
+  
+  /**
+   * Get active alerts
+   * @returns {Array} Active alerts
+   */
+  getActiveAlerts() {
+    return this.alerts.filter(alert => !alert.resolved);
+  }
+  
+  /**
+   * Get process status
+   * @param {Object} processInfo - Process information
+   * @returns {string} Process status
+   */
+  getProcessStatus(processInfo) {
+    const heapUsage = processInfo.memory.heapUsed / processInfo.memory.heapTotal;
+    
+    if (heapUsage > this.thresholds.heapUsed) {
+      return 'critical';
+    }
+    
+    if (processInfo.eventLoop.delay > this.thresholds.eventLoopDelay) {
+      return 'warning';
+    }
+    
+    return 'normal';
+  }
+  
+  /**
+   * Get metric summary
+   * @param {string} metric - Metric type
+   * @param {Array} data - Metric data
+   * @returns {Object} Metric summary
+   */
+  getMetricSummary(metric, data) {
+    if (data.length === 0) {
+      return {
+        count: 0,
+        average: 0,
+        min: 0,
+        max: 0,
+        latest: null
+      };
+    }
+    
+    let values = [];
+    
+    switch (metric) {
+      case 'cpu':
+        values = data.map(d => d.usage);
+        break;
+      case 'memory':
+        values = data.map(d => d.usage);
+        break;
+      case 'process':
+        values = data.map(d => d.memory.heapUsed / d.memory.heapTotal);
+        break;
+      default:
+        values = [];
+    }
+    
+    const sum = values.reduce((a, b) => a + b, 0);
+    const average = sum / values.length;
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    const latest = data[data.length - 1];
+    
+    return {
+      count: data.length,
+      average: average.toFixed(4),
+      min: min.toFixed(4),
+      max: max.toFixed(4),
+      latest: latest ? {
+        value: values[values.length - 1],
+        timestamp: latest.timestamp
+      } : null,
+      trend: this.getTrend(values)
+    };
+  }
+  
+  /**
+   * Get trend from values
+   * @param {Array} values - Array of values
+   * @returns {string} Trend (up, down, stable)
+   */
+  getTrend(values) {
+    if (values.length < 2) {
+      return 'stable';
+    }
+    
+    const recent = values.slice(-5); // Last 5 values
+    const first = recent[0];
+    const last = recent[recent.length - 1];
+    
+    if (last > first * 1.1) {
+      return 'up';
+    } else if (last < first * 0.9) {
+      return 'down';
+    } else {
+      return 'stable';
+    }
+  }
+  
+  /**
+   * Limit history size
+   */
+  limitHistory() {
+    if (this.metrics.cpu.length > this.options.historySize) {
+      this.metrics.cpu = this.metrics.cpu.slice(-this.options.historySize);
+    }
+    
+    if (this.metrics.memory.length > this.options.historySize) {
+      this.metrics.memory = this.metrics.memory.slice(-this.options.historySize);
+    }
+    
+    if (this.metrics.process.length > this.options.historySize) {
+      this.metrics.process = this.metrics.process.slice(-this.options.historySize);
+    }
+    
+    if (this.metrics.system.length > this.options.historySize) {
+      this.metrics.system = this.metrics.system.slice(-this.options.historySize);
+    }
+    
+    if (this.alerts.length > this.options.historySize * 2) {
+      this.alerts = this.alerts.slice(-this.options.historySize * 2);
+    }
+  }
+  
+  /**
+   * Reset metrics
+   */
+  resetMetrics() {
+    this.metrics = {
+      cpu: [],
+      memory: [],
+      process: [],
+      system: []
+    };
+    
+    this.alerts = [];
+    this.lastUpdate = null;
+    
+    console.log('🔄 Process monitor metrics reset');
+    this.emit('metrics:reset');
+  }
+  
+  /**
+   * Check authentication
+   * @param {Object} ctx - Context object
+   * @returns {boolean} Authentication status
+   */
+  checkAuth(ctx) {
+    if (typeof this.options.auth === 'function') {
+      return this.options.auth(ctx);
+    }
+    
+    if (typeof this.options.auth === 'object') {
+      // Check API key
+      if (this.options.auth.apiKey) {
+        const apiKey = ctx.headers['x-api-key'] || ctx.query.apiKey;
+        return apiKey === this.options.auth.apiKey;
+      }
+      
+      // Check basic auth
+      if (this.options.auth.username && this.options.auth.password) {
+        const authHeader = ctx.headers.authorization;
+        if (!authHeader || !authHeader.startsWith('Basic ')) {
+          return false;
+        }
+        
+        const credentials = Buffer.from(authHeader.slice(6), 'base64').toString();
+        const [username, password] = credentials.split(':');
+        return username === this.options.auth.username && password === this.options.auth.password;
+      }
+    }
+    
+    return true; // No auth required
+  }
+  
+  /**
+   * Get monitoring configuration
+   * @returns {Object} Monitoring configuration
+   */
+  getConfig() {
+    return {
+      ...this.options,
+      thresholds: this.thresholds,
+      isMonitoring: !!this.monitoringInterval,
+      lastUpdate: this.lastUpdate,
+      metricsCount: {
+        cpu: this.metrics.cpu.length,
+        memory: this.metrics.memory.length,
+        process: this.metrics.process.length,
+        system: this.metrics.system.length
+      },
+      alertsCount: {
+        total: this.alerts.length,
+        active: this.getActiveAlerts().length,
+        resolved: this.alerts.filter(a => a.resolved).length
+      }
+    };
+  }
+}
+
+export default ProcessMonitorMiddleware;