Update app.py

app.py

@@ -1041,7 +1041,7 @@ class AuditTrailManager:
     
     def get_execution_dataframe(self) -> pd.DataFrame:
         """
-        FIXED: Returns pandas DataFrame for Gradio DataFrame component
+        FIXED: Robust pandas DataFrame creation for Gradio DataFrame component
         """
         try:
             if not self.executions:
@@ -1051,50 +1051,136 @@ class AuditTrailManager:
                     "Start Time", "End Time", "Duration", "Boundary"
                 ])
             
-            # Build DataFrame from executions
+            # Build DataFrame from executions with safe access
             data = []
             for i, execution in enumerate(self.executions):
-                # Extract execution ID from result or generate one
-                exec_id = execution.get("result", {}).get("execution_id", f"exec_{i}")
-                status = "Success" if "success" in str(execution.get("result", {})).lower() else "Failed"
-                mode = execution.get("mode", "unknown")
-                scenario = execution.get("scenario", "Unknown")
-                timestamp = execution.get("timestamp", "")
-                boundary = execution.get("boundary_context", "Unknown")
-                
-                # Extract end time from telemetry if available
-                end_time = execution.get("result", {}).get("telemetry", {}).get("end_time", "")
-                duration = "12m"  # Mock duration
-                
-                data.append({
-                    "Execution ID": exec_id,
-                    "Scenario": scenario,
-                    "Status": status,
-                    "Mode": mode,
-                    "Start Time": timestamp[:19] if timestamp else "",  # Format: YYYY-MM-DD HH:MM:SS
-                    "End Time": end_time[:19] if end_time else "",
-                    "Duration": duration,
-                    "Boundary": boundary
-                })
+                try:
+                    # Safe access to nested dictionaries
+                    result = execution.get("result", {})
+                    
+                    # Execution ID - safe extraction with fallback
+                    exec_id = result.get("execution_id", f"exec_{i:03d}")
+                    
+                    # Status determination with multiple fallbacks
+                    status_text = "Unknown"
+                    if isinstance(result, dict):
+                        status_lower = str(result.get("status", "")).lower()
+                        if "success" in status_lower:
+                            status_text = "Success"
+                        elif "failed" in status_lower or "error" in status_lower:
+                            status_text = "Failed"
+                        else:
+                            # Check if there's an error key
+                            if result.get("error"):
+                                status_text = "Failed"
+                            else:
+                                status_text = "Success"
+                    
+                    # Mode extraction
+                    mode = execution.get("mode", "unknown")
+                    
+                    # Scenario extraction
+                    scenario = execution.get("scenario", "Unknown")
+                    
+                    # Timestamp formatting with validation
+                    timestamp = execution.get("timestamp", "")
+                    start_time = ""
+                    if timestamp and len(timestamp) > 10:
+                        try:
+                            # Format: YYYY-MM-DD HH:MM:SS
+                            start_time = timestamp[:19]
+                        except Exception:
+                            start_time = timestamp  # Fallback to raw string
+                    
+                    # End time extraction from telemetry
+                    end_time = ""
+                    telemetry = result.get("telemetry", {})
+                    if telemetry:
+                        end_timestamp = telemetry.get("end_time", "")
+                        if end_timestamp and len(end_timestamp) > 10:
+                            try:
+                                end_time = end_timestamp[:19]
+                            except Exception:
+                                end_time = end_timestamp  # Fallback
+                    
+                    # Duration - mock or extract from execution
+                    duration = "12m"  # Default mock duration
+                    if telemetry and "estimated_duration" in telemetry:
+                        duration = telemetry.get("estimated_duration", "12m")
+                    
+                    # Boundary context
+                    boundary = execution.get("boundary_context", "Unknown")
+                    
+                    data.append({
+                        "Execution ID": exec_id,
+                        "Scenario": scenario,
+                        "Status": status_text,
+                        "Mode": mode,
+                        "Start Time": start_time,
+                        "End Time": end_time,
+                        "Duration": duration,
+                        "Boundary": boundary
+                    })
+                    
+                except Exception as row_error:
+                    logger.warning(f"Error processing execution row {i}: {row_error}")
+                    # Add error row for debugging
+                    data.append({
+                        "Execution ID": f"error_{i}",
+                        "Scenario": "Error",
+                        "Status": "Failed",
+                        "Mode": "error",
+                        "Start Time": datetime.datetime.now().isoformat()[:19],
+                        "End Time": "",
+                        "Duration": "0m",
+                        "Boundary": "Error processing"
+                    })
+            
+            if not data:
+                logger.warning("No valid execution data found, returning empty DataFrame")
+                return pd.DataFrame(columns=[
+                    "Execution ID", "Scenario", "Status", "Mode", 
+                    "Start Time", "End Time", "Duration", "Boundary"
+                ])
             
+            # Create DataFrame
             df = pd.DataFrame(data)
             
-            # Sort by time (newest first)
+            # Safe sorting - only if we have valid Start Time data
             if not df.empty and "Start Time" in df.columns:
-                df = df.sort_values("Start Time", ascending=False)
+                # Check if Start Time column has valid data
+                valid_times = df["Start Time"].apply(
+                    lambda x: isinstance(x, str) and len(x) > 0 and x != "None"
+                )
+                
+                if valid_times.any():
+                    try:
+                        # Sort by time (newest first)
+                        df = df.sort_values("Start Time", ascending=False)
+                    except Exception as sort_error:
+                        logger.warning(f"Could not sort DataFrame: {sort_error}")
+                        # Keep unsorted if sorting fails
+                else:
+                    logger.debug("No valid timestamps for sorting")
             
+            logger.info(f"✅ Created execution DataFrame with {len(df)} rows")
             return df
             
         except Exception as e:
-            logger.error(f"Error creating execution DataFrame: {e}")
-            # Return empty DataFrame as fallback
-            return pd.DataFrame(columns=[
-                "Error", "Message"
-            ]).from_records([{"Error": "DataFrame Error", "Message": str(e)}])
+            logger.error(f"❌ Error creating execution DataFrame: {e}")
+            # Return informative error DataFrame
+            error_df = pd.DataFrame(columns=[
+                "Error", "Message", "Timestamp"
+            ]).from_records([{
+                "Error": "DataFrame Creation Failed",
+                "Message": str(e),
+                "Timestamp": datetime.datetime.now().isoformat()[:19]
+            }])
+            return error_df
     
     def get_incident_dataframe(self) -> pd.DataFrame:
         """
-        FIXED: Returns pandas DataFrame for Gradio DataFrame component
+        FIXED: Robust pandas DataFrame creation for Gradio DataFrame component
         """
         try:
             if not self.incidents:
@@ -1104,46 +1190,135 @@ class AuditTrailManager:
                     "Confidence", "Action", "Target"
                 ])
             
-            # Build DataFrame from incidents
+            # Build DataFrame from incidents with safe access
             data = []
             for i, incident in enumerate(self.incidents):
-                scenario = incident.get("scenario", "Unknown")
-                analysis = incident.get("analysis", {})
-                status = analysis.get("status", "analyzed").capitalize()
-                boundary = incident.get("boundary_context", "OSS analysis")
-                timestamp = incident.get("timestamp", "")
-                time_display = timestamp[11:19] if len(timestamp) > 11 else ""
-                
-                # Extract analysis details
-                healing_intent = analysis.get("oss_analysis", {}).get("analysis", {}).get("decision", {})
-                confidence = healing_intent.get("confidence", 0.85)
-                action = healing_intent.get("action", "Analysis")
-                target = healing_intent.get("target", "system")
-                
-                data.append({
-                    "Scenario": scenario,
-                    "Status": status,
-                    "Boundary": boundary,
-                    "Time": time_display,
-                    "Confidence": f"{confidence * 100:.1f}%",
-                    "Action": action,
-                    "Target": target
-                })
+                try:
+                    # Safe extraction of basic fields
+                    scenario = incident.get("scenario", "Unknown")
+                    boundary = incident.get("boundary_context", "OSS analysis")
+                    
+                    # Analysis data extraction
+                    analysis = incident.get("analysis", {})
+                    
+                    # Status determination
+                    status = "Analyzed"
+                    if isinstance(analysis, dict):
+                        analysis_status = analysis.get("status", "").lower()
+                        if analysis_status:
+                            status = analysis_status.capitalize()
+                        else:
+                            # Fallback status determination
+                            if analysis.get("error"):
+                                status = "Error"
+                            elif analysis.get("analysis") or analysis.get("oss_analysis"):
+                                status = "Success"
+                    
+                    # Timestamp formatting
+                    timestamp = incident.get("timestamp", "")
+                    time_display = ""
+                    if timestamp and len(timestamp) > 10:
+                        try:
+                            # Extract HH:MM:SS
+                            time_display = timestamp[11:19]
+                        except Exception:
+                            time_display = timestamp[:8] if len(timestamp) >= 8 else timestamp
+                    
+                    # Extract healing intent details with multiple fallback paths
+                    confidence = 0.85  # Default confidence
+                    action = "Analysis"
+                    target = "system"
+                    
+                    # Try multiple paths to find healing intent
+                    healing_intent = None
+                    
+                    # Path 1: oss_analysis -> analysis -> decision
+                    oss_analysis = analysis.get("oss_analysis", {})
+                    if isinstance(oss_analysis, dict):
+                        oss_analysis_inner = oss_analysis.get("analysis", {})
+                        if isinstance(oss_analysis_inner, dict):
+                            healing_intent = oss_analysis_inner.get("decision", {})
+                    
+                    # Path 2: direct analysis -> decision
+                    if not healing_intent and isinstance(analysis.get("analysis", {}), dict):
+                        healing_intent = analysis["analysis"].get("decision", {})
+                    
+                    # Path 3: direct healing_intent
+                    if not healing_intent:
+                        healing_intent = analysis.get("healing_intent", {})
+                    
+                    if healing_intent and isinstance(healing_intent, dict):
+                        confidence = healing_intent.get("confidence", 0.85)
+                        action = healing_intent.get("action", "Analysis")
+                        target = healing_intent.get("target", "system")
+                    
+                    # Format confidence as percentage
+                    confidence_display = f"{confidence * 100:.1f}%"
+                    
+                    data.append({
+                        "Scenario": scenario,
+                        "Status": status,
+                        "Boundary": boundary,
+                        "Time": time_display,
+                        "Confidence": confidence_display,
+                        "Action": action[:50],  # Limit action length
+                        "Target": target[:30]   # Limit target length
+                    })
+                    
+                except Exception as row_error:
+                    logger.warning(f"Error processing incident row {i}: {row_error}")
+                    # Add error row for debugging
+                    data.append({
+                        "Scenario": "Error",
+                        "Status": "Failed",
+                        "Boundary": "Error processing",
+                        "Time": datetime.datetime.now().isoformat()[11:19],
+                        "Confidence": "0.0%",
+                        "Action": "Error",
+                        "Target": "system"
+                    })
+            
+            if not data:
+                logger.warning("No valid incident data found, returning empty DataFrame")
+                return pd.DataFrame(columns=[
+                    "Scenario", "Status", "Boundary", "Time", 
+                    "Confidence", "Action", "Target"
+                ])
             
+            # Create DataFrame
             df = pd.DataFrame(data)
             
-            # Sort by time (newest first)
+            # Safe sorting - only if we have valid Time data
             if not df.empty and "Time" in df.columns:
-                df = df.sort_values("Time", ascending=False)
+                # Check if Time column has valid data
+                valid_times = df["Time"].apply(
+                    lambda x: isinstance(x, str) and len(x) > 0 and x != "None"
+                )
+                
+                if valid_times.any():
+                    try:
+                        # Sort by time (newest first)
+                        df = df.sort_values("Time", ascending=False)
+                    except Exception as sort_error:
+                        logger.warning(f"Could not sort incident DataFrame: {sort_error}")
+                        # Keep unsorted if sorting fails
+                else:
+                    logger.debug("No valid timestamps for sorting in incident DataFrame")
             
+            logger.info(f"✅ Created incident DataFrame with {len(df)} rows")
             return df
             
         except Exception as e:
-            logger.error(f"Error creating incident DataFrame: {e}")
-            # Return empty DataFrame as fallback
-            return pd.DataFrame(columns=[
-                "Error", "Message"
-            ]).from_records([{"Error": "DataFrame Error", "Message": str(e)}])
+            logger.error(f"❌ Error creating incident DataFrame: {e}")
+            # Return informative error DataFrame
+            error_df = pd.DataFrame(columns=[
+                "Error", "Message", "Timestamp"
+            ]).from_records([{
+                "Error": "DataFrame Creation Failed",
+                "Message": str(e),
+                "Timestamp": datetime.datetime.now().isoformat()[:19]
+            }])
+            return error_df
     
     def get_execution_table_html(self):
         """Legacy HTML method for backward compatibility"""