snow-flow 1.4.49 → 2.0.0

package/src/monitoring/enhanced-monitoring-system.ts

@@ -0,0 +1,1345 @@
+/**
+ * 🚀 PERFORMANCE FIX: Enhanced Monitoring System
+ * Advanced real-time monitoring with predictive analytics, alerting, and dashboards
+ * 
+ * Addresses beta testing feedback on performance monitoring gaps
+ */
+
+import { EventEmitter } from 'events';
+import { PerformanceTracker, PerformanceMetric, PerformanceReport } from './performance-tracker';
+import { MemorySystem } from '../memory/memory-system';
+import { Logger } from '../utils/logger';
+import WebSocket from 'ws';
+import http from 'http';
+import path from 'path';
+import fs from 'fs';
+
+export interface MonitoringConfig {
+  realTimeEnabled: boolean;
+  predictiveAnalyticsEnabled: boolean;
+  alertingEnabled: boolean;
+  dashboardEnabled: boolean;
+  websocketPort: number;
+  alertThresholds: AlertThresholds;
+  retentionPeriods: RetentionPeriods;
+}
+
+export interface AlertThresholds {
+  cpuUsage: number;
+  memoryUsage: number;
+  diskUsage: number;
+  responseTime: number;
+  errorRate: number;
+  cacheHitRate: number;
+  queueDepth: number;
+}
+
+export interface RetentionPeriods {
+  realTimeMetrics: number; // milliseconds
+  hourlyAggregates: number;
+  dailyAggregates: number;
+  weeklyAggregates: number;
+}
+
+export interface SystemHealth {
+  overall: 'healthy' | 'warning' | 'critical' | 'unknown';
+  components: {
+    cpu: ComponentHealth;
+    memory: ComponentHealth;
+    disk: ComponentHealth;
+    network: ComponentHealth;
+    database: ComponentHealth;
+    cache: ComponentHealth;
+    api: ComponentHealth;
+  };
+  alerts: ActiveAlert[];
+  recommendations: string[];
+  predictedIssues: PredictedIssue[];
+}
+
+export interface ComponentHealth {
+  status: 'healthy' | 'warning' | 'critical' | 'unknown';
+  value: number;
+  threshold: number;
+  trend: 'improving' | 'stable' | 'degrading';
+  lastUpdated: Date;
+  details: string;
+}
+
+export interface ActiveAlert {
+  id: string;
+  severity: 'low' | 'medium' | 'high' | 'critical';
+  component: string;
+  message: string;
+  timestamp: Date;
+  acknowledged: boolean;
+  count: number;
+  firstSeen: Date;
+}
+
+export interface PredictedIssue {
+  type: 'resource_exhaustion' | 'performance_degradation' | 'capacity_limit' | 'error_spike';
+  component: string;
+  description: string;
+  probability: number;
+  estimatedTime: Date;
+  impact: 'low' | 'medium' | 'high' | 'critical';
+  recommendations: string[];
+}
+
+export interface PerformanceTrend {
+  metric: string;
+  period: 'hour' | 'day' | 'week' | 'month';
+  trend: 'improving' | 'stable' | 'degrading';
+  percentageChange: number;
+  currentValue: number;
+  historicalAverage: number;
+  volatility: number;
+}
+
+export interface ResourceForecast {
+  resource: string;
+  currentUsage: number;
+  predictedUsage: number;
+  timeHorizon: number; // hours
+  confidence: number;
+  exhaustionDate?: Date;
+  recommendations: string[];
+}
+
+export class EnhancedMonitoringSystem extends EventEmitter {
+  private performanceTracker: PerformanceTracker;
+  private memory: MemorySystem;
+  private logger: Logger;
+  private config: MonitoringConfig;
+  private websocketServer?: WebSocket.Server;
+  private httpServer?: http.Server;
+  private activeAlerts: Map<string, ActiveAlert> = new Map();
+  private metricHistory: Map<string, number[]> = new Map();
+  private systemHealth: SystemHealth;
+  private monitoringInterval?: NodeJS.Timeout;
+  private alertingInterval?: NodeJS.Timeout;
+  private predictionInterval?: NodeJS.Timeout;
+  private connectedClients: Set<WebSocket> = new Set();
+
+  constructor(
+    performanceTracker: PerformanceTracker,
+    memory: MemorySystem,
+    config?: Partial<MonitoringConfig>
+  ) {
+    super();
+    
+    this.performanceTracker = performanceTracker;
+    this.memory = memory;
+    this.logger = new Logger('EnhancedMonitoringSystem');
+    
+    this.config = {
+      realTimeEnabled: true,
+      predictiveAnalyticsEnabled: true,
+      alertingEnabled: true,
+      dashboardEnabled: true,
+      websocketPort: 8090,
+      alertThresholds: {
+        cpuUsage: 80,
+        memoryUsage: 85,
+        diskUsage: 90,
+        responseTime: 5000,
+        errorRate: 10,
+        cacheHitRate: 50,
+        queueDepth: 100
+      },
+      retentionPeriods: {
+        realTimeMetrics: 3600000, // 1 hour
+        hourlyAggregates: 2592000000, // 30 days
+        dailyAggregates: 7776000000, // 90 days
+        weeklyAggregates: 31536000000 // 1 year
+      },
+      ...config
+    };
+
+    this.systemHealth = this.initializeSystemHealth();
+    
+    this.logger.info('🚀 Enhanced Monitoring System initialized', {
+      realTimeEnabled: this.config.realTimeEnabled,
+      predictiveAnalyticsEnabled: this.config.predictiveAnalyticsEnabled,
+      alertingEnabled: this.config.alertingEnabled,
+      dashboardEnabled: this.config.dashboardEnabled
+    });
+  }
+
+  /**
+   * Start the enhanced monitoring system
+   */
+  async start(): Promise<void> {
+    this.logger.info('🚀 Starting Enhanced Monitoring System...');
+
+    // Initialize monitoring tables
+    await this.createMonitoringTables();
+
+    // Start real-time monitoring
+    if (this.config.realTimeEnabled) {
+      this.startRealTimeMonitoring();
+    }
+
+    // Start alerting system
+    if (this.config.alertingEnabled) {
+      this.startAlertingSystem();
+    }
+
+    // Start predictive analytics
+    if (this.config.predictiveAnalyticsEnabled) {
+      this.startPredictiveAnalytics();
+    }
+
+    // Start dashboard server
+    if (this.config.dashboardEnabled) {
+      await this.startDashboardServer();
+    }
+
+    // Set up performance tracker integration
+    this.setupPerformanceTrackerIntegration();
+
+    this.logger.info('✅ Enhanced Monitoring System started successfully');
+  }
+
+  /**
+   * Get current system health status
+   */
+  async getSystemHealth(): Promise<SystemHealth> {
+    await this.updateSystemHealth();
+    return { ...this.systemHealth };
+  }
+
+  /**
+   * Get performance trends for specified periods
+   */
+  async getPerformanceTrends(periods: string[] = ['hour', 'day', 'week']): Promise<PerformanceTrend[]> {
+    const trends: PerformanceTrend[] = [];
+    
+    const metrics = [
+      'response_time',
+      'throughput',
+      'error_rate',
+      'cpu_usage',
+      'memory_usage',
+      'cache_hit_rate'
+    ];
+
+    for (const metric of metrics) {
+      for (const period of periods) {
+        const trend = await this.calculateTrend(metric, period as 'hour' | 'day' | 'week');
+        if (trend) {
+          trends.push(trend);
+        }
+      }
+    }
+
+    return trends.sort((a, b) => {
+      // Sort by severity: degrading trends first, then by impact
+      if (a.trend === 'degrading' && b.trend !== 'degrading') return -1;
+      if (b.trend === 'degrading' && a.trend !== 'degrading') return 1;
+      return Math.abs(b.percentageChange) - Math.abs(a.percentageChange);
+    });
+  }
+
+  /**
+   * Get resource usage forecasts
+   */
+  async getResourceForecasts(timeHorizonHours: number = 24): Promise<ResourceForecast[]> {
+    const forecasts: ResourceForecast[] = [];
+    
+    const resources = ['cpu', 'memory', 'disk', 'network', 'database_connections'];
+    
+    for (const resource of resources) {
+      const forecast = await this.generateResourceForecast(resource, timeHorizonHours);
+      if (forecast) {
+        forecasts.push(forecast);
+      }
+    }
+
+    return forecasts.sort((a, b) => {
+      // Sort by urgency: resources approaching exhaustion first
+      if (a.exhaustionDate && b.exhaustionDate) {
+        return a.exhaustionDate.getTime() - b.exhaustionDate.getTime();
+      }
+      if (a.exhaustionDate && !b.exhaustionDate) return -1;
+      if (!a.exhaustionDate && b.exhaustionDate) return 1;
+      return b.predictedUsage - a.predictedUsage;
+    });
+  }
+
+  /**
+   * Generate comprehensive monitoring report
+   */
+  async generateMonitoringReport(period: 'hour' | 'day' | 'week' | 'month' = 'day'): Promise<any> {
+    this.logger.info('📊 Generating comprehensive monitoring report', { period });
+
+    const [
+      systemHealth,
+      performanceReport,
+      trends,
+      forecasts,
+      alerts,
+      recommendations
+    ] = await Promise.all([
+      this.getSystemHealth(),
+      this.performanceTracker.generateReport(period),
+      this.getPerformanceTrends([period]),
+      this.getResourceForecasts(period === 'hour' ? 24 : 168), // 24h or 1 week
+      this.getActiveAlerts(),
+      this.generateSmartRecommendations()
+    ]);
+
+    const report = {
+      timestamp: new Date(),
+      period,
+      summary: {
+        overallHealth: systemHealth.overall,
+        totalAlerts: alerts.length,
+        criticalIssues: alerts.filter(a => a.severity === 'critical').length,
+        performanceScore: this.calculatePerformanceScore(performanceReport, systemHealth),
+        trendsCount: trends.length,
+        forecastsCount: forecasts.length
+      },
+      systemHealth,
+      performance: performanceReport,
+      trends: trends.slice(0, 10), // Top 10 trends
+      forecasts: forecasts.slice(0, 5), // Top 5 forecasts
+      alerts: alerts.slice(0, 20), // Recent 20 alerts
+      recommendations: recommendations.slice(0, 10), // Top 10 recommendations
+      metadata: {
+        monitoringSystemVersion: '2.0.0',
+        reportGenerationTime: Date.now() - Date.now(), // Will be updated at end
+        includedComponents: Object.keys(systemHealth.components),
+        dataPoints: await this.getDataPointCount(period)
+      }
+    };
+
+    // Update generation time
+    report.metadata.reportGenerationTime = Date.now() - report.timestamp.getTime();
+
+    // Store report
+    await this.memory.store(`monitoring_report_${period}_${Date.now()}`, report, 
+      this.config.retentionPeriods.dailyAggregates);
+
+    this.logger.info('✅ Monitoring report generated', {
+      period,
+      overallHealth: systemHealth.overall,
+      alertCount: alerts.length,
+      generationTime: report.metadata.reportGenerationTime
+    });
+
+    return report;
+  }
+
+  /**
+   * Acknowledge an alert
+   */
+  async acknowledgeAlert(alertId: string, acknowledgedBy: string): Promise<boolean> {
+    const alert = this.activeAlerts.get(alertId);
+    if (!alert) {
+      return false;
+    }
+
+    alert.acknowledged = true;
+    
+    // Store acknowledgment
+    await this.memory.store(`alert_ack_${alertId}`, {
+      alertId,
+      acknowledgedBy,
+      acknowledgedAt: new Date(),
+      alert: { ...alert }
+    });
+
+    this.logger.info('🔔 Alert acknowledged', { alertId, acknowledgedBy });
+    
+    // Broadcast to connected clients
+    this.broadcastToClients({
+      type: 'alert_acknowledged',
+      data: { alertId, acknowledgedBy, timestamp: new Date() }
+    });
+
+    return true;
+  }
+
+  /**
+   * Get active alerts
+   */
+  async getActiveAlerts(): Promise<ActiveAlert[]> {
+    return Array.from(this.activeAlerts.values())
+      .sort((a, b) => {
+        // Sort by severity, then by timestamp
+        const severityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
+        const severityDiff = severityOrder[b.severity] - severityOrder[a.severity];
+        if (severityDiff !== 0) return severityDiff;
+        return b.timestamp.getTime() - a.timestamp.getTime();
+      });
+  }
+
+  /**
+   * Private Methods
+   */
+
+  private initializeSystemHealth(): SystemHealth {
+    return {
+      overall: 'unknown',
+      components: {
+        cpu: { status: 'unknown', value: 0, threshold: 80, trend: 'stable', lastUpdated: new Date(), details: 'Initializing...' },
+        memory: { status: 'unknown', value: 0, threshold: 85, trend: 'stable', lastUpdated: new Date(), details: 'Initializing...' },
+        disk: { status: 'unknown', value: 0, threshold: 90, trend: 'stable', lastUpdated: new Date(), details: 'Initializing...' },
+        network: { status: 'unknown', value: 0, threshold: 80, trend: 'stable', lastUpdated: new Date(), details: 'Initializing...' },
+        database: { status: 'unknown', value: 0, threshold: 75, trend: 'stable', lastUpdated: new Date(), details: 'Initializing...' },
+        cache: { status: 'unknown', value: 0, threshold: 50, trend: 'stable', lastUpdated: new Date(), details: 'Initializing...' },
+        api: { status: 'unknown', value: 0, threshold: 5000, trend: 'stable', lastUpdated: new Date(), details: 'Initializing...' }
+      },
+      alerts: [],
+      recommendations: [],
+      predictedIssues: []
+    };
+  }
+
+  private async createMonitoringTables(): Promise<void> {
+    await this.memory.execute(`
+      CREATE TABLE IF NOT EXISTS monitoring_metrics (
+        id TEXT PRIMARY KEY,
+        metric_name TEXT NOT NULL,
+        metric_value REAL NOT NULL,
+        component TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        metadata TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+      
+      CREATE INDEX IF NOT EXISTS idx_monitoring_metrics_name ON monitoring_metrics(metric_name);
+      CREATE INDEX IF NOT EXISTS idx_monitoring_metrics_timestamp ON monitoring_metrics(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_monitoring_metrics_component ON monitoring_metrics(component);
+      
+      CREATE TABLE IF NOT EXISTS monitoring_alerts (
+        id TEXT PRIMARY KEY,
+        severity TEXT NOT NULL,
+        component TEXT NOT NULL,
+        message TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        acknowledged BOOLEAN DEFAULT FALSE,
+        acknowledged_by TEXT,
+        acknowledged_at INTEGER,
+        count INTEGER DEFAULT 1,
+        first_seen INTEGER NOT NULL,
+        last_seen INTEGER NOT NULL,
+        metadata TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+      
+      CREATE INDEX IF NOT EXISTS idx_monitoring_alerts_severity ON monitoring_alerts(severity);
+      CREATE INDEX IF NOT EXISTS idx_monitoring_alerts_component ON monitoring_alerts(component);
+      CREATE INDEX IF NOT EXISTS idx_monitoring_alerts_timestamp ON monitoring_alerts(timestamp);
+      
+      CREATE TABLE IF NOT EXISTS monitoring_predictions (
+        id TEXT PRIMARY KEY,
+        prediction_type TEXT NOT NULL,
+        component TEXT NOT NULL,
+        description TEXT NOT NULL,
+        probability REAL NOT NULL,
+        estimated_time INTEGER,
+        impact TEXT NOT NULL,
+        recommendations TEXT,
+        confidence REAL NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+    `);
+  }
+
+  private startRealTimeMonitoring(): void {
+    this.logger.info('🔄 Starting real-time monitoring...');
+    
+    this.monitoringInterval = setInterval(async () => {
+      try {
+        await this.collectSystemMetrics();
+        await this.updateSystemHealth();
+        
+        // Broadcast to connected clients
+        if (this.connectedClients.size > 0) {
+          this.broadcastToClients({
+            type: 'system_health_update',
+            data: this.systemHealth
+          });
+        }
+      } catch (error) {
+        this.logger.error('❌ Error in real-time monitoring:', error);
+      }
+    }, 5000); // Every 5 seconds
+  }
+
+  private startAlertingSystem(): void {
+    this.logger.info('🔔 Starting alerting system...');
+    
+    this.alertingInterval = setInterval(async () => {
+      try {
+        await this.checkAlertConditions();
+        await this.cleanupOldAlerts();
+      } catch (error) {
+        this.logger.error('❌ Error in alerting system:', error);
+      }
+    }, 10000); // Every 10 seconds
+  }
+
+  private startPredictiveAnalytics(): void {
+    this.logger.info('🔮 Starting predictive analytics...');
+    
+    this.predictionInterval = setInterval(async () => {
+      try {
+        await this.runPredictiveAnalysis();
+      } catch (error) {
+        this.logger.error('❌ Error in predictive analytics:', error);
+      }
+    }, 300000); // Every 5 minutes
+  }
+
+  private async startDashboardServer(): Promise<void> {
+    this.httpServer = http.createServer((req, res) => {
+      this.handleHttpRequest(req, res);
+    });
+
+    this.websocketServer = new WebSocket.Server({ 
+      server: this.httpServer,
+      path: '/monitoring-ws'
+    });
+
+    this.websocketServer.on('connection', (ws) => {
+      this.handleWebSocketConnection(ws);
+    });
+
+    return new Promise((resolve) => {
+      this.httpServer!.listen(this.config.websocketPort, () => {
+        this.logger.info(`🌐 Dashboard server started on port ${this.config.websocketPort}`);
+        resolve();
+      });
+    });
+  }
+
+  private setupPerformanceTrackerIntegration(): void {
+    // Listen to performance tracker events
+    this.performanceTracker.on('performance:slow', (data) => {
+      this.createAlert('high', 'api', `Slow operation detected: ${data.operation} (${data.duration}ms)`, data);
+    });
+
+    this.performanceTracker.on('performance:failure', (data) => {
+      this.createAlert('medium', 'api', `Operation failed: ${data.operation} - ${data.error}`, data);
+    });
+
+    this.performanceTracker.on('performance:high-memory', (data) => {
+      this.createAlert('medium', 'memory', `High memory usage: ${data.operation} (${data.memoryUsage}MB)`, data);
+    });
+
+    this.performanceTracker.on('resource:warning', (data) => {
+      this.createAlert('high', data.type, `Resource warning: ${data.type} usage at ${(data.usage * 100).toFixed(1)}%`, data);
+    });
+  }
+
+  private async collectSystemMetrics(): Promise<void> {
+    const timestamp = Date.now();
+    
+    // Collect Node.js process metrics
+    const memUsage = process.memoryUsage();
+    const cpuUsage = process.cpuUsage();
+    
+    const metrics = [
+      {
+        name: 'process_memory_heap_used',
+        value: memUsage.heapUsed / 1024 / 1024, // MB
+        component: 'memory'
+      },
+      {
+        name: 'process_memory_heap_total',
+        value: memUsage.heapTotal / 1024 / 1024, // MB
+        component: 'memory'
+      },
+      {
+        name: 'process_memory_rss',
+        value: memUsage.rss / 1024 / 1024, // MB
+        component: 'memory'
+      },
+      {
+        name: 'process_cpu_user',
+        value: cpuUsage.user / 1000, // milliseconds
+        component: 'cpu'
+      },
+      {
+        name: 'process_cpu_system',
+        value: cpuUsage.system / 1000, // milliseconds
+        component: 'cpu'
+      }
+    ];
+
+    // Collect memory system metrics
+    const memoryStats = await this.memory.getDatabaseStats();
+    metrics.push({
+      name: 'database_size',
+      value: memoryStats.size / 1024 / 1024, // MB
+      component: 'database'
+    });
+
+    // Collect cache metrics if available
+    try {
+      const cacheStats = await this.memory.getCacheStats();
+      metrics.push(
+        {
+          name: 'cache_hit_rate',
+          value: cacheStats.hits / (cacheStats.hits + cacheStats.misses) * 100,
+          component: 'cache'
+        },
+        {
+          name: 'cache_size',
+          value: cacheStats.size,
+          component: 'cache'
+        }
+      );
+    } catch (error) {
+      // Cache stats may not be available
+    }
+
+    // Store metrics
+    for (const metric of metrics) {
+      await this.storeMetric(metric.name, metric.value, metric.component, timestamp);
+      
+      // Update history for trend analysis
+      const historyKey = `${metric.component}_${metric.name}`;
+      if (!this.metricHistory.has(historyKey)) {
+        this.metricHistory.set(historyKey, []);
+      }
+      const history = this.metricHistory.get(historyKey)!;
+      history.push(metric.value);
+      
+      // Keep only last 100 values
+      if (history.length > 100) {
+        history.shift();
+      }
+    }
+  }
+
+  private async storeMetric(name: string, value: number, component: string, timestamp: number): Promise<void> {
+    const id = `${component}_${name}_${timestamp}`;
+    
+    await this.memory.insert('monitoring_metrics', {
+      id,
+      metric_name: name,
+      metric_value: value,
+      component,
+      timestamp,
+      metadata: JSON.stringify({
+        node_version: process.version,
+        platform: process.platform,
+        arch: process.arch
+      })
+    });
+  }
+
+  private async updateSystemHealth(): Promise<void> {
+    const now = new Date();
+    
+    // Update CPU health
+    const cpuHistory = this.metricHistory.get('cpu_process_cpu_user') || [];
+    if (cpuHistory.length > 0) {
+      const currentCpu = cpuHistory[cpuHistory.length - 1] || 0;
+      this.systemHealth.components.cpu = {
+        status: currentCpu > this.config.alertThresholds.cpuUsage ? 'critical' : 
+                currentCpu > this.config.alertThresholds.cpuUsage * 0.8 ? 'warning' : 'healthy',
+        value: currentCpu,
+        threshold: this.config.alertThresholds.cpuUsage,
+        trend: this.calculateComponentTrend('cpu', cpuHistory),
+        lastUpdated: now,
+        details: `CPU usage: ${currentCpu.toFixed(1)}%`
+      };
+    }
+
+    // Update Memory health
+    const memHistory = this.metricHistory.get('memory_process_memory_heap_used') || [];
+    if (memHistory.length > 0) {
+      const currentMem = memHistory[memHistory.length - 1] || 0;
+      this.systemHealth.components.memory = {
+        status: currentMem > 500 ? 'critical' : currentMem > 300 ? 'warning' : 'healthy',
+        value: currentMem,
+        threshold: 500,
+        trend: this.calculateComponentTrend('memory', memHistory),
+        lastUpdated: now,
+        details: `Heap usage: ${currentMem.toFixed(1)}MB`
+      };
+    }
+
+    // Update Database health
+    const dbHistory = this.metricHistory.get('database_database_size') || [];
+    if (dbHistory.length > 0) {
+      const currentDb = dbHistory[dbHistory.length - 1] || 0;
+      this.systemHealth.components.database = {
+        status: currentDb > 1000 ? 'warning' : 'healthy',
+        value: currentDb,
+        threshold: 1000,
+        trend: this.calculateComponentTrend('database', dbHistory),
+        lastUpdated: now,
+        details: `Database size: ${currentDb.toFixed(1)}MB`
+      };
+    }
+
+    // Update Cache health
+    const cacheHitHistory = this.metricHistory.get('cache_cache_hit_rate') || [];
+    if (cacheHitHistory.length > 0) {
+      const currentHitRate = cacheHitHistory[cacheHitHistory.length - 1] || 0;
+      this.systemHealth.components.cache = {
+        status: currentHitRate < this.config.alertThresholds.cacheHitRate ? 'warning' : 'healthy',
+        value: currentHitRate,
+        threshold: this.config.alertThresholds.cacheHitRate,
+        trend: this.calculateComponentTrend('cache', cacheHitHistory),
+        lastUpdated: now,
+        details: `Cache hit rate: ${currentHitRate.toFixed(1)}%`
+      };
+    }
+
+    // Calculate overall health
+    const componentStatuses = Object.values(this.systemHealth.components).map(c => c.status);
+    if (componentStatuses.includes('critical')) {
+      this.systemHealth.overall = 'critical';
+    } else if (componentStatuses.includes('warning')) {
+      this.systemHealth.overall = 'warning';
+    } else if (componentStatuses.every(s => s === 'healthy')) {
+      this.systemHealth.overall = 'healthy';
+    } else {
+      this.systemHealth.overall = 'unknown';
+    }
+
+    // Update alerts list
+    this.systemHealth.alerts = await this.getActiveAlerts();
+  }
+
+  private calculateComponentTrend(component: string, history: number[]): 'improving' | 'stable' | 'degrading' {
+    if (history.length < 10) return 'stable';
+    
+    const recent = history.slice(-5);
+    const older = history.slice(-10, -5);
+    
+    const recentAvg = recent.reduce((a, b) => a + b, 0) / recent.length;
+    const olderAvg = older.reduce((a, b) => a + b, 0) / older.length;
+    
+    const changePercent = ((recentAvg - olderAvg) / olderAvg) * 100;
+    
+    // For CPU, memory, response time: increasing is degrading
+    // For cache hit rate, throughput: increasing is improving
+    const isInverseMetric = component.includes('cache') || component.includes('throughput');
+    
+    if (Math.abs(changePercent) < 5) return 'stable';
+    
+    if (isInverseMetric) {
+      return changePercent > 0 ? 'improving' : 'degrading';
+    } else {
+      return changePercent > 0 ? 'degrading' : 'improving';
+    }
+  }
+
+  private async checkAlertConditions(): Promise<void> {
+    const now = Date.now();
+    
+    // Check each component health
+    for (const [componentName, component] of Object.entries(this.systemHealth.components)) {
+      if (component.status === 'critical' || component.status === 'warning') {
+        const severity = component.status === 'critical' ? 'critical' : 'high';
+        const alertId = `${componentName}_${component.status}`;
+        
+        if (this.activeAlerts.has(alertId)) {
+          // Update existing alert
+          const alert = this.activeAlerts.get(alertId)!;
+          alert.count++;
+          (alert as any).lastSeen = new Date();
+        } else {
+          // Create new alert
+          await this.createAlert(severity, componentName, component.details, {
+            threshold: component.threshold,
+            currentValue: component.value,
+            trend: component.trend
+          });
+        }
+      }
+    }
+  }
+
+  private async createAlert(
+    severity: 'low' | 'medium' | 'high' | 'critical',
+    component: string,
+    message: string,
+    metadata?: any
+  ): Promise<void> {
+    const alertId = `${component}_${severity}_${Date.now()}`;
+    const now = new Date();
+    
+    const alert: ActiveAlert = {
+      id: alertId,
+      severity,
+      component,
+      message,
+      timestamp: now,
+      acknowledged: false,
+      count: 1,
+      firstSeen: now
+    };
+    
+    this.activeAlerts.set(alertId, alert);
+    
+    // Store in database
+    await this.memory.insert('monitoring_alerts', {
+      id: alertId,
+      severity,
+      component,
+      message,
+      timestamp: now.getTime(),
+      acknowledged: false,
+      count: 1,
+      first_seen: now.getTime(),
+      last_seen: now.getTime(),
+      metadata: JSON.stringify(metadata || {})
+    });
+    
+    this.logger.warn(`🚨 Alert created: ${severity.toUpperCase()} - ${component} - ${message}`, { alertId });
+    
+    // Emit alert event
+    this.emit('alert', alert);
+    
+    // Broadcast to connected clients
+    this.broadcastToClients({
+      type: 'new_alert',
+      data: alert
+    });
+  }
+
+  private async cleanupOldAlerts(): Promise<void> {
+    const cutoff = Date.now() - (24 * 60 * 60 * 1000); // 24 hours
+    
+    for (const [alertId, alert] of this.activeAlerts) {
+      if (alert.timestamp.getTime() < cutoff && alert.acknowledged) {
+        this.activeAlerts.delete(alertId);
+      }
+    }
+  }
+
+  private async runPredictiveAnalysis(): Promise<void> {
+    this.logger.debug('🔮 Running predictive _analysis...');
+    
+    const predictions: PredictedIssue[] = [];
+    
+    // Analyze memory growth
+    const memHistory = this.metricHistory.get('memory_process_memory_heap_used') || [];
+    if (memHistory.length > 20) {
+      const memoryPrediction = this.predictResourceExhaustion('memory', memHistory, 1000); // 1GB limit
+      if (memoryPrediction) {
+        predictions.push(memoryPrediction);
+      }
+    }
+    
+    // Analyze database growth
+    const dbHistory = this.metricHistory.get('database_database_size') || [];
+    if (dbHistory.length > 20) {
+      const dbPrediction = this.predictResourceExhaustion('database', dbHistory, 5000); // 5GB limit
+      if (dbPrediction) {
+        predictions.push(dbPrediction);
+      }
+    }
+    
+    // Store predictions
+    for (const prediction of predictions) {
+      await this.memory.insert('monitoring_predictions', {
+        id: `prediction_${prediction.type}_${prediction.component}_${Date.now()}`,
+        prediction_type: prediction.type,
+        component: prediction.component,
+        description: prediction.description,
+        probability: prediction.probability,
+        estimated_time: prediction.estimatedTime?.getTime(),
+        impact: prediction.impact,
+        recommendations: JSON.stringify(prediction.recommendations),
+        confidence: prediction.probability
+      });
+    }
+    
+    // Update system health with predictions
+    this.systemHealth.predictedIssues = predictions;
+  }
+
+  private predictResourceExhaustion(
+    resource: string, 
+    history: number[], 
+    limit: number
+  ): PredictedIssue | null {
+    if (history.length < 10) return null;
+    
+    // Simple linear regression to predict growth
+    const recentHistory = history.slice(-20);
+    const n = recentHistory.length;
+    const x = Array.from({ length: n }, (_, i) => i);
+    const y = recentHistory;
+    
+    const sumX = x.reduce((a, b) => a + b, 0);
+    const sumY = y.reduce((a, b) => a + b, 0);
+    const sumXY = x.reduce((sum, xi, i) => sum + xi * y[i], 0);
+    const sumXX = x.reduce((sum, xi) => sum + xi * xi, 0);
+    
+    const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
+    const intercept = (sumY - slope * sumX) / n;
+    
+    // Predict when resource will reach limit
+    if (slope > 0) {
+      const currentValue = y[y.length - 1];
+      const timeToLimit = (limit - currentValue) / slope;
+      
+      if (timeToLimit > 0 && timeToLimit < 1000) { // Within 1000 time units
+        const probability = Math.min(0.9, Math.max(0.1, 1 - (timeToLimit / 1000)));
+        const estimatedTime = new Date(Date.now() + (timeToLimit * 300000)); // 5-minute intervals
+        
+        return {
+          type: 'resource_exhaustion',
+          component: resource,
+          description: `${resource} usage is growing and may reach capacity limits`,
+          probability,
+          estimatedTime,
+          impact: timeToLimit < 100 ? 'critical' : timeToLimit < 300 ? 'high' : 'medium',
+          recommendations: [
+            `Monitor ${resource} usage closely`,
+            `Consider optimizing ${resource} consumption`,
+            'Implement cleanup/archival processes',
+            'Scale resources if necessary'
+          ]
+        };
+      }
+    }
+    
+    return null;
+  }
+
+  private async calculateTrend(metric: string, period: 'hour' | 'day' | 'week'): Promise<PerformanceTrend | null> {
+    const timeframe = {
+      hour: 3600000,
+      day: 86400000,
+      week: 604800000
+    }[period];
+    
+    const since = Date.now() - timeframe;
+    
+    const metrics = await this.memory.query<{ metric_value: number, timestamp: number }>(`
+      SELECT metric_value, timestamp FROM monitoring_metrics 
+      WHERE metric_name = ? AND timestamp > ?
+      ORDER BY timestamp
+    `, [metric, since]);
+    
+    if (metrics.length < 10) return null;
+    
+    const values = metrics.map(m => m.metric_value);
+    const recent = values.slice(-Math.floor(values.length / 3));
+    const older = values.slice(0, Math.floor(values.length / 3));
+    
+    const recentAvg = recent.reduce((a, b) => a + b, 0) / recent.length;
+    const olderAvg = older.reduce((a, b) => a + b, 0) / older.length;
+    const overallAvg = values.reduce((a, b) => a + b, 0) / values.length;
+    
+    const percentageChange = ((recentAvg - olderAvg) / olderAvg) * 100;
+    const variance = values.reduce((sum, val) => sum + Math.pow(val - overallAvg, 2), 0) / values.length;
+    const volatility = Math.sqrt(variance) / overallAvg;
+    
+    return {
+      metric,
+      period,
+      trend: Math.abs(percentageChange) < 5 ? 'stable' : 
+             percentageChange > 0 ? 'degrading' : 'improving',
+      percentageChange,
+      currentValue: recentAvg,
+      historicalAverage: overallAvg,
+      volatility
+    };
+  }
+
+  private async generateResourceForecast(resource: string, timeHorizonHours: number): Promise<ResourceForecast | null> {
+    const history = this.metricHistory.get(`${resource}_${resource}_usage`) || 
+                   this.metricHistory.get(`${resource}_process_memory_heap_used`) ||
+                   this.metricHistory.get(`${resource}_database_size`) || [];
+    
+    if (history.length < 10) return null;
+    
+    const currentUsage = history[history.length - 1] || 0;
+    const trend = this.calculateComponentTrend(resource, history);
+    
+    // Simple prediction based on trend
+    let predictedUsage = currentUsage;
+    let confidence = 0.5;
+    
+    if (trend === 'degrading') {
+      const growthRate = this.calculateGrowthRate(history);
+      predictedUsage = currentUsage * (1 + (growthRate * timeHorizonHours / 24));
+      confidence = 0.7;
+    } else if (trend === 'improving') {
+      const reductionRate = this.calculateGrowthRate(history);
+      predictedUsage = currentUsage * (1 + (reductionRate * timeHorizonHours / 24));
+      confidence = 0.6;
+    }
+    
+    const recommendations: string[] = [];
+    let exhaustionDate: Date | undefined;
+    
+    if (predictedUsage > currentUsage * 1.5) {
+      recommendations.push(`${resource} usage expected to increase significantly`);
+      recommendations.push('Consider implementing resource optimization');
+    }
+    
+    if (predictedUsage > 1000) { // Arbitrary threshold
+      exhaustionDate = new Date(Date.now() + (timeHorizonHours * 3600000));
+      recommendations.push('Resource exhaustion predicted - immediate action required');
+    }
+    
+    return {
+      resource,
+      currentUsage,
+      predictedUsage,
+      timeHorizon: timeHorizonHours,
+      confidence,
+      exhaustionDate,
+      recommendations
+    };
+  }
+
+  private calculateGrowthRate(history: number[]): number {
+    if (history.length < 5) return 0;
+    
+    const recent = history.slice(-5);
+    const older = history.slice(-10, -5);
+    
+    const recentAvg = recent.reduce((a, b) => a + b) / recent.length;
+    const olderAvg = older.reduce((a, b) => a + b) / older.length;
+    
+    return (recentAvg - olderAvg) / olderAvg;
+  }
+
+  private calculatePerformanceScore(performanceReport: PerformanceReport, systemHealth: SystemHealth): number {
+    let score = 100;
+    
+    // Deduct points for errors
+    score -= performanceReport.summary.errorRate * 2;
+    
+    // Deduct points for slow response times
+    if (performanceReport.summary.averageResponseTime > 2000) {
+      score -= (performanceReport.summary.averageResponseTime - 2000) / 100;
+    }
+    
+    // Deduct points for unhealthy components
+    const unhealthyComponents = Object.values(systemHealth.components)
+      .filter(c => c.status !== 'healthy').length;
+    score -= unhealthyComponents * 10;
+    
+    // Deduct points for critical alerts
+    const criticalAlerts = systemHealth.alerts.filter(a => a.severity === 'critical').length;
+    score -= criticalAlerts * 15;
+    
+    return Math.max(0, Math.min(100, score));
+  }
+
+  private async generateSmartRecommendations(): Promise<string[]> {
+    const recommendations: string[] = [];
+    
+    // Analyze system health and generate recommendations
+    for (const [componentName, component] of Object.entries(this.systemHealth.components)) {
+      if (component.status !== 'healthy') {
+        if (componentName === 'memory' && component.trend === 'degrading') {
+          recommendations.push('Consider implementing memory optimization strategies');
+          recommendations.push('Review memory leaks in long-running processes');
+        }
+        
+        if (componentName === 'cpu' && component.value > 80) {
+          recommendations.push('CPU usage is high - consider scaling or optimization');
+        }
+        
+        if (componentName === 'cache' && component.value < 50) {
+          recommendations.push('Cache hit rate is low - review caching strategy');
+        }
+      }
+    }
+    
+    // Add predictive recommendations
+    for (const prediction of this.systemHealth.predictedIssues) {
+      recommendations.push(...prediction.recommendations);
+    }
+    
+    return [...new Set(recommendations)]; // Remove duplicates
+  }
+
+  private async getDataPointCount(period: string): Promise<number> {
+    const timeframe = {
+      hour: 3600000,
+      day: 86400000,
+      week: 604800000,
+      month: 2592000000
+    }[period] || 86400000;
+    
+    const since = Date.now() - timeframe;
+    
+    const result = await this.memory.query<{ count: number }>(`
+      SELECT COUNT(*) as count FROM monitoring_metrics 
+      WHERE timestamp > ?
+    `, [since]);
+    
+    return result[0]?.count || 0;
+  }
+
+  private handleWebSocketConnection(ws: WebSocket): void {
+    this.connectedClients.add(ws);
+    this.logger.info('📱 WebSocket client connected', { totalClients: this.connectedClients.size });
+    
+    // Send initial system health
+    ws.send(JSON.stringify({
+      type: 'initial_data',
+      data: {
+        systemHealth: this.systemHealth,
+        timestamp: new Date()
+      }
+    }));
+    
+    ws.on('close', () => {
+      this.connectedClients.delete(ws);
+      this.logger.info('📱 WebSocket client disconnected', { totalClients: this.connectedClients.size });
+    });
+    
+    ws.on('message', async (message) => {
+      try {
+        const data = JSON.parse(message.toString());
+        await this.handleWebSocketMessage(ws, data);
+      } catch (error) {
+        this.logger.error('❌ Error handling WebSocket message:', error);
+      }
+    });
+  }
+
+  private async handleWebSocketMessage(ws: WebSocket, message: any): Promise<void> {
+    switch (message.type) {
+      case 'acknowledge_alert':
+        if (message.alertId && message.user) {
+          const success = await this.acknowledgeAlert(message.alertId, message.user);
+          ws.send(JSON.stringify({
+            type: 'alert_acknowledged',
+            success,
+            alertId: message.alertId
+          }));
+        }
+        break;
+        
+      case 'get_performance_trends':
+        const trends = await this.getPerformanceTrends(message.periods || ['day']);
+        ws.send(JSON.stringify({
+          type: 'performance_trends',
+          data: trends
+        }));
+        break;
+        
+      case 'get_resource_forecasts':
+        const forecasts = await this.getResourceForecasts(message.timeHorizon || 24);
+        ws.send(JSON.stringify({
+          type: 'resource_forecasts',
+          data: forecasts
+        }));
+        break;
+    }
+  }
+
+  private handleHttpRequest(req: http.IncomingMessage, res: http.ServerResponse): void {
+    // Serve basic monitoring dashboard
+    const dashboardHtml = this.generateDashboardHtml();
+    
+    res.writeHead(200, {
+      'Content-Type': 'text/html',
+      'Content-Length': Buffer.byteLength(dashboardHtml)
+    });
+    res.end(dashboardHtml);
+  }
+
+  private generateDashboardHtml(): string {
+    return `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Snow-Flow Enhanced Monitoring Dashboard</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 0; padding: 20px; background: #f5f5f5; }
+        .header { background: #2c3e50; color: white; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
+        .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; }
+        .card { background: white; padding: 20px; border-radius: 5px; box-shadow: 0 2px 5px rgba(0,0,0,0.1); }
+        .status-healthy { color: #27ae60; }
+        .status-warning { color: #f39c12; }
+        .status-critical { color: #e74c3c; }
+        .status-unknown { color: #95a5a6; }
+        .metric { display: flex; justify-content: space-between; margin: 10px 0; }
+        .alert { padding: 10px; margin: 5px 0; border-radius: 3px; }
+        .alert-critical { background: #ffebee; border-left: 4px solid #e74c3c; }
+        .alert-high { background: #fff3e0; border-left: 4px solid #ff9800; }
+        .alert-medium { background: #f3e5f5; border-left: 4px solid #9c27b0; }
+        .alert-low { background: #e8f5e8; border-left: 4px solid #4caf50; }
+        #connectionStatus { position: fixed; top: 10px; right: 10px; padding: 5px 10px; border-radius: 3px; }
+        .connected { background: #4caf50; color: white; }
+        .disconnected { background: #f44336; color: white; }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>🚀 Snow-Flow Enhanced Monitoring Dashboard</h1>
+        <p>Real-time system health and performance monitoring</p>
+        <div id="connectionStatus" class="disconnected">Connecting...</div>
+    </div>
+    
+    <div class="grid">
+        <div class="card">
+            <h3>System Health Overview</h3>
+            <div id="overallHealth">Loading...</div>
+            <div id="componentHealth"></div>
+        </div>
+        
+        <div class="card">
+            <h3>Active Alerts</h3>
+            <div id="alerts">Loading...</div>
+        </div>
+        
+        <div class="card">
+            <h3>Performance Metrics</h3>
+            <div id="performanceMetrics">Loading...</div>
+        </div>
+        
+        <div class="card">
+            <h3>Resource Usage</h3>
+            <div id="resourceUsage">Loading...</div>
+        </div>
+    </div>
+
+    <script>
+        const ws = new WebSocket('ws://localhost:${this.config.websocketPort}/monitoring-ws');
+        const connectionStatus = document.getElementById('connectionStatus');
+        
+        ws.onopen = function() {
+            connectionStatus.textContent = 'Connected';
+            connectionStatus.className = 'connected';
+        };
+        
+        ws.onclose = function() {
+            connectionStatus.textContent = 'Disconnected';
+            connectionStatus.className = 'disconnected';
+        };
+        
+        ws.onmessage = function(event) {
+            const message = JSON.parse(event.data);
+            
+            switch(message.type) {
+                case 'initial_data':
+                case 'system_health_update':
+                    updateSystemHealth(message.data.systemHealth || message.data);
+                    break;
+                case 'new_alert':
+                    addAlert(message.data);
+                    break;
+            }
+        };
+        
+        function updateSystemHealth(health) {
+            // Update overall health
+            const overallHealth = document.getElementById('overallHealth');
+            overallHealth.innerHTML = \`
+                <div class="metric">
+                    <span>Overall Status:</span>
+                    <span class="status-\${health.overall}">\${health.overall.toUpperCase()}</span>
+                </div>
+            \`;
+            
+            // Update component health
+            const componentHealth = document.getElementById('componentHealth');
+            let componentsHtml = '';
+            
+            for (const [name, component] of Object.entries(health.components)) {
+                componentsHtml += \`
+                    <div class="metric">
+                        <span>\${name.charAt(0).toUpperCase() + name.slice(1)}:</span>
+                        <span class="status-\${component.status}">
+                            \${component.value.toFixed(1)} (\${component.status})
+                        </span>
+                    </div>
+                \`;
+            }
+            componentHealth.innerHTML = componentsHtml;
+            
+            // Update alerts
+            updateAlerts(health.alerts || []);
+        }
+        
+        function updateAlerts(alerts) {
+            const alertsDiv = document.getElementById('alerts');
+            
+            if (alerts.length === 0) {
+                alertsDiv.innerHTML = '<p>No active alerts</p>';
+                return;
+            }
+            
+            let alertsHtml = '';
+            alerts.slice(0, 10).forEach(alert => {
+                alertsHtml += \`
+                    <div class="alert alert-\${alert.severity}">
+                        <strong>\${alert.component.toUpperCase()}</strong>: \${alert.message}
+                        <br><small>\${new Date(alert.timestamp).toLocaleString()}</small>
+                    </div>
+                \`;
+            });
+            
+            alertsDiv.innerHTML = alertsHtml;
+        }
+        
+        function addAlert(alert) {
+            // Add new alert to the top of the list
+            const alertsDiv = document.getElementById('alerts');
+            const newAlertHtml = \`
+                <div class="alert alert-\${alert.severity}">
+                    <strong>\${alert.component.toUpperCase()}</strong>: \${alert.message}
+                    <br><small>\${new Date(alert.timestamp).toLocaleString()}</small>
+                </div>
+            \`;
+            
+            alertsDiv.innerHTML = newAlertHtml + alertsDiv.innerHTML;
+        }
+    </script>
+</body>
+</html>
+    `;
+  }
+
+  private broadcastToClients(message: any): void {
+    const messageStr = JSON.stringify(message);
+    
+    this.connectedClients.forEach(client => {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(messageStr);
+      }
+    });
+  }
+
+  /**
+   * Shutdown the monitoring system
+   */
+  async shutdown(): Promise<void> {
+    this.logger.info('🛑 Shutting down Enhanced Monitoring System...');
+    
+    // Clear intervals
+    if (this.monitoringInterval) clearInterval(this.monitoringInterval);
+    if (this.alertingInterval) clearInterval(this.alertingInterval);
+    if (this.predictionInterval) clearInterval(this.predictionInterval);
+    
+    // Close WebSocket connections
+    this.connectedClients.forEach(client => {
+      client.close();
+    });
+    this.connectedClients.clear();
+    
+    // Close servers
+    if (this.websocketServer) {
+      this.websocketServer.close();
+    }
+    
+    if (this.httpServer) {
+      this.httpServer.close();
+    }
+    
+    this.logger.info('✅ Enhanced Monitoring System shut down');
+  }
+}