Update demo/mock_arf.py

demo/mock_arf.py

@@ -1,122 +1,444 @@
 """
-Mock ARF components for demo purposes
+Enhanced Mock ARF components for demo purposes
 In production, these would use the real agentic-reliability-framework package
 """
 import time
 import json
-from typing import Dict, Any, List
+import hashlib
+from typing import Dict, Any, List, Optional
 import random
+import logging
+from datetime import datetime, timedelta
 
-def simulate_arf_analysis(scenario: Dict[str, Any]) -> Dict[str, Any]:
-    """Simulate ARF analysis pipeline"""
-    return {
-        "analysis_complete": True,
-        "anomaly_detected": True,
-        "severity": "critical",
-        "root_cause": scenario.get('root_cause', 'unknown'),
-        "pattern_detected": True,
-        "pattern_confidence": random.uniform(0.8, 0.95),
-        "analysis_timestamp": time.time(),
-        "processing_time_ms": random.randint(200, 500)
-    }
+logger = logging.getLogger(__name__)
 
-def run_rag_similarity_search(scenario: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """Simulate RAG similarity search"""
-    component = scenario.get('component', 'redis_cache')
+
+class MockARFSimulator:
+    """Enhanced mock ARF simulator with realistic patterns"""
+    
+    def __init__(self, seed: Optional[int] = None):
+        self.seed = seed or int(time.time())
+        random.seed(self.seed)
+        self._incident_patterns = self._initialize_patterns()
+        self._healing_actions = self._initialize_healing_actions()
+    
+    def _initialize_patterns(self) -> Dict[str, Dict[str, Any]]:
+        """Initialize realistic incident patterns"""
+        return {
+            "cache_miss_storm": {
+                "pattern": "exponential_miss_increase",
+                "indicators": ["cache_hit_rate < 30%", "database_load > 80%", "response_time > 1500ms"],
+                "typical_causes": ["key_eviction", "cold_cache", "traffic_spike"],
+                "resolution_patterns": ["scale_out", "cache_warming", "ttl_optimization"]
+            },
+            "db_connection_exhaustion": {
+                "pattern": "connection_pool_saturation",
+                "indicators": ["active_connections > 95%", "connection_wait > 30s", "query_timeout_rate > 10%"],
+                "typical_causes": ["connection_leak", "slow_queries", "connection_pool_misconfig"],
+                "resolution_patterns": ["pool_tuning", "query_optimization", "circuit_breaker"]
+            },
+            "memory_leak": {
+                "pattern": "gradual_memory_increase",
+                "indicators": ["memory_usage > 90%", "gc_frequency_high", "restart_count_increasing"],
+                "typical_causes": ["object_retention", "resource_leak", "cache_growth"],
+                "resolution_patterns": ["heap_analysis", "restart", "memory_limit"]
+            },
+            "api_rate_limit": {
+                "pattern": "rate_limit_cascade",
+                "indicators": ["429_rate > 40%", "retry_storm", "cascade_failures"],
+                "typical_causes": ["burst_traffic", "misconfigured_limits", "retry_logic"],
+                "resolution_patterns": ["backoff_strategy", "circuit_breaker", "cache_responses"]
+            }
+        }
+    
+    def _initialize_healing_actions(self) -> Dict[str, Dict[str, Any]]:
+        """Initialize healing actions with success rates"""
+        return {
+            "scale_out": {
+                "action": "increase_capacity",
+                "success_rate": 0.87,
+                "typical_recovery_time": "5-15 minutes",
+                "risk_level": "low",
+                "prerequisites": ["capacity_available", "auto_scaling_enabled"]
+            },
+            "cache_warming": {
+                "action": "preload_cache",
+                "success_rate": 0.72,
+                "typical_recovery_time": "2-10 minutes",
+                "risk_level": "very_low",
+                "prerequisites": ["predictive_model", "cache_pattern_known"]
+            },
+            "restart_container": {
+                "action": "graceful_restart",
+                "success_rate": 0.95,
+                "typical_recovery_time": "1-3 minutes",
+                "risk_level": "medium",
+                "prerequisites": ["health_checks", "load_balancer", "redundancy"]
+            },
+            "circuit_breaker": {
+                "action": "fail_fast_protection",
+                "success_rate": 0.89,
+                "typical_recovery_time": "instant",
+                "risk_level": "low",
+                "prerequisites": ["dependency_awareness", "fallback_strategy"]
+            }
+        }
+    
+    def simulate_arf_analysis(self, scenario: Dict[str, Any]) -> Dict[str, Any]:
+        """Simulate ARF analysis pipeline with enhanced realism"""
+        component = scenario.get('component', 'unknown')
+        pattern_name = self._detect_pattern(component, scenario)
+        
+        return {
+            "analysis_complete": True,
+            "anomaly_detected": True,
+            "severity": self._determine_severity(scenario),
+            "root_cause": scenario.get('root_cause', 'resource_constraint'),
+            "pattern_detected": True,
+            "pattern_name": pattern_name,
+            "pattern_confidence": self._calculate_pattern_confidence(pattern_name),
+            "detection_method": "ensemble_ml_model",
+            "detection_time_ms": random.randint(150, 350),
+            "analysis_timestamp": time.time(),
+            "processing_time_ms": random.randint(200, 500),
+            "model_version": "arf-ml-v3.3.6",
+            "features_analyzed": self._extract_features(scenario)
+        }
+    
+    def run_rag_similarity_search(self, scenario: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Simulate RAG similarity search with realistic data"""
+        component = scenario.get('component', 'redis_cache')
+        pattern_name = self._detect_pattern(component, scenario)
+        
+        # Generate realistic similar incidents
+        similar_incidents = []
+        base_time = time.time()
+        
+        for i in range(random.randint(3, 5)):
+            days_ago = random.randint(1, 90)
+            incident_time = base_time - (days_ago * 86400)
+            
+            similarity = random.uniform(0.75, 0.95)
+            success = similarity > 0.82
+            
+            incident = {
+                "incident_id": f"inc_{int(incident_time)}_{i}",
+                "component": component,
+                "pattern": pattern_name,
+                "similarity_score": similarity,
+                "cosine_similarity": similarity,
+                "success": success,
+                "resolution": self._get_recommended_action(component),
+                "actions_taken": self._get_action_sequence(component, success),
+                "resolution_time_minutes": random.uniform(3.5, 18.5),
+                "timestamp": incident_time,
+                "occurred_at": datetime.fromtimestamp(incident_time).isoformat(),
+                "engineers_involved": random.randint(1, 3),
+                "blast_radius": f"{random.randint(1, 5)} services",
+                "root_cause_analysis": self._generate_root_cause(component)
+            }
+            
+            if success:
+                cost_saved = random.randint(1500, 12500)
+                incident["cost_savings"] = cost_saved
+                incident["mttr_reduction"] = f"{random.randint(60, 85)}%"
+                incident["user_impact"] = f"{random.randint(85, 99)}% reduction"
+            
+            similar_incidents.append(incident)
+        
+        # Sort by similarity
+        similar_incidents.sort(key=lambda x: x['similarity_score'], reverse=True)
+        
+        # Add RAG metadata
+        rag_metadata = {
+            "vector_db": "chroma_v0.4.0",
+            "embedding_model": "all-MiniLM-L6-v2",
+            "index_size": f"{random.randint(500, 5000)} incidents",
+            "retrieval_time_ms": random.randint(45, 120),
+            "top_k": len(similar_incidents)
+        }
+        
+        for incident in similar_incidents:
+            incident["rag_metadata"] = rag_metadata
+        
+        return similar_incidents
     
-    # Mock similar incidents based on scenario
-    similar_incidents = []
+    def calculate_pattern_confidence(self, scenario: Dict[str, Any], 
+                                   similar_incidents: List[Dict[str, Any]]) -> float:
+        """Calculate pattern detection confidence with enhanced logic"""
+        if not similar_incidents:
+            return 0.70  # Base confidence without similar incidents
+        
+        # Base confidence from pattern matching
+        component = scenario.get('component', 'unknown')
+        pattern_name = self._detect_pattern(component, scenario)
+        base_confidence = self._calculate_pattern_confidence(pattern_name)
+        
+        # Boost based on number of similar incidents
+        incident_count = len(similar_incidents)
+        incident_boost = min(0.15, incident_count * 0.025)
+        
+        # Boost based on average similarity
+        avg_similarity = sum(i['similarity_score'] for i in similar_incidents) / incident_count
+        similarity_boost = avg_similarity * 0.12
+        
+        # Boost based on success rate
+        success_count = sum(1 for i in similar_incidents if i['success'])
+        success_rate = success_count / incident_count
+        success_boost = success_rate * 0.10
+        
+        # Boost based on recency (weight recent incidents more)
+        recency_boost = self._calculate_recency_boost(similar_incidents)
+        
+        total_confidence = (
+            base_confidence + 
+            incident_boost + 
+            similarity_boost + 
+            success_boost + 
+            recency_boost
+        )
+        
+        # Cap at 0.98 and ensure minimum
+        return max(0.70, min(0.98, total_confidence))
     
-    # Generate 3-5 similar incidents
-    for i in range(random.randint(3, 5)):
-        similarity = random.uniform(0.7, 0.95)
-        success = similarity > 0.8
+    def create_mock_healing_intent(self, scenario: Dict[str, Any], 
+                                  similar_incidents: List[Dict[str, Any]], 
+                                  confidence: float = 0.85) -> Dict[str, Any]:
+        """Create a realistic mock HealingIntent object"""
+        
+        component = scenario.get('component', 'redis_cache')
+        pattern_name = self._detect_pattern(component, scenario)
+        
+        # Determine action based on component and pattern
+        action_info = self._determine_healing_action(component, pattern_name)
+        
+        # Generate deterministic ID
+        params_hash = hashlib.md5(
+            json.dumps(action_info['parameters'], sort_keys=True).encode()
+        ).hexdigest()[:8]
+        
+        # Calculate RAG similarity metrics
+        rag_metrics = self._calculate_rag_metrics(similar_incidents)
         
-        incident = {
-            "incident_id": f"inc_{int(time.time())}_{i}",
+        # Create healing intent
+        healing_intent = {
+            "action": action_info['action'],
             "component": component,
-            "similarity_score": similarity,
-            "success": success,
-            "resolution": "scale_out" if component == "redis_cache" else "restart",
-            "actions_taken": ["scale_out", "adjust_cache_ttl"] if component == "redis_cache" else ["restart_container"],
-            "resolution_time_minutes": random.uniform(5, 15),
-            "timestamp": time.time() - random.randint(86400, 2592000)  # 1-30 days ago
+            "pattern": pattern_name,
+            "parameters": action_info['parameters'],
+            "justification": action_info['justification'],
+            "confidence": confidence,
+            "incident_id": f"inc_{int(time.time())}",
+            "detected_at": time.time(),
+            "similar_incidents_count": len(similar_incidents),
+            "rag_similarity_score": rag_metrics['avg_similarity'],
+            "rag_metrics": rag_metrics,
+            "source": "oss_analysis",
+            "intent_id": f"intent_{int(time.time())}_{params_hash}",
+            "created_at": time.time(),
+            "status": "created",
+            "edition": "community",
+            "requires_enterprise": True,
+            "execution_allowed": False,
+            "safety_checks": {
+                "blast_radius": f"{random.randint(1, 3)} services",
+                "business_hours": "compliant",
+                "rollback_plan": "available",
+                "approval_required": True,
+                "risk_assessment": "low",
+                "compliance_check": "passed"
+            },
+            "expected_outcome": {
+                "recovery_time_minutes": action_info['recovery_time'],
+                "success_probability": action_info['success_rate'],
+                "cost_savings_estimate": self._estimate_savings(scenario),
+                "user_impact_reduction": f"{random.randint(85, 99)}%"
+            },
+            "deterministic_id": f"intent_{params_hash}"
         }
         
-        if success:
-            incident["cost_savings"] = random.randint(1000, 10000)
+        return healing_intent
+    
+    # Helper methods
+    def _detect_pattern(self, component: str, scenario: Dict[str, Any]) -> str:
+        """Detect incident pattern based on component"""
+        if 'cache' in component.lower():
+            return "cache_miss_storm"
+        elif 'database' in component.lower() or 'postgres' in component.lower():
+            return "db_connection_exhaustion"
+        elif 'memory' in component.lower() or 'java' in component.lower():
+            return "memory_leak"
+        elif 'api' in component.lower() or 'rate' in component.lower():
+            return "api_rate_limit"
+        else:
+            return "unknown_pattern"
+    
+    def _determine_severity(self, scenario: Dict[str, Any]) -> str:
+        """Determine incident severity"""
+        metrics = scenario.get('metrics', {})
         
-        similar_incidents.append(incident)
+        if 'error_rate' in metrics and metrics['error_rate'] > 30:
+            return "critical"
+        elif 'response_time_ms' in metrics and metrics['response_time_ms'] > 2000:
+            return "critical"
+        elif 'memory_usage' in metrics and metrics['memory_usage'] > 90:
+            return "high"
+        else:
+            return random.choice(["high", "medium"])
     
-    # Sort by similarity
-    similar_incidents.sort(key=lambda x: x['similarity_score'], reverse=True)
+    def _calculate_pattern_confidence(self, pattern_name: str) -> float:
+        """Calculate confidence for specific pattern"""
+        confidence_map = {
+            "cache_miss_storm": 0.92,
+            "db_connection_exhaustion": 0.88,
+            "memory_leak": 0.85,
+            "api_rate_limit": 0.90,
+            "unknown_pattern": 0.70
+        }
+        return confidence_map.get(pattern_name, 0.75)
     
-    return similar_incidents
-
-def calculate_pattern_confidence(scenario: Dict[str, Any], similar_incidents: List[Dict[str, Any]]) -> float:
-    """Calculate pattern detection confidence"""
-    if not similar_incidents:
-        return 0.7
+    def _extract_features(self, scenario: Dict[str, Any]) -> List[str]:
+        """Extract features for ML analysis"""
+        features = []
+        metrics = scenario.get('metrics', {})
+        
+        for key, value in metrics.items():
+            if isinstance(value, (int, float)):
+                features.append(f"{key}:{value}")
+        
+        # Add derived features
+        if 'cache_hit_rate' in metrics and metrics['cache_hit_rate'] < 30:
+            features.append("cache_miss_critical")
+        if 'error_rate' in metrics and metrics['error_rate'] > 10:
+            features.append("error_rate_high")
+        
+        return features[:10]  # Limit to 10 features
     
-    # Base confidence
-    base_confidence = 0.75
+    def _get_recommended_action(self, component: str) -> str:
+        """Get recommended healing action"""
+        if 'cache' in component.lower():
+            return 'scale_out'
+        elif 'database' in component.lower():
+            return 'optimize_connections'
+        elif 'memory' in component.lower():
+            return 'restart_container'
+        else:
+            return 'circuit_breaker'
     
-    # Boost based on number of similar incidents
-    incident_boost = min(0.15, len(similar_incidents) * 0.03)
+    def _get_action_sequence(self, component: str, success: bool) -> List[str]:
+        """Get sequence of actions taken"""
+        base_actions = []
+        
+        if 'cache' in component.lower():
+            base_actions = ["scale_out", "adjust_cache_ttl", "implement_warming"]
+        elif 'database' in component.lower():
+            base_actions = ["increase_pool_size", "add_timeout", "optimize_queries"]
+        
+        if success and random.random() > 0.5:
+            base_actions.append("add_monitoring")
+        
+        return base_actions
+    
+    def _generate_root_cause(self, component: str) -> str:
+        """Generate realistic root cause"""
+        causes = {
+            'cache': ["key_eviction_policy", "cold_cache_after_deploy", "traffic_spike_2x"],
+            'database': ["connection_leak_in_pool", "slow_query_cascade", "max_connections_limit"],
+            'memory': ["object_retention_in_cache", "thread_local_leak", "off_heap_memory_growth"]
+        }
+        
+        for key, cause_list in causes.items():
+            if key in component.lower():
+                return random.choice(cause_list)
+        
+        return "resource_constraint_under_load"
     
-    # Boost based on average similarity
-    avg_similarity = sum(i['similarity_score'] for i in similar_incidents) / len(similar_incidents)
-    similarity_boost = avg_similarity * 0.1
+    def _calculate_recency_boost(self, incidents: List[Dict[str, Any]]) -> float:
+        """Calculate boost based on incident recency"""
+        if not incidents:
+            return 0.0
+        
+        now = time.time()
+        recent_count = 0
+        
+        for incident in incidents:
+            incident_time = incident.get('timestamp', now)
+            days_ago = (now - incident_time) / 86400
+            
+            if days_ago < 7:  # Within last week
+                recent_count += 1
+        
+        return min(0.08, recent_count * 0.02)
     
-    # Boost based on success rate
-    success_rate = sum(1 for i in similar_incidents if i['success']) / len(similar_incidents)
-    success_boost = success_rate * 0.1
+    def _determine_healing_action(self, component: str, pattern: str) -> Dict[str, Any]:
+        """Determine healing action with parameters"""
+        if 'cache' in component.lower():
+            return {
+                "action": 'scale_out',
+                "parameters": {'scale_factor': random.choice([2, 3]), 'cache_ttl': 300},
+                "justification": "Scale Redis cluster and adjust cache TTL based on historical pattern",
+                "success_rate": 0.87,
+                "recovery_time": "5-15 minutes"
+            }
+        elif 'database' in component.lower():
+            return {
+                "action": 'optimize_connections',
+                "parameters": {'max_connections': 200, 'connection_timeout': 30},
+                "justification": "Optimize database connection pool settings based on load patterns",
+                "success_rate": 0.82,
+                "recovery_time": "2-8 minutes"
+            }
+        else:
+            return {
+                "action": 'restart_container',
+                "parameters": {'grace_period': 30, 'drain_connections': True},
+                "justification": "Restart container to resolve memory issues with graceful shutdown",
+                "success_rate": 0.95,
+                "recovery_time": "1-3 minutes"
+            }
     
-    total_confidence = base_confidence + incident_boost + similarity_boost + success_boost
+    def _calculate_rag_metrics(self, incidents: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Calculate RAG metrics"""
+        if not incidents:
+            return {
+                "avg_similarity": 0.0,
+                "similarity_std": 0.0,
+                "coverage_score": 0.0
+            }
+        
+        similarities = [i.get('similarity_score', 0) for i in incidents]
+        
+        return {
+            "avg_similarity": sum(similarities) / len(similarities),
+            "similarity_std": np.std(similarities) if len(similarities) > 1 else 0.0,
+            "coverage_score": min(1.0, len(incidents) / 5),
+            "diversity_score": random.uniform(0.6, 0.9)
+        }
     
-    return min(0.98, total_confidence)
+    def _estimate_savings(self, scenario: Dict[str, Any]) -> int:
+        """Estimate cost savings"""
+        impact = scenario.get('business_impact', {})
+        revenue_loss = impact.get('revenue_loss_per_hour', 5000)
+        
+        # 70-90% savings estimate
+        savings_percentage = random.uniform(0.7, 0.9)
+        return int(revenue_loss * savings_percentage)
+
+
+# Global simulator instance
+_simulator = MockARFSimulator()
+
+# Public API functions (backward compatibility)
+def simulate_arf_analysis(scenario: Dict[str, Any]) -> Dict[str, Any]:
+    return _simulator.simulate_arf_analysis(scenario)
+
+def run_rag_similarity_search(scenario: Dict[str, Any]) -> List[Dict[str, Any]]:
+    return _simulator.run_rag_similarity_search(scenario)
+
+def calculate_pattern_confidence(scenario: Dict[str, Any], similar_incidents: List[Dict[str, Any]]) -> float:
+    return _simulator.calculate_pattern_confidence(scenario, similar_incidents)
 
 def create_mock_healing_intent(scenario: Dict[str, Any], 
-                               similar_incidents: List[Dict[str, Any]], 
-                               confidence: float = 0.85) -> Dict[str, Any]:
-    """Create a mock HealingIntent object"""
-    
-    # Determine action based on scenario
-    component = scenario.get('component', 'redis_cache')
-    if component == 'redis_cache':
-        action = 'scale_out'
-        parameters = {'scale_factor': 2, 'cache_ttl': 300}
-        justification = "Scale Redis cluster and adjust cache TTL based on historical pattern"
-    elif component == 'database':
-        action = 'optimize_connections'
-        parameters = {'max_connections': 200, 'connection_timeout': 30}
-        justification = "Optimize database connection pool settings"
-    else:
-        action = 'restart_container'
-        parameters = {}
-        justification = "Restart container to resolve memory issues"
-    
-    # Calculate RAG similarity score
-    rag_score = None
-    if similar_incidents:
-        rag_score = sum(i['similarity_score'] for i in similar_incidents[:3]) / min(3, len(similar_incidents))
-    
-    return {
-        "action": action,
-        "component": component,
-        "parameters": parameters,
-        "justification": justification,
-        "confidence": confidence,
-        "incident_id": scenario.get('incident_id', f"inc_{int(time.time())}"),
-        "detected_at": time.time(),
-        "similar_incidents": similar_incidents,
-        "rag_similarity_score": rag_score,
-        "source": "oss_analysis",
-        "intent_id": f"intent_{int(time.time())}",
-        "created_at": time.time(),
-        "status": "created",
-        "oss_edition": "community",
-        "requires_enterprise": True,
-        "execution_allowed": False,
-        "deterministic_id": f"intent_{hash(json.dumps(parameters, sort_keys=True)) % 10000:04d}"
-    }
+                              similar_incidents: List[Dict[str, Any]], 
+                              confidence: float = 0.85) -> Dict[str, Any]:
+    return _simulator.create_mock_healing_intent(scenario, similar_incidents, confidence)