@arela/uploader 0.2.12 → 0.3.0

package/src/services/MonitoringService.js

@@ -0,0 +1,401 @@
+/**
+ * MonitoringService.js
+ * Phase 7 - Task 4: Advanced Monitoring & Alerting
+ *
+ * Provides advanced monitoring and alerting including:
+ * - Real-time alerts
+ * - Threshold-based notifications
+ * - Health monitoring
+ * - Alert history and escalation
+ * - Custom alert rules
+ */
+
+class MonitoringService {
+  constructor(logger) {
+    this.logger = logger;
+    this.alerts = [];
+    this.alertRules = [];
+    this.subscribers = [];
+
+    this.metrics = {
+      cpuUsage: 0,
+      memoryUsage: 0,
+      diskUsage: 0,
+      activeConnections: 0,
+      errorRate: 0,
+    };
+
+    this.thresholds = {
+      memoryWarning: 75, // 75% heap used
+      memoryCritical: 90, // 90% heap used
+      errorRateWarning: 5, // 5% error rate
+      errorRateCritical: 10, // 10% error rate
+      responseTimeWarning: 5000, // 5 seconds
+      responseTimeCritical: 10000, // 10 seconds
+    };
+
+    this._initializeDefaultRules();
+  }
+
+  /**
+   * Initialize default alert rules
+   */
+  _initializeDefaultRules() {
+    this.addAlertRule({
+      name: 'High Memory Usage',
+      metric: 'memoryUsage',
+      operator: 'greaterThan',
+      threshold: this.thresholds.memoryWarning,
+      severity: 'warning',
+      enabled: true,
+    });
+
+    this.addAlertRule({
+      name: 'Critical Memory Usage',
+      metric: 'memoryUsage',
+      operator: 'greaterThan',
+      threshold: this.thresholds.memoryCritical,
+      severity: 'critical',
+      enabled: true,
+    });
+
+    this.addAlertRule({
+      name: 'High Error Rate',
+      metric: 'errorRate',
+      operator: 'greaterThan',
+      threshold: this.thresholds.errorRateWarning,
+      severity: 'warning',
+      enabled: true,
+    });
+
+    this.addAlertRule({
+      name: 'Critical Error Rate',
+      metric: 'errorRate',
+      operator: 'greaterThan',
+      threshold: this.thresholds.errorRateCritical,
+      severity: 'critical',
+      enabled: true,
+    });
+  }
+
+  /**
+   * Add alert rule
+   */
+  addAlertRule(rule) {
+    const fullRule = {
+      id: `rule_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      ...rule,
+      createdAt: new Date().toISOString(),
+      triggeredCount: 0,
+      lastTriggered: null,
+    };
+
+    this.alertRules.push(fullRule);
+    return fullRule;
+  }
+
+  /**
+   * Subscribe to alerts
+   */
+  subscribe(severity, callback) {
+    const subscription = {
+      id: `sub_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      severity,
+      callback,
+      subscribed: true,
+    };
+
+    this.subscribers.push(subscription);
+    return subscription.id;
+  }
+
+  /**
+   * Unsubscribe from alerts
+   */
+  unsubscribe(subscriptionId) {
+    const index = this.subscribers.findIndex((s) => s.id === subscriptionId);
+    if (index > -1) {
+      this.subscribers.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Update metrics
+   */
+  updateMetrics(newMetrics) {
+    const previousMetrics = { ...this.metrics };
+    this.metrics = { ...this.metrics, ...newMetrics };
+
+    // Check rules
+    this._checkAlertRules();
+
+    return {
+      previous: previousMetrics,
+      current: this.metrics,
+      changed: Object.keys(newMetrics),
+    };
+  }
+
+  /**
+   * Check all alert rules
+   */
+  _checkAlertRules() {
+    for (const rule of this.alertRules) {
+      if (!rule.enabled) continue;
+
+      const metricValue = this.metrics[rule.metric];
+      let triggered = false;
+
+      switch (rule.operator) {
+        case 'greaterThan':
+          triggered = metricValue > rule.threshold;
+          break;
+        case 'lessThan':
+          triggered = metricValue < rule.threshold;
+          break;
+        case 'equals':
+          triggered = metricValue === rule.threshold;
+          break;
+        case 'between':
+          triggered =
+            metricValue >= rule.threshold[0] &&
+            metricValue <= rule.threshold[1];
+          break;
+      }
+
+      if (triggered) {
+        this._triggerAlert(rule, metricValue);
+      }
+    }
+  }
+
+  /**
+   * Trigger an alert
+   */
+  _triggerAlert(rule, value) {
+    const alert = {
+      id: `alert_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      ruleId: rule.id,
+      ruleName: rule.name,
+      severity: rule.severity,
+      metric: rule.metric,
+      value,
+      threshold: rule.threshold,
+      timestamp: new Date().toISOString(),
+      message: `${rule.name}: ${rule.metric} = ${value} (threshold: ${rule.threshold})`,
+      acknowledged: false,
+    };
+
+    this.alerts.push(alert);
+    rule.triggeredCount++;
+    rule.lastTriggered = new Date().toISOString();
+
+    // Notify subscribers
+    this._notifySubscribers(alert);
+
+    this.logger.warn(`Alert triggered: ${alert.message}`);
+
+    return alert;
+  }
+
+  /**
+   * Notify subscribers
+   */
+  _notifySubscribers(alert) {
+    const severityOrder = { info: 0, warning: 1, critical: 2 };
+    const alertSeverityLevel = severityOrder[alert.severity] || 0;
+
+    for (const subscriber of this.subscribers) {
+      const subscriberSeverityLevel = severityOrder[subscriber.severity] || 0;
+
+      if (alertSeverityLevel >= subscriberSeverityLevel) {
+        try {
+          subscriber.callback(alert);
+        } catch (error) {
+          this.logger.error(`Subscriber callback error:`, error);
+        }
+      }
+    }
+  }
+
+  /**
+   * Acknowledge alert
+   */
+  acknowledgeAlert(alertId) {
+    const alert = this.alerts.find((a) => a.id === alertId);
+    if (alert) {
+      alert.acknowledged = true;
+      alert.acknowledgedAt = new Date().toISOString();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get active alerts
+   */
+  getActiveAlerts(severity = null) {
+    let alerts = this.alerts.filter((a) => !a.acknowledged);
+
+    if (severity) {
+      alerts = alerts.filter((a) => a.severity === severity);
+    }
+
+    return alerts;
+  }
+
+  /**
+   * Get alert history
+   */
+  getAlertHistory(limit = 50) {
+    return this.alerts.slice(-limit).reverse();
+  }
+
+  /**
+   * Get health status
+   */
+  getHealthStatus() {
+    const activeAlerts = this.getActiveAlerts();
+    const criticalAlerts = activeAlerts.filter(
+      (a) => a.severity === 'critical',
+    );
+
+    let healthStatus = 'healthy';
+    if (criticalAlerts.length > 0) {
+      healthStatus = 'critical';
+    } else if (activeAlerts.length > 0) {
+      healthStatus = 'warning';
+    }
+
+    return {
+      status: healthStatus,
+      timestamp: new Date().toISOString(),
+      metrics: this.metrics,
+      activeAlerts: activeAlerts.length,
+      criticalAlerts: criticalAlerts.length,
+      totalAlerts: this.alerts.length,
+      uptime: process.uptime() + 's',
+    };
+  }
+
+  /**
+   * Generate health report
+   */
+  generateHealthReport() {
+    const health = this.getHealthStatus();
+    const recentAlerts = this.getAlertHistory(10);
+    const ruleStats = this.alertRules.map((rule) => ({
+      name: rule.name,
+      severity: rule.severity,
+      triggeredCount: rule.triggeredCount,
+      lastTriggered: rule.lastTriggered,
+    }));
+
+    return {
+      timestamp: new Date().toISOString(),
+      health,
+      recentAlerts,
+      ruleStatistics: ruleStats,
+      alertsSummary: {
+        total: this.alerts.length,
+        active: health.activeAlerts,
+        critical: health.criticalAlerts,
+        acknowledged: this.alerts.filter((a) => a.acknowledged).length,
+      },
+    };
+  }
+
+  /**
+   * Set metric threshold
+   */
+  setThreshold(metric, level, value) {
+    const thresholdKey = `${metric}${level.charAt(0).toUpperCase() + level.slice(1)}`;
+    if (thresholdKey in this.thresholds) {
+      this.thresholds[thresholdKey] = value;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get alert rules
+   */
+  getAlertRules(enabled = null) {
+    let rules = this.alertRules;
+
+    if (enabled !== null) {
+      rules = rules.filter((r) => r.enabled === enabled);
+    }
+
+    return rules;
+  }
+
+  /**
+   * Enable/disable alert rule
+   */
+  toggleAlertRule(ruleId, enabled) {
+    const rule = this.alertRules.find((r) => r.id === ruleId);
+    if (rule) {
+      rule.enabled = enabled;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Clear old alerts
+   */
+  clearOldAlerts(daysOld = 30) {
+    const cutoffTime = Date.now() - daysOld * 24 * 60 * 60 * 1000;
+    const beforeCount = this.alerts.length;
+
+    this.alerts = this.alerts.filter(
+      (alert) => new Date(alert.timestamp).getTime() > cutoffTime,
+    );
+
+    const removed = beforeCount - this.alerts.length;
+    this.logger.info(`Cleared ${removed} alerts older than ${daysOld} days`);
+
+    return { removed, remaining: this.alerts.length };
+  }
+
+  /**
+   * Simulate monitoring scenario for testing
+   */
+  async simulateMonitoring(duration = 5000, intervals = 10) {
+    const intervalMs = duration / intervals;
+    const results = [];
+
+    for (let i = 0; i < intervals; i++) {
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+
+      // Simulate changing metrics
+      const memoryUsage = 50 + Math.random() * 50;
+      const errorRate = Math.random() * 12;
+      const activeConnections = Math.floor(Math.random() * 100);
+
+      const update = this.updateMetrics({
+        memoryUsage: Math.round(memoryUsage),
+        errorRate: Math.round(errorRate * 10) / 10,
+        activeConnections,
+      });
+
+      results.push({
+        timestamp: new Date().toISOString(),
+        metrics: update.current,
+        alerts: this.getActiveAlerts(),
+      });
+    }
+
+    return {
+      duration,
+      intervals,
+      results,
+      finalHealth: this.getHealthStatus(),
+    };
+  }
+}
+
+export default MonitoringService;