fix: run diagnostics

app.py

@@ -19,84 +19,128 @@ from typing import List, Dict, Any
 # from app_trans_new import create_transcation_visualizations,create_active_agents_visualizations
 # APR visualization functions integrated directly
 
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+# Set up more detailed logging
+logging.basicConfig(
+    level=logging.DEBUG,  # Change to DEBUG for more detailed logs
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.FileHandler("app_debug.log"),  # Log to file for persistence
+        logging.StreamHandler()  # Also log to console
+    ]
+)
 logger = logging.getLogger(__name__)
 
+# Log the startup information
+logger.info("============= APPLICATION STARTING =============")
+logger.info(f"Running from directory: {os.getcwd()}")
+
 # Global variable to store the data for reuse
 global_df = None
 
 # Configuration
 API_BASE_URL = "https://afmdb.autonolas.tech"
-
-# Add a timezone adjustment function at the top of the file after imports
-def adjust_timestamp(timestamp_dt, hours_offset=0):
-    """
-    Adjust a timestamp by the specified number of hours.
-    Used to correct for timezone differences between environments.
-    
-    Args:
-        timestamp_dt: datetime object to adjust
-        hours_offset: number of hours to add (can be negative)
-        
-    Returns:
-        Adjusted datetime object
-    """
-    if timestamp_dt is None:
-        return None
-    
-    return timestamp_dt + timedelta(hours=hours_offset)
+logger.info(f"Using API endpoint: {API_BASE_URL}")
 
 def get_agent_type_by_name(type_name: str) -> Dict[str, Any]:
     """Get agent type by name"""
-    response = requests.get(f"{API_BASE_URL}/api/agent-types/name/{type_name}")
-    if response.status_code == 404:
-        logger.error(f"Agent type '{type_name}' not found")
+    url = f"{API_BASE_URL}/api/agent-types/name/{type_name}"
+    logger.debug(f"Calling API: {url}")
+    
+    try:
+        response = requests.get(url)
+        logger.debug(f"Response status: {response.status_code}")
+        
+        if response.status_code == 404:
+            logger.error(f"Agent type '{type_name}' not found")
+            return None
+            
+        response.raise_for_status()
+        result = response.json()
+        logger.debug(f"Agent type response: {result}")
+        return result
+    except Exception as e:
+        logger.error(f"Error in get_agent_type_by_name: {e}")
         return None
-    response.raise_for_status()
-    return response.json()
 
 def get_attribute_definition_by_name(attr_name: str) -> Dict[str, Any]:
     """Get attribute definition by name"""
-    response = requests.get(f"{API_BASE_URL}/api/attributes/name/{attr_name}")
-    if response.status_code == 404:
-        logger.error(f"Attribute definition '{attr_name}' not found")
+    url = f"{API_BASE_URL}/api/attributes/name/{attr_name}"
+    logger.debug(f"Calling API: {url}")
+    
+    try:
+        response = requests.get(url)
+        logger.debug(f"Response status: {response.status_code}")
+        
+        if response.status_code == 404:
+            logger.error(f"Attribute definition '{attr_name}' not found")
+            return None
+            
+        response.raise_for_status()
+        result = response.json()
+        logger.debug(f"Attribute definition response: {result}")
+        return result
+    except Exception as e:
+        logger.error(f"Error in get_attribute_definition_by_name: {e}")
         return None
-    response.raise_for_status()
-    return response.json()
 
 def get_agents_by_type(type_id: int) -> List[Dict[str, Any]]:
     """Get all agents of a specific type"""
-    response = requests.get(f"{API_BASE_URL}/api/agent-types/{type_id}/agents/")
-    if response.status_code == 404:
-        logger.error(f"No agents found for type ID {type_id}")
+    url = f"{API_BASE_URL}/api/agent-types/{type_id}/agents/"
+    logger.debug(f"Calling API: {url}")
+    
+    try:
+        response = requests.get(url)
+        logger.debug(f"Response status: {response.status_code}")
+        
+        if response.status_code == 404:
+            logger.error(f"No agents found for type ID {type_id}")
+            return []
+            
+        response.raise_for_status()
+        result = response.json()
+        logger.debug(f"Agents count: {len(result)}")
+        logger.debug(f"First few agents: {result[:2] if result else []}")
+        return result
+    except Exception as e:
+        logger.error(f"Error in get_agents_by_type: {e}")
         return []
-    response.raise_for_status()
-    return response.json()
 
 def get_attribute_values_by_type_and_attr(agents: List[Dict[str, Any]], attr_def_id: int) -> List[Dict[str, Any]]:
     """Get all attribute values for a specific attribute definition across all agents of a given list"""
     all_attributes = []
+    logger.debug(f"Getting attributes for {len(agents)} agents with attr_def_id: {attr_def_id}")
     
     # For each agent, get their attributes and filter for the one we want
     for agent in agents:
         agent_id = agent["agent_id"]
         
         # Call the /api/agents/{agent_id}/attributes/ endpoint
-        response = requests.get(f"{API_BASE_URL}/api/agents/{agent_id}/attributes/", params={"limit": 1000})
-        if response.status_code == 404:
-            logger.error(f"No attributes found for agent ID {agent_id}")
-            continue
+        url = f"{API_BASE_URL}/api/agents/{agent_id}/attributes/"
+        logger.debug(f"Calling API for agent {agent_id}: {url}")
         
         try:
+            response = requests.get(url, params={"limit": 1000})
+            
+            if response.status_code == 404:
+                logger.error(f"No attributes found for agent ID {agent_id}")
+                continue
+            
             response.raise_for_status()
             agent_attrs = response.json()
+            logger.debug(f"Agent {agent_id} has {len(agent_attrs)} attributes")
             
             # Filter for the specific attribute definition ID
             filtered_attrs = [attr for attr in agent_attrs if attr.get("attr_def_id") == attr_def_id]
+            logger.debug(f"Agent {agent_id} has {len(filtered_attrs)} APR attributes")
+            
+            if filtered_attrs:
+                logger.debug(f"Sample attribute for agent {agent_id}: {filtered_attrs[0]}")
+            
             all_attributes.extend(filtered_attrs)
         except requests.exceptions.RequestException as e:
             logger.error(f"Error fetching attributes for agent ID {agent_id}: {e}")
     
+    logger.info(f"Total APR attributes found across all agents: {len(all_attributes)}")
     return all_attributes
 
 def get_agent_name(agent_id: int, agents: List[Dict[str, Any]]) -> str:
@@ -109,14 +153,17 @@ def get_agent_name(agent_id: int, agents: List[Dict[str, Any]]) -> str:
 def extract_apr_value(attr: Dict[str, Any]) -> Dict[str, Any]:
     """Extract APR value and timestamp from JSON value"""
     try:
+        agent_id = attr.get("agent_id", "unknown")
+        logger.debug(f"Extracting APR value for agent {agent_id}")
+        
         # The APR value is stored in the json_value field
         if attr["json_value"] is None:
-            logger.warning(f"Null JSON value for agent_id: {attr.get('agent_id')}")
-            return {"apr": None, "timestamp": None, "agent_id": attr["agent_id"], "is_dummy": False}
+            logger.debug(f"Agent {agent_id}: json_value is None")
+            return {"apr": None, "timestamp": None, "agent_id": agent_id, "is_dummy": False}
         
         # If json_value is a string, parse it
         if isinstance(attr["json_value"], str):
-            logger.info(f"Parsing JSON string for agent_id: {attr.get('agent_id')}")
+            logger.debug(f"Agent {agent_id}: json_value is string, parsing")
             json_data = json.loads(attr["json_value"])
         else:
             json_data = attr["json_value"]
@@ -124,29 +171,20 @@ def extract_apr_value(attr: Dict[str, Any]) -> Dict[str, Any]:
         apr = json_data.get("apr")
         timestamp = json_data.get("timestamp")
         
-        logger.info(f"Raw timestamp from API: {timestamp}, type: {type(timestamp)}")
+        logger.debug(f"Agent {agent_id}: Raw APR value: {apr}, timestamp: {timestamp}")
         
         # Convert timestamp to datetime if it exists
         timestamp_dt = None
         if timestamp:
-            # Just use the standard conversion without timezone specification
             timestamp_dt = datetime.fromtimestamp(timestamp)
-            logger.info(f"Converted timestamp: {timestamp_dt}")
             
-            # Log timezone information
-            try:
-                local_now = datetime.now()
-                logger.info(f"Current local time: {local_now}")
-                logger.info(f"Difference between API time and local time (hours): {(timestamp_dt - local_now).total_seconds() / 3600:.2f}")
-            except Exception as e:
-                logger.error(f"Error calculating time difference: {e}")
-        else:
-            logger.warning(f"No timestamp in data for agent_id: {attr.get('agent_id')}")
-            
-        return {"apr": apr, "timestamp": timestamp_dt, "agent_id": attr["agent_id"], "is_dummy": False}
+        result = {"apr": apr, "timestamp": timestamp_dt, "agent_id": agent_id, "is_dummy": False}
+        logger.debug(f"Agent {agent_id}: Extracted result: {result}")
+        return result
     except (json.JSONDecodeError, KeyError, TypeError) as e:
         logger.error(f"Error parsing JSON value: {e} for agent_id: {attr.get('agent_id')}")
-        return {"apr": None, "timestamp": None, "agent_id": attr["agent_id"], "is_dummy": False}
+        logger.error(f"Problematic json_value: {attr.get('json_value')}")
+        return {"apr": None, "timestamp": None, "agent_id": attr.get('agent_id'), "is_dummy": False}
 
 def fetch_apr_data_from_db():
     """
@@ -154,13 +192,11 @@ def fetch_apr_data_from_db():
     """
     global global_df
     
-    # Set the timezone offset between local and HF environments
-    # Based on the logs, we're seeing ~6 hour difference
-    # If HF is showing earlier times than local, use a negative value
-    TIMEZONE_OFFSET_HOURS = -3  # Adjust based on observed differences
+    logger.info("==== Starting APR data fetch ====")
     
     try:
         # Step 1: Find the Modius agent type
+        logger.info("Finding Modius agent type")
         modius_type = get_agent_type_by_name("Modius")
         if not modius_type:
             logger.error("Modius agent type not found, using placeholder data")
@@ -168,8 +204,10 @@ def fetch_apr_data_from_db():
             return global_df
         
         type_id = modius_type["type_id"]
+        logger.info(f"Found Modius agent type with ID: {type_id}")
         
         # Step 2: Find the APR attribute definition
+        logger.info("Finding APR attribute definition")
         apr_attr_def = get_attribute_definition_by_name("APR")
         if not apr_attr_def:
             logger.error("APR attribute definition not found, using placeholder data")
@@ -177,30 +215,35 @@ def fetch_apr_data_from_db():
             return global_df
             
         attr_def_id = apr_attr_def["attr_def_id"]
+        logger.info(f"Found APR attribute definition with ID: {attr_def_id}")
         
         # Step 3: Get all agents of type Modius
+        logger.info(f"Getting all agents of type Modius (type_id: {type_id})")
         modius_agents = get_agents_by_type(type_id)
         if not modius_agents:
             logger.error("No agents of type 'Modius' found")
             global_df = pd.DataFrame([])
             return global_df
         
+        logger.info(f"Found {len(modius_agents)} Modius agents")
+        logger.debug(f"Modius agents: {[{'agent_id': a['agent_id'], 'agent_name': a['agent_name']} for a in modius_agents]}")
+        
         # Step 4: Fetch all APR values for Modius agents
+        logger.info(f"Fetching APR values for all Modius agents (attr_def_id: {attr_def_id})")
         apr_attributes = get_attribute_values_by_type_and_attr(modius_agents, attr_def_id)
         if not apr_attributes:
             logger.error("No APR values found for 'Modius' agents")
             global_df = pd.DataFrame([])
             return global_df
         
+        logger.info(f"Found {len(apr_attributes)} APR attributes total")
+        
         # Step 5: Extract APR data
+        logger.info("Extracting APR data from attributes")
         apr_data_list = []
         for attr in apr_attributes:
             apr_data = extract_apr_value(attr)
             if apr_data["apr"] is not None and apr_data["timestamp"] is not None:
-                # Apply timezone adjustment
-                apr_data["timestamp"] = adjust_timestamp(apr_data["timestamp"], TIMEZONE_OFFSET_HOURS)
-                logger.info(f"Adjusted timestamp: {apr_data['timestamp']}")
-                
                 # Get agent name
                 agent_name = get_agent_name(attr["agent_id"], modius_agents)
                 # Add agent name to the data
@@ -211,8 +254,10 @@ def fetch_apr_data_from_db():
                 # Mark negative values as "Performance" metrics
                 if apr_data["apr"] < 0:
                     apr_data["metric_type"] = "Performance"
+                    logger.debug(f"Agent {agent_name} ({attr['agent_id']}): Performance value: {apr_data['apr']}")
                 else:
                     apr_data["metric_type"] = "APR"
+                    logger.debug(f"Agent {agent_name} ({attr['agent_id']}): APR value: {apr_data['apr']}")
                     
                 apr_data_list.append(apr_data)
         
@@ -224,10 +269,17 @@ def fetch_apr_data_from_db():
         
         global_df = pd.DataFrame(apr_data_list)
         
-        # Log timestamp ranges for debugging
-        if not global_df.empty:
-            logger.info(f"DataFrame timestamp min: {global_df['timestamp'].min()}")
-            logger.info(f"DataFrame timestamp max: {global_df['timestamp'].max()}")
+        # Log the resulting dataframe
+        logger.info(f"Created DataFrame with {len(global_df)} rows")
+        logger.info(f"DataFrame columns: {global_df.columns.tolist()}")
+        logger.info(f"APR statistics: min={global_df['apr'].min()}, max={global_df['apr'].max()}, mean={global_df['apr'].mean()}")
+        logger.info(f"Metric types count: {global_df['metric_type'].value_counts().to_dict()}")
+        logger.info(f"Agents count: {global_df['agent_name'].value_counts().to_dict()}")
+        
+        # Log the entire dataframe for debugging
+        logger.debug("Final DataFrame contents:")
+        for idx, row in global_df.iterrows():
+            logger.debug(f"Row {idx}: {row.to_dict()}")
         
         return global_df
         
@@ -237,6 +289,7 @@ def fetch_apr_data_from_db():
         return global_df
     except Exception as e:
         logger.error(f"Error fetching APR data: {e}")
+        logger.exception("Exception details:")
         global_df = pd.DataFrame([])
         return global_df
 
@@ -428,34 +481,50 @@ def create_combined_time_series_graph(df):
         )
         return fig
     
-    # Debug: Print detailed info about the dataframe
-    logger.info(f"Combined graph data - shape: {df.shape}")
-    logger.info(f"Timestamp min: {df['timestamp'].min()}, timezone info: {getattr(df['timestamp'].min(), 'tzinfo', None)}")
-    logger.info(f"Timestamp max: {df['timestamp'].max()}, timezone info: {getattr(df['timestamp'].max(), 'tzinfo', None)}")
-    logger.info("Platform/Environment info:")
-    logger.info(f"Host: {os.uname().nodename if hasattr(os, 'uname') else 'Unknown'}")
-    logger.info(f"System: {os.name}")
-    
-    # Create a timestamp reference to identify the environment
-    current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-    logger.info(f"Environment check - current time: {current_time}")
+    # ADDED: Export full dataframe to CSV for debugging
+    debug_csv = "debug_graph_data.csv"
+    df.to_csv(debug_csv)
+    logger.info(f"Exported graph data to {debug_csv} for debugging")
     
-    # Add a title annotation with environment information to help identify which environment is which
-    environment_tag = "LOCAL" if os.environ.get("GRADIO_SERVER_PORT") is None else "HUGGINGFACE"
-    logger.info(f"Environment tag: {environment_tag}")
+    # ADDED: Write detailed data report
+    with open("debug_graph_data_report.txt", "w") as f:
+        f.write("==== GRAPH DATA REPORT ====\n\n")
+        f.write(f"Total data points: {len(df)}\n")
+        f.write(f"Timestamp range: {df['timestamp'].min()} to {df['timestamp'].max()}\n\n")
+        
+        # Output per-agent details
+        unique_agents = df['agent_id'].unique()
+        f.write(f"Number of agents: {len(unique_agents)}\n\n")
+        
+        for agent_id in unique_agents:
+            agent_data = df[df['agent_id'] == agent_id]
+            agent_name = agent_data['agent_name'].iloc[0]
+            
+            f.write(f"== Agent: {agent_name} (ID: {agent_id}) ==\n")
+            f.write(f"  Total data points: {len(agent_data)}\n")
+            
+            apr_data = agent_data[agent_data['metric_type'] == 'APR']
+            perf_data = agent_data[agent_data['metric_type'] == 'Performance']
+            
+            f.write(f"  APR data points: {len(apr_data)}\n")
+            f.write(f"  Performance data points: {len(perf_data)}\n")
+            
+            if not apr_data.empty:
+                f.write(f"  APR values: {apr_data['apr'].tolist()}\n")
+                f.write(f"  APR timestamps: {[ts.strftime('%Y-%m-%d %H:%M:%S') if ts is not None else 'None' for ts in apr_data['timestamp']]}\n")
+            
+            if not perf_data.empty:
+                f.write(f"  Performance values: {perf_data['apr'].tolist()}\n")
+                f.write(f"  Performance timestamps: {[ts.strftime('%Y-%m-%d %H:%M:%S') if ts is not None else 'None' for ts in perf_data['timestamp']]}\n")
+            
+            f.write("\n")
     
-    # Debug: Print every data point with full details to verify consistency
-    for idx, row in df.iterrows():
-        logger.info(f"Data point {idx}: agent={row['agent_name']}, time={row['timestamp']}, apr={row['apr']}, type={row['metric_type']}")
+    logger.info("Generated detailed graph data report")
     
     # Create Plotly figure
     fig = go.Figure()
     
     # Get unique agents
-    unique_agents = df['agent_id'].unique()
-    logger.info(f"Unique agents: {[df[df['agent_id'] == agent_id]['agent_name'].iloc[0] for agent_id in unique_agents]}")
-    
-    # Define a color scale for different agents
     colors = px.colors.qualitative.Plotly[:len(unique_agents)]
     
     # Add background shapes for APR and Performance regions
@@ -498,9 +567,7 @@ def create_combined_time_series_graph(df):
         
         # Sort the data by timestamp
         agent_data = agent_data.sort_values('timestamp')
-        logger.info(f"Agent {agent_name} data points: {len(agent_data)}")
-        logger.info(f"Agent {agent_name} timestamps: {agent_data['timestamp'].tolist()}")
-        
+        print("agent_data_combined",agent_data)
         # Add the combined line for both APR and Performance
         fig.add_trace(
             go.Scatter(
@@ -516,7 +583,7 @@ def create_combined_time_series_graph(df):
         
         # Add scatter points for APR values
         apr_data = agent_data[agent_data['metric_type'] == 'APR']
-        logger.info(f"Agent {agent_name} APR points: {len(apr_data)}")
+        print("apr_data_combined",apr_data)
         if not apr_data.empty:
             fig.add_trace(
                 go.Scatter(
@@ -533,7 +600,7 @@ def create_combined_time_series_graph(df):
         
         # Add scatter points for Performance values
         perf_data = agent_data[agent_data['metric_type'] == 'Performance']
-        logger.info(f"Agent {agent_name} Performance points: {len(perf_data)}")
+        print("perf_data_combined",perf_data)
         if not perf_data.empty:
             fig.add_trace(
                 go.Scatter(
@@ -550,7 +617,7 @@ def create_combined_time_series_graph(df):
     
     # Update layout
     fig.update_layout(
-        title=f"APR and Performance Values for All Agents - {environment_tag} - {current_time}",
+        title="APR and Performance Values for All Agents",
         xaxis_title="Time",
         yaxis_title="Value",
         template="plotly_white",
@@ -564,17 +631,8 @@ def create_combined_time_series_graph(df):
             x=1,
             groupclick="toggleitem"
         ),
-        margin=dict(r=20, l=20, t=50, b=20),  # Increased top margin for title
-        hovermode="closest",
-        annotations=[
-            dict(
-                text=f"Environment: {environment_tag} | Server Time: {current_time}",
-                xref="paper", yref="paper",
-                x=0.5, y=1.05,  # Positioned above the main title
-                showarrow=False,
-                font=dict(size=10, color="gray")
-            )
-        ]
+        margin=dict(r=20, l=20, t=30, b=20),
+        hovermode="closest"
     )
     
     # Update axes
@@ -1004,7 +1062,78 @@ def create_visualizations():
     
     return fig_swaps_chain, fig_bridges_chain, fig_agents_registered, fig_tvl
 
-# Gradio interface
+# Add new function to the bottom of the file, before the dashboard() function
+def add_diagnostic_controls(demo):
+    """Add diagnostic UI controls to help debug the difference between local and production"""
+    with gr.Column():
+        gr.Markdown("## Diagnostics")
+        
+        diagnostic_button = gr.Button("Run Data Diagnostics")
+        diagnostic_output = gr.Textbox(label="Diagnostic Results", lines=10)
+        
+        def run_diagnostics():
+            """Function to diagnose data issues"""
+            global global_df
+            
+            if global_df is None or global_df.empty:
+                return "No data available. Please click 'Refresh APR Data' first."
+            
+            # Gather diagnostics
+            result = []
+            result.append(f"=== DIAGNOSTIC REPORT ===")
+            result.append(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+            result.append(f"API Endpoint: {API_BASE_URL}")
+            result.append(f"Total data points: {len(global_df)}")
+            
+            unique_agents = global_df['agent_id'].unique()
+            result.append(f"Number of unique agents: {len(unique_agents)}")
+            
+            # Per-agent diagnostics
+            for agent_id in unique_agents:
+                agent_data = global_df[global_df['agent_id'] == agent_id]
+                agent_name = agent_data['agent_name'].iloc[0]
+                
+                result.append(f"\nAgent: {agent_name} (ID: {agent_id})")
+                result.append(f"  Data points: {len(agent_data)}")
+                
+                # Check APR values
+                apr_data = agent_data[agent_data['metric_type'] == 'APR']
+                perf_data = agent_data[agent_data['metric_type'] == 'Performance']
+                
+                result.append(f"  APR points: {len(apr_data)}")
+                if not apr_data.empty:
+                    result.append(f"  APR values: {apr_data['apr'].tolist()}")
+                
+                result.append(f"  Performance points: {len(perf_data)}")
+                if not perf_data.empty:
+                    result.append(f"  Performance values: {perf_data['apr'].tolist()}")
+            
+            # Write to file as well
+            with open("latest_diagnostics.txt", "w") as f:
+                f.write("\n".join(result))
+            
+            return "\n".join(result)
+        
+        # Fix for Gradio interface - use event listeners properly
+        try:
+            # Different Gradio versions have different APIs
+            # Try the newer approach first
+            diagnostic_button.click(
+                fn=run_diagnostics,
+                inputs=None,
+                outputs=diagnostic_output
+            )
+        except TypeError:
+            # Fall back to original approach
+            diagnostic_button.click(
+                fn=run_diagnostics,
+                inputs=[],
+                outputs=[diagnostic_output]
+            )
+    
+    return demo
+
+# Modify dashboard function to include diagnostics
 def dashboard():
     with gr.Blocks() as demo:
         gr.Markdown("# Valory APR Metrics")
@@ -1020,15 +1149,36 @@ def dashboard():
                 # Function to update the graph
                 def update_apr_graph():
                     # Generate visualization and get figure object directly
-                    combined_fig, _ = generate_apr_visualizations()
-                    return combined_fig
+                    try:
+                        combined_fig, _ = generate_apr_visualizations()
+                        return combined_fig
+                    except Exception as e:
+                        logger.exception("Error generating APR visualization")
+                        # Create error figure
+                        error_fig = go.Figure()
+                        error_fig.add_annotation(
+                            text=f"Error: {str(e)}", 
+                            x=0.5, y=0.5, 
+                            showarrow=False, 
+                            font=dict(size=15, color="red")
+                        )
+                        return error_fig
                 
-                # Set up the button click event
-                refresh_btn.click(
-                    fn=update_apr_graph,
-                    inputs=[],
-                    outputs=[combined_graph]
-                )
+                # Set up the button click event with error handling
+                try:
+                    # Try newer Gradio API first
+                    refresh_btn.click(
+                        fn=update_apr_graph,
+                        inputs=None,
+                        outputs=combined_graph
+                    )
+                except TypeError:
+                    # Fall back to original method
+                    refresh_btn.click(
+                        fn=update_apr_graph,
+                        inputs=[],
+                        outputs=[combined_graph]
+                    )
                 
                 # Initialize the graph on load
                 # We'll use placeholder figure initially
@@ -1041,6 +1191,9 @@ def dashboard():
                     font=dict(size=15)
                 )
                 combined_graph.value = placeholder_fig
+                
+                # Add diagnostics section
+                demo = add_diagnostic_controls(demo)
         
     return demo