Update app.py

app.py

@@ -1656,12 +1656,17 @@ class EnhancedReliabilityEngine:
         
         logger.info(f"Event processed: {result['status']} with {result['severity']} severity")
         
-        # Enhance with Claude AI reasoning (optional layer)
-        try:
-            result = await self.enhance_with_claude(event, result)
-        except Exception as e:
-            logger.error(f"Failed to enhance with Claude: {e}")
-            # Continue without enhancement
+        # Track business metrics for ROI dashboard
+        if is_anomaly and business_impact:
+            auto_healed = len(healing_actions) > 0 and healing_actions[0] != HealingAction.NO_ACTION
+            business_metrics.record_incident(
+                severity=event.severity.value,
+                auto_healed=auto_healed,
+                revenue_loss=business_impact['revenue_loss_estimate'],
+                detection_time_seconds=120.0  # Assume 2 min detection
+            )
+        
+        logger.info(f"Event processed: {result['status']} with {result['severity']} severity")
         
         return result
     
@@ -1669,6 +1674,92 @@ class EnhancedReliabilityEngine:
 enhanced_engine = EnhancedReliabilityEngine()
 
 
+# === Global Metrics Tracker for ROI Dashboard ===
+class BusinessMetricsTracker:
+    """Track cumulative business metrics for ROI dashboard"""
+    
+    def __init__(self):
+        self.total_incidents = 0
+        self.incidents_auto_healed = 0
+        self.total_revenue_saved = 0.0
+        self.total_revenue_at_risk = 0.0
+        self.detection_times = []
+        self._lock = threading.RLock()
+        logger.info("Initialized BusinessMetricsTracker")
+    
+    def record_incident(
+        self,
+        severity: str,
+        auto_healed: bool,
+        revenue_loss: float,
+        detection_time_seconds: float = 120.0  # 2 minutes default
+    ):
+        """Record an incident and update metrics"""
+        with self._lock:
+            self.total_incidents += 1
+            
+            if auto_healed:
+                self.incidents_auto_healed += 1
+            
+            # Calculate what revenue would have been lost (industry average: 14 min response)
+            # vs what we actually lost (ARF average: 2 min response)
+            industry_avg_response_minutes = 14
+            arf_response_minutes = detection_time_seconds / 60
+            
+            # Revenue at risk if using traditional monitoring
+            revenue_per_minute = revenue_loss / max(1, arf_response_minutes)
+            traditional_loss = revenue_per_minute * industry_avg_response_minutes
+            
+            self.total_revenue_at_risk += traditional_loss
+            self.total_revenue_saved += (traditional_loss - revenue_loss)
+            
+            self.detection_times.append(detection_time_seconds)
+            
+            logger.info(
+                f"Recorded incident: auto_healed={auto_healed}, "
+                f"saved=\${traditional_loss - revenue_loss:.2f}"
+            )
+    
+    def get_metrics(self) -> dict:
+        """Get current cumulative metrics"""
+        with self._lock:
+            auto_heal_rate = (
+                (self.incidents_auto_healed / self.total_incidents * 100)
+                if self.total_incidents > 0 else 0
+            )
+            
+            avg_detection_time = (
+                sum(self.detection_times) / len(self.detection_times)
+                if self.detection_times else 120.0
+            )
+            
+            return {
+                "total_incidents": self.total_incidents,
+                "incidents_auto_healed": self.incidents_auto_healed,
+                "auto_heal_rate": auto_heal_rate,
+                "total_revenue_saved": self.total_revenue_saved,
+                "total_revenue_at_risk": self.total_revenue_at_risk,
+                "avg_detection_time_seconds": avg_detection_time,
+                "avg_detection_time_minutes": avg_detection_time / 60,
+                "time_improvement": (
+                    (14 - (avg_detection_time / 60)) / 14 * 100
+                )  # vs industry 14 min
+            }
+    
+    def reset(self):
+        """Reset all metrics (for demo purposes)"""
+        with self._lock:
+            self.total_incidents = 0
+            self.incidents_auto_healed = 0
+            self.total_revenue_saved = 0.0
+            self.total_revenue_at_risk = 0.0
+            self.detection_times = []
+            logger.info("Reset BusinessMetricsTracker")
+
+
+# Initialize global tracker
+business_metrics = BusinessMetricsTracker()
+
 # === Rate Limiting ===
 class RateLimiter:
     """Simple rate limiter for request throttling"""