Update app.py

app.py

@@ -1,7 +1,7 @@
 """
 🚀 ARF ULTIMATE INVESTOR DEMO v3.4.0
 Enhanced with professional visualizations, export features, and data persistence
-FINAL ENHANCED VERSION: All visualizations working + Interactive Capability Matrix
+FINAL ENHANCED VERSION WITH INCIDENT HISTORY & AUDIT TRAIL
 """
 
 import asyncio
@@ -52,8 +52,37 @@ class VisualizationEngine:
     def __init__(self):
         self.performance_data = deque(maxlen=100)
         self.incident_history = []
+        self.execution_history = []  # NEW: Store execution history
         self.color_palette = px.colors.qualitative.Set3
         
+    def add_to_history(self, incident: Dict):
+        """Add incident to history"""
+        self.incident_history.append({
+            **incident,
+            "id": str(uuid.uuid4())[:8],
+            "timestamp": datetime.datetime.now()
+        })
+    
+    def add_execution_to_history(self, execution: Dict):
+        """Add execution to history"""
+        self.execution_history.append({
+            **execution,
+            "id": str(uuid.uuid4())[:8],
+            "timestamp": datetime.datetime.now()
+        })
+    
+    def get_incident_history(self, limit: int = 20) -> List[Dict]:
+        """Get recent incident history"""
+        return sorted(self.incident_history[-limit:], 
+                     key=lambda x: x.get('timestamp', datetime.datetime.min), 
+                     reverse=True)
+    
+    def get_execution_history(self, limit: int = 20) -> List[Dict]:
+        """Get recent execution history"""
+        return sorted(self.execution_history[-limit:], 
+                     key=lambda x: x.get('timestamp', datetime.datetime.min), 
+                     reverse=True)
+    
     def create_performance_radar(self, metrics: Dict[str, float]) -> go.Figure:
         """Create performance radar chart"""
         categories = list(metrics.keys())
@@ -109,7 +138,7 @@ class VisualizationEngine:
         
         # Prepare data for heatmap
         hours = list(range(24))
-        services = sorted(list(set(inc['service'] for inc in incidents if 'service' in inc)))
+        services = sorted(list(set(inc.get('service', 'Unknown') for inc in incidents if inc.get('service'))))
         
         if not services:
             services = ["Service A", "Service B", "Service C", "Service D", "Service E"]
@@ -118,10 +147,13 @@ class VisualizationEngine:
         severity_matrix = np.zeros((len(services), len(hours)))
         
         for inc in incidents:
-            if 'service' in inc and 'hour' in inc:
+            if inc.get('service') and inc.get('hour') is not None:
                 try:
-                    service_idx = services.index(inc['service'])
-                    hour_idx = int(inc['hour']) % 24
+                    service = inc.get('service', 'Unknown')
+                    if service not in services:
+                        services.append(service)
+                    service_idx = services.index(service)
+                    hour_idx = int(inc.get('hour', 0)) % 24
                     severity = inc.get('severity', 1)
                     severity_matrix[service_idx, hour_idx] = max(
                         severity_matrix[service_idx, hour_idx], severity
@@ -129,6 +161,13 @@ class VisualizationEngine:
                 except (ValueError, IndexError):
                     continue
         
+        # Ensure matrix matches services length
+        if len(severity_matrix) < len(services):
+            severity_matrix = np.vstack([
+                severity_matrix, 
+                np.zeros((len(services) - len(severity_matrix), len(hours)))
+            ])
+        
         # Create heatmap with corrected colorbar configuration
         fig = go.Figure(data=go.Heatmap(
             z=severity_matrix,
@@ -174,6 +213,143 @@ class VisualizationEngine:
         
         return fig
     
+    def create_incident_timeline(self, incidents: List[Dict]) -> go.Figure:
+        """Create interactive incident timeline"""
+        if not incidents:
+            return self._create_empty_figure("No incident history available")
+        
+        # Prepare timeline data
+        timeline_data = []
+        for inc in incidents:
+            timeline_data.append({
+                'timestamp': inc.get('timestamp', datetime.datetime.now()),
+                'service': inc.get('service', 'Unknown'),
+                'severity': inc.get('severity', 1),
+                'type': inc.get('type', 'incident'),
+                'description': inc.get('description', ''),
+                'id': inc.get('id', '')
+            })
+        
+        df = pd.DataFrame(timeline_data)
+        df['timestamp'] = pd.to_datetime(df['timestamp'])
+        df = df.sort_values('timestamp')
+        
+        # Map severity to colors and sizes
+        severity_colors = {
+            1: 'green',
+            2: 'orange', 
+            3: 'red'
+        }
+        
+        fig = go.Figure()
+        
+        # Group by service for better visualization
+        services = df['service'].unique()
+        
+        for service in services:
+            service_df = df[df['service'] == service]
+            fig.add_trace(go.Scatter(
+                x=service_df['timestamp'],
+                y=[service] * len(service_df),
+                mode='markers',
+                name=service,
+                marker=dict(
+                    size=[s * 10 for s in service_df['severity']],
+                    color=[severity_colors.get(s, 'gray') for s in service_df['severity']],
+                    symbol='circle',
+                    line=dict(width=2, color='white')
+                ),
+                text=[f"<b>{row['service']}</b><br>Severity: {row['severity']}/3<br>Time: {row['timestamp'].strftime('%H:%M')}<br>{row.get('description', '')}" 
+                      for _, row in service_df.iterrows()],
+                hoverinfo='text'
+            ))
+        
+        fig.update_layout(
+            title="Incident Timeline (Last 24h)",
+            xaxis_title="Time",
+            yaxis_title="Service",
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)',
+            height=400,
+            hovermode='closest',
+            showlegend=True
+        )
+        
+        return fig
+    
+    def create_execution_history_chart(self, executions: List[Dict]) -> go.Figure:
+        """Create execution history visualization"""
+        if not executions:
+            return self._create_empty_figure("No execution history available")
+        
+        # Prepare data
+        timeline_data = []
+        for exec in executions:
+            timeline_data.append({
+                'timestamp': exec.get('timestamp', datetime.datetime.now()),
+                'scenario': exec.get('scenario', 'Unknown'),
+                'actions': len(exec.get('actions', [])),
+                'status': exec.get('status', ''),
+                'time_savings': exec.get('time_savings', ''),
+                'cost_saved': exec.get('cost_saved', '$0')
+            })
+        
+        df = pd.DataFrame(timeline_data)
+        df['timestamp'] = pd.to_datetime(df['timestamp'])
+        df = df.sort_values('timestamp')
+        
+        fig = make_subplots(
+            rows=2, cols=1,
+            subplot_titles=('Execution Timeline', 'Cost Savings Over Time'),
+            vertical_spacing=0.15,
+            row_heights=[0.6, 0.4]
+        )
+        
+        # Timeline
+        for scenario in df['scenario'].unique():
+            scenario_df = df[df['scenario'] == scenario]
+            fig.add_trace(
+                go.Scatter(
+                    x=scenario_df['timestamp'],
+                    y=scenario_df['actions'],
+                    mode='markers+lines',
+                    name=scenario,
+                    marker=dict(size=10),
+                    text=[f"<b>{row['scenario']}</b><br>Actions: {row['actions']}<br>Time: {row['timestamp'].strftime('%H:%M')}<br>{row['status']}<br>{row['time_savings']}"
+                          for _, row in scenario_df.iterrows()],
+                    hoverinfo='text'
+                ),
+                row=1, col=1
+            )
+        
+        # Cost savings
+        df['cost_numeric'] = df['cost_saved'].apply(lambda x: float(x.replace('$', '').replace(',', '')) if isinstance(x, str) else 0)
+        fig.add_trace(
+            go.Bar(
+                x=df['timestamp'],
+                y=df['cost_numeric'],
+                name='Cost Saved',
+                marker_color='lightseagreen',
+                text=[f"${x:,.0f}" for x in df['cost_numeric']],
+                textposition='outside'
+            ),
+            row=2, col=1
+        )
+        
+        fig.update_layout(
+            height=500,
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)',
+            showlegend=True
+        )
+        
+        fig.update_xaxes(title_text="Time", row=1, col=1)
+        fig.update_xaxes(title_text="Time", row=2, col=1)
+        fig.update_yaxes(title_text="Actions Executed", row=1, col=1)
+        fig.update_yaxes(title_text="Cost Saved ($)", row=2, col=1)
+        
+        return fig
+    
     def create_stream_graph(self, metrics_history: List[Dict]) -> go.Figure:
         """Create streaming metrics visualization"""
         if not metrics_history:
@@ -785,9 +961,10 @@ class OSSModel:
 class EnterpriseModel:
     """Enterprise Edition Model (Autonomous Execution)"""
     
-    def __init__(self):
+    def __init__(self, viz_engine):
         self.execution_history = []
         self.learning_engine = LearningEngine()
+        self.viz_engine = viz_engine
     
     def execute_healing(self, scenario: Dict, approval_required: bool = True) -> Dict[str, Any]:
         """Execute healing actions with optional approval"""
@@ -820,6 +997,18 @@ class EnterpriseModel:
             oss_time = scenario.get("business_impact", {}).get("recovery_time_oss", "60 minutes")
             ent_time = scenario.get("business_impact", {}).get("recovery_time_enterprise", "10 minutes")
             cost_saved = execution_results.get("business_outcomes", {}).get("cost_saved", "$0")
+            time_savings = f"{oss_time} → {ent_time}"
+            
+            # Add to visualization engine history
+            self.viz_engine.add_execution_to_history({
+                "execution_id": execution_id,
+                "timestamp": timestamp,
+                "scenario": scenario.get("name"),
+                "actions": len(actions),
+                "status": status,
+                "time_savings": time_savings,
+                "cost_saved": cost_saved
+            })
             
             return {
                 "execution_id": execution_id,
@@ -827,7 +1016,7 @@ class EnterpriseModel:
                 "actions_executed": len(actions),
                 "results": execution_results,
                 "status": status,
-                "time_savings": f"{oss_time} → {ent_time}",
+                "time_savings": time_savings,
                 "cost_saved": cost_saved,
                 "learning_applied": True,
                 "compliance_logged": True,
@@ -939,7 +1128,7 @@ class ROICalculator:
         }
 
 # ===========================================
-# MAIN ENHANCED APPLICATION
+# MAIN ENHANCED APPLICATION WITH INCIDENT HISTORY
 # ===========================================
 
 class ARFUltimateInvestorDemo:
@@ -949,7 +1138,7 @@ class ARFUltimateInvestorDemo:
         self.viz_engine = VisualizationEngine()
         self.incident_scenarios = IncidentScenarios()
         self.oss_model = OSSModel()
-        self.enterprise_model = EnterpriseModel()
+        self.enterprise_model = EnterpriseModel(self.viz_engine)
         self.roi_calculator = ROICalculator()
         
         # Initialize incident history for visualizations
@@ -958,22 +1147,31 @@ class ARFUltimateInvestorDemo:
     def _init_incident_history(self):
         """Initialize sample incident history for visualizations"""
         services = ["API Gateway", "Database", "Cache", "Auth Service", "Payment Service"]
+        scenario_names = list(self.incident_scenarios.SCENARIOS.keys())
         
         for i in range(20):
             hour = random.randint(0, 23)
             severity = random.choices([0, 1, 2, 3], weights=[0.3, 0.4, 0.2, 0.1])[0]
             
             if severity > 0:  # Only record actual incidents
-                self.viz_engine.incident_history.append({
+                scenario = random.choice(scenario_names)
+                scenario_data = self.incident_scenarios.get_scenario(scenario)
+                
+                incident_record = {
                     "timestamp": datetime.datetime.now() - datetime.timedelta(hours=24-i),
                     "hour": hour,
-                    "service": random.choice(services),
+                    "service": random.choice(scenario_data.get("services_affected", services)),
                     "severity": severity,
-                    "type": random.choice(["latency", "error", "timeout", "crash"])
-                })
+                    "type": scenario_data.get("name", "incident"),
+                    "description": scenario_data.get("description", ""),
+                    "scenario_id": scenario,
+                    "id": str(uuid.uuid4())[:8]
+                }
+                
+                self.viz_engine.add_to_history(incident_record)
     
     def create_demo_interface(self):
-        """Create the main Gradio interface"""
+        """Create the main Gradio interface with incident history"""
         
         # CSS for professional styling
         css = """
@@ -1002,6 +1200,9 @@ class ARFUltimateInvestorDemo:
         .oss-card {
             border-left: 4px solid #f59e0b;
         }
+        .history-card {
+            border-left: 4px solid #3b82f6;
+        }
         .capability-table {
             width: 100%;
             border-collapse: collapse;
@@ -1023,6 +1224,9 @@ class ARFUltimateInvestorDemo:
         .demo-button {
             margin: 5px;
         }
+        .tab-button {
+            margin: 2px;
+        }
         """
         
         with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
@@ -1064,7 +1268,7 @@ class ARFUltimateInvestorDemo:
                             
                             gr.Markdown("### 📊 Visualization Type")
                             viz_type = gr.Radio(
-                                choices=["Radar Chart", "Heatmap", "Stream"],
+                                choices=["Radar Chart", "Heatmap", "Stream", "Incident Timeline"],
                                 label="Choose how to visualize the metrics",
                                 value="Radar Chart"
                             )
@@ -1125,7 +1329,50 @@ class ARFUltimateInvestorDemo:
                             roi_results = gr.JSON(value={})
                             calculate_roi_btn = gr.Button("📊 Calculate ROI", variant="primary")
                 
-                # ============ TAB 3: INTERACTIVE CAPABILITY MATRIX ============
+                # ============ TAB 3: INCIDENT HISTORY & AUDIT TRAIL ============
+                with gr.TabItem("📜 Incident History & Audit"):
+                    with gr.Row():
+                        with gr.Column(scale=2):
+                            gr.Markdown("### 📋 Recent Incidents (Last 24h)")
+                            
+                            # Incident history controls
+                            with gr.Row():
+                                refresh_history_btn = gr.Button("🔄 Refresh History", variant="secondary", size="sm")
+                                clear_history_btn = gr.Button("🗑️ Clear History", variant="stop", size="sm")
+                            
+                            incident_history_table = gr.Dataframe(
+                                label="Incident Log",
+                                headers=["Time", "Service", "Type", "Severity", "Description"],
+                                datatype=["str", "str", "str", "str", "str"],
+                                col_count=(5, "fixed"),
+                                height=300,
+                                value=[]
+                            )
+                            
+                            gr.Markdown("### 📊 Incident Timeline")
+                            incident_timeline_viz = gr.Plot()
+                        
+                        with gr.Column(scale=2):
+                            gr.Markdown("### 📋 Execution History (Audit Trail)")
+                            
+                            # Execution history controls
+                            with gr.Row():
+                                refresh_executions_btn = gr.Button("🔄 Refresh Executions", variant="secondary", size="sm")
+                                export_audit_btn = gr.Button("📥 Export Audit Trail", variant="secondary", size="sm")
+                            
+                            execution_history_table = gr.Dataframe(
+                                label="Execution Audit Trail",
+                                headers=["Time", "Scenario", "Actions", "Status", "Time Saved", "Cost Saved"],
+                                datatype=["str", "str", "str", "str", "str", "str"],
+                                col_count=(6, "fixed"),
+                                height=300,
+                                value=[]
+                            )
+                            
+                            gr.Markdown("### 📈 Execution History Chart")
+                            execution_history_chart = gr.Plot()
+                
+                # ============ TAB 4: INTERACTIVE CAPABILITY MATRIX ============
                 with gr.TabItem("📊 Capability Matrix"):
                     with gr.Column():
                         gr.Markdown("### 🚀 Ready to transform your reliability operations?")
@@ -1200,6 +1447,8 @@ class ARFUltimateInvestorDemo:
                     viz = self.viz_engine.create_performance_radar(metrics)
                 elif viz_type == "Heatmap":
                     viz = self.viz_engine.create_heatmap_timeline(self.viz_engine.incident_history)
+                elif viz_type == "Incident Timeline":
+                    viz = self.viz_engine.create_incident_timeline(self.viz_engine.incident_history)
                 else:  # Stream
                     # Create sample stream data
                     stream_data = []
@@ -1223,6 +1472,67 @@ class ARFUltimateInvestorDemo:
                     heatmap_output: incident_heatmap
                 }
             
+            def get_incident_history_data():
+                """Get formatted incident history for table"""
+                incidents = self.viz_engine.get_incident_history(limit=20)
+                formatted_data = []
+                
+                for inc in incidents:
+                    timestamp = inc.get('timestamp', datetime.datetime.now())
+                    if isinstance(timestamp, str):
+                        timestamp = datetime.datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+                    
+                    formatted_data.append([
+                        timestamp.strftime('%H:%M'),
+                        inc.get('service', 'Unknown'),
+                        inc.get('type', 'incident'),
+                        f"{inc.get('severity', 1)}/3",
+                        inc.get('description', '')[:50] + '...' if len(inc.get('description', '')) > 50 else inc.get('description', '')
+                    ])
+                
+                return formatted_data
+            
+            def get_execution_history_data():
+                """Get formatted execution history for table"""
+                executions = self.viz_engine.get_execution_history(limit=20)
+                formatted_data = []
+                
+                for exec in executions:
+                    timestamp = exec.get('timestamp', datetime.datetime.now())
+                    if isinstance(timestamp, str):
+                        timestamp = datetime.datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+                    
+                    formatted_data.append([
+                        timestamp.strftime('%H:%M'),
+                        exec.get('scenario', 'Unknown'),
+                        str(exec.get('actions', 0)),
+                        exec.get('status', ''),
+                        exec.get('time_savings', 'N/A'),
+                        exec.get('cost_saved', '$0')
+                    ])
+                
+                return formatted_data
+            
+            def refresh_history():
+                """Refresh history displays"""
+                incident_data = get_incident_history_data()
+                execution_data = get_execution_history_data()
+                incident_timeline = self.viz_engine.create_incident_timeline(self.viz_engine.incident_history)
+                execution_chart = self.viz_engine.create_execution_history_chart(self.viz_engine.execution_history)
+                
+                return {
+                    incident_history_table: incident_data,
+                    execution_history_table: execution_data,
+                    incident_timeline_viz: incident_timeline,
+                    execution_history_chart: execution_chart
+                }
+            
+            def clear_history():
+                """Clear all history"""
+                self.viz_engine.incident_history.clear()
+                self.viz_engine.execution_history.clear()
+                return refresh_history()
+            
             def run_oss_analysis(scenario_id: str):
                 """Run OSS analysis on selected scenario"""
                 scenario = self.incident_scenarios.get_scenario(scenario_id)
@@ -1240,10 +1550,14 @@ class ARFUltimateInvestorDemo:
                 # Update visualizations
                 predictive_viz = self.viz_engine.create_predictive_timeline(self.viz_engine.incident_history)
                 
+                # Also update history
+                history_update = refresh_history()
+                
                 return {
                     enterprise_results: results,
                     roi_results: roi,
-                    predictive_timeline: predictive_viz
+                    predictive_timeline: predictive_viz,
+                    **history_update
                 }
             
             def calculate_comprehensive_roi():
@@ -1425,7 +1739,9 @@ class ARFUltimateInvestorDemo:
             execute_btn.click(
                 fn=run_enterprise_execution,
                 inputs=[scenario_dropdown, approval_toggle],
-                outputs=[enterprise_results, roi_results, predictive_timeline]
+                outputs=[enterprise_results, roi_results, predictive_timeline, 
+                        incident_history_table, execution_history_table, 
+                        incident_timeline_viz, execution_history_chart]
             )
             
             # ROI Calculation
@@ -1435,6 +1751,21 @@ class ARFUltimateInvestorDemo:
                 outputs=[roi_results, performance_radar, learning_insights]
             )
             
+            # History tab interactions
+            refresh_history_btn.click(
+                fn=refresh_history,
+                inputs=[],
+                outputs=[incident_history_table, execution_history_table, 
+                        incident_timeline_viz, execution_history_chart]
+            )
+            
+            clear_history_btn.click(
+                fn=clear_history,
+                inputs=[],
+                outputs=[incident_history_table, execution_history_table, 
+                        incident_timeline_viz, execution_history_chart]
+            )
+            
             # Capability Matrix Interactions
             capability_select.change(
                 fn=update_capability_demo,
@@ -1458,7 +1789,9 @@ class ARFUltimateInvestorDemo:
             run_enterprise_demo.click(
                 fn=lambda: run_enterprise_execution("cache_miss_storm", False),
                 inputs=[],
-                outputs=[enterprise_results, roi_results, predictive_timeline]
+                outputs=[enterprise_results, roi_results, predictive_timeline,
+                        incident_history_table, execution_history_table,
+                        incident_timeline_viz, execution_history_chart]
             )
             
             # Initial load
@@ -1474,6 +1807,13 @@ class ARFUltimateInvestorDemo:
                 outputs=[roi_results, performance_radar, learning_insights]
             )
             
+            demo.load(
+                fn=refresh_history,
+                inputs=[],
+                outputs=[incident_history_table, execution_history_table, 
+                        incident_timeline_viz, execution_history_chart]
+            )
+            
             # Footer
             gr.Markdown("""
             ---