feat: add roi graph

app.py

@@ -14,7 +14,7 @@ import matplotlib.pyplot as plt
 import matplotlib.dates as mdates
 import random
 import logging
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 # Comment out the import for now and replace with dummy functions
 # from app_trans_new import create_transcation_visualizations,create_active_agents_visualizations
 # APR visualization functions integrated directly
@@ -39,8 +39,9 @@ logging.getLogger("matplotlib").setLevel(logging.WARNING)
 logger.info("============= APPLICATION STARTING =============")
 logger.info(f"Running from directory: {os.getcwd()}")
 
-# Global variable to store the data for reuse
+# Global variables to store the data for reuse
 global_df = None
+global_roi_df = None
 
 # Configuration
 API_BASE_URL = "https://afmdb.autonolas.tech"
@@ -156,7 +157,7 @@ def get_agent_name(agent_id: int, agents: List[Dict[str, Any]]) -> str:
     return "Unknown"
 
 def extract_apr_value(attr: Dict[str, Any]) -> Dict[str, Any]:
-    """Extract APR value, adjusted APR value, and timestamp from JSON value"""
+    """Extract APR value, adjusted APR value, ROI value, and timestamp from JSON value"""
     try:
         agent_id = attr.get("agent_id", "unknown")
         logger.debug(f"Extracting APR value for agent {agent_id}")
@@ -164,7 +165,7 @@ def extract_apr_value(attr: Dict[str, Any]) -> Dict[str, Any]:
         # The APR value is stored in the json_value field
         if attr["json_value"] is None:
             logger.debug(f"Agent {agent_id}: json_value is None")
-            return {"apr": None, "adjusted_apr": None, "timestamp": None, "agent_id": agent_id, "is_dummy": False}
+            return {"apr": None, "adjusted_apr": None, "roi": None, "timestamp": None, "agent_id": agent_id, "is_dummy": False}
         
         # If json_value is a string, parse it
         if isinstance(attr["json_value"], str):
@@ -177,26 +178,39 @@ def extract_apr_value(attr: Dict[str, Any]) -> Dict[str, Any]:
         adjusted_apr = json_data.get("adjusted_apr")  # Extract adjusted_apr if present
         timestamp = json_data.get("timestamp")
         
-        logger.debug(f"Agent {agent_id}: Raw APR value: {apr}, adjusted APR value: {adjusted_apr}, timestamp: {timestamp}")
+        # Extract ROI (f_i_ratio) from calculation_metrics if it exists
+        roi = None
+        if "calculation_metrics" in json_data and json_data["calculation_metrics"] is not None:
+            roi = json_data["calculation_metrics"].get("f_i_ratio")
+        
+        logger.debug(f"Agent {agent_id}: Raw APR value: {apr}, adjusted APR value: {adjusted_apr}, ROI value: {roi}, timestamp: {timestamp}")
         
         # Convert timestamp to datetime if it exists
         timestamp_dt = None
         if timestamp:
             timestamp_dt = datetime.fromtimestamp(timestamp)
             
-        result = {"apr": apr, "adjusted_apr": adjusted_apr, "timestamp": timestamp_dt, "agent_id": agent_id, "is_dummy": False}
+        result = {
+            "apr": apr, 
+            "adjusted_apr": adjusted_apr, 
+            "roi": roi,
+            "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')}")
         logger.error(f"Problematic json_value: {attr.get('json_value')}")
-        return {"apr": None, "adjusted_apr": None, "timestamp": None, "agent_id": attr.get('agent_id'), "is_dummy": False}
+        return {"apr": None, "adjusted_apr": None, "roi": None, "timestamp": None, "agent_id": attr.get('agent_id'), "is_dummy": False}
 
 def fetch_apr_data_from_db():
     """
     Fetch APR data from database using the API.
     """
     global global_df
+    global global_roi_df
     
     logger.info("==== Starting APR data fetch ====")
     
@@ -244,30 +258,54 @@ def fetch_apr_data_from_db():
         
         logger.info(f"Found {len(apr_attributes)} APR attributes total")
         
-        # Step 5: Extract APR data
-        logger.info("Extracting APR data from attributes")
+        # Step 5: Extract APR and ROI data
+        logger.info("Extracting APR and ROI data from attributes")
         apr_data_list = []
+        roi_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:
+            data = extract_apr_value(attr)
+            if data["timestamp"] is not None:
                 # Get agent name
                 agent_name = get_agent_name(attr["agent_id"], modius_agents)
                 # Add agent name to the data
-                apr_data["agent_name"] = agent_name
+                data["agent_name"] = agent_name
                 # Add is_dummy flag (all real data)
-                apr_data["is_dummy"] = False
+                data["is_dummy"] = False
                 
-                # Include all APR values (including negative ones) EXCEPT zero and -100
-                if apr_data["apr"] != 0 and apr_data["apr"] != -100:
-                    apr_data["metric_type"] = "APR"
-                    logger.debug(f"Agent {agent_name} ({attr['agent_id']}): APR value: {apr_data['apr']}")
-                    # Add to the data list
-                    apr_data_list.append(apr_data)
-                else:
-                    # Log that we're skipping zero or -100 values
-                    logger.debug(f"Skipping value for agent {agent_name} ({attr['agent_id']}): {apr_data['apr']} (zero or -100)")
-        
-        logger.info(f"Extracted {len(apr_data_list)} valid APR data points")
+                # Process APR data
+                if data["apr"] is not None:
+                    # Include all APR values (including negative ones) EXCEPT zero and -100
+                    if data["apr"] != 0 and data["apr"] != -100:
+                        apr_entry = data.copy()
+                        apr_entry["metric_type"] = "APR"
+                        logger.debug(f"Agent {agent_name} ({attr['agent_id']}): APR value: {data['apr']}")
+                        # Add to the APR data list
+                        apr_data_list.append(apr_entry)
+                    else:
+                        # Log that we're skipping zero or -100 values
+                        logger.debug(f"Skipping APR value for agent {agent_name} ({attr['agent_id']}): {data['apr']} (zero or -100)")
+                
+                # Process ROI data
+                if data["roi"] is not None:
+                    # Include all ROI values except extreme outliers
+                    if data["roi"] > -10 and data["roi"] < 10:  # Filter extreme outliers
+                        roi_entry = {
+                            "roi": data["roi"],
+                            "timestamp": data["timestamp"],
+                            "agent_id": data["agent_id"],
+                            "agent_name": agent_name,
+                            "is_dummy": False,
+                            "metric_type": "ROI"
+                        }
+                        logger.debug(f"Agent {agent_name} ({attr['agent_id']}): ROI value: {data['roi']}")
+                        # Add to the ROI data list
+                        roi_data_list.append(roi_entry)
+                    else:
+                        # Log that we're skipping extreme outlier values
+                        logger.debug(f"Skipping ROI value for agent {agent_name} ({attr['agent_id']}): {data['roi']} (extreme outlier)")
+        
+        logger.info(f"Extracted {len(apr_data_list)} valid APR data points and {len(roi_data_list)} valid ROI data points")
         
         # Added debug for adjusted APR data after May 10th
         may_10_2025 = datetime(2025, 5, 10)
@@ -412,14 +450,20 @@ def fetch_apr_data_from_db():
             if keys_used:
                 logger.info(f"Keys used for adjusted_apr after May 10th: {keys_used}")
         
-        # Convert to DataFrame
+        # Convert to DataFrames
         if not apr_data_list:
             logger.error("No valid APR data extracted")
             global_df = pd.DataFrame([])
-            return global_df
-        
-        # Convert list of dictionaries to DataFrame
-        global_df = pd.DataFrame(apr_data_list)
+        else:
+            # Convert list of dictionaries to DataFrame for APR
+            global_df = pd.DataFrame(apr_data_list)
+            
+        if not roi_data_list:
+            logger.error("No valid ROI data extracted")
+            global_roi_df = pd.DataFrame([])
+        else:
+            # Convert list of dictionaries to DataFrame for ROI
+            global_roi_df = pd.DataFrame(roi_data_list)
         
         # Log the resulting dataframe
         logger.info(f"Created DataFrame with {len(global_df)} rows")
@@ -448,21 +492,23 @@ def fetch_apr_data_from_db():
         for idx, row in global_df.iterrows():
             logger.debug(f"Row {idx}: {row.to_dict()}")
         
-        # Add this at the end, right before returning the global_df
+        # Add this at the end, right before returning
         logger.info("Analyzing adjusted_apr data availability...")
         log_adjusted_apr_availability(global_df)
         
-        return global_df
+        return global_df, global_roi_df
         
     except requests.exceptions.RequestException as e:
         logger.error(f"API request error: {e}")
         global_df = pd.DataFrame([])
-        return global_df
+        global_roi_df = pd.DataFrame([])
+        return global_df, global_roi_df
     except Exception as e:
         logger.error(f"Error fetching APR data: {e}")
         logger.exception("Exception traceback:")
         global_df = pd.DataFrame([])
-        return global_df
+        global_roi_df = pd.DataFrame([])
+        return global_df, global_roi_df
 
 def log_adjusted_apr_availability(df):
     """
@@ -605,7 +651,7 @@ def generate_apr_visualizations():
     global global_df
     
     # Fetch data from database
-    df = fetch_apr_data_from_db()
+    df, _ = fetch_apr_data_from_db()
     
     # If we got no data at all, return placeholder figures
     if df.empty:
@@ -642,6 +688,464 @@ def generate_apr_visualizations():
     
     return combined_fig, csv_file
 
+def generate_roi_visualizations():
+    """Generate ROI visualizations with real data only (no dummy data)"""
+    global global_roi_df
+    
+    # Fetch data from database if not already fetched
+    if global_roi_df is None or global_roi_df.empty:
+        _, df_roi = fetch_apr_data_from_db()
+    else:
+        df_roi = global_roi_df
+    
+    # If we got no data at all, return placeholder figures
+    if df_roi.empty:
+        logger.info("No ROI data available. Using fallback visualization.")
+        # Create empty visualizations with a message using Plotly
+        fig = go.Figure()
+        fig.add_annotation(
+            x=0.5, y=0.5,
+            text="No ROI data available",
+            font=dict(size=20),
+            showarrow=False
+        )
+        fig.update_layout(
+            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
+        )
+        
+        # Save as static file for reference
+        fig.write_html("modius_roi_graph.html")
+        fig.write_image("modius_roi_graph.png")
+        
+        csv_file = None
+        return fig, csv_file
+    
+    # Set global_roi_df for access by other functions
+    global_roi_df = df_roi
+    
+    # Save to CSV before creating visualizations
+    csv_file = save_roi_to_csv(df_roi)
+    
+    # Create combined time series graph for ROI
+    combined_fig = create_combined_roi_time_series_graph(df_roi)
+    
+    return combined_fig, csv_file
+
+def create_combined_roi_time_series_graph(df):
+    """Create a time series graph showing average ROI values across all agents"""
+    if len(df) == 0:
+        logger.error("No data to plot combined ROI graph")
+        fig = go.Figure()
+        fig.add_annotation(
+            text="No ROI data available",
+            x=0.5, y=0.5,
+            showarrow=False, font=dict(size=20)
+        )
+        return fig
+    
+    # IMPORTANT: Force data types to ensure consistency
+    df['roi'] = df['roi'].astype(float)  # Ensure ROI is float
+    df['metric_type'] = df['metric_type'].astype(str)  # Ensure metric_type is string
+    
+    # Get min and max time for shapes
+    min_time = df['timestamp'].min()
+    max_time = df['timestamp'].max()
+    
+    # Use the actual start date from the data instead of a fixed date
+    x_start_date = min_time
+    
+    # CRITICAL: Log the exact dataframe we're using for plotting to help debug
+    logger.info(f"ROI Graph data - shape: {df.shape}, columns: {df.columns}")
+    logger.info(f"ROI Graph data - unique agents: {df['agent_name'].unique().tolist()}")
+    logger.info(f"ROI Graph data - min ROI: {df['roi'].min()}, max ROI: {df['roi'].max()}")
+    
+    # Export full dataframe to CSV for debugging
+    debug_csv = "debug_roi_data.csv"
+    df.to_csv(debug_csv)
+    logger.info(f"Exported ROI graph data to {debug_csv} for debugging")
+    
+    # Create Plotly figure in a clean state
+    fig = go.Figure()
+    
+    # Get min and max time for shapes
+    min_time = df['timestamp'].min()
+    max_time = df['timestamp'].max()
+    
+    # Add background shapes for positive and negative regions
+    # Add shape for positive ROI region (above zero)
+    fig.add_shape(
+        type="rect",
+        fillcolor="rgba(230, 243, 255, 0.3)",
+        line=dict(width=0),
+        y0=0, y1=1,  # Use a fixed positive value
+        x0=min_time, x1=max_time,
+        layer="below"
+    )
+    
+    # Add shape for negative ROI region (below zero)
+    fig.add_shape(
+        type="rect",
+        fillcolor="rgba(255, 230, 230, 0.3)",
+        line=dict(width=0),
+        y0=-1, y1=0,  # Use a fixed negative value
+        x0=min_time, x1=max_time,
+        layer="below"
+    )
+    
+    # Add zero line
+    fig.add_shape(
+        type="line",
+        line=dict(dash="solid", width=1.5, color="black"),
+        y0=0, y1=0,
+        x0=min_time, x1=max_time
+    )
+    
+    # Filter out outliers (ROI values above 2 or below -2)
+    outlier_data = df[(df['roi'] > 2) | (df['roi'] < -2)].copy()
+    df_filtered = df[(df['roi'] <= 2) & (df['roi'] >= -2)].copy()
+    
+    # Log the outliers for better debugging
+    if len(outlier_data) > 0:
+        excluded_count = len(outlier_data)
+        logger.info(f"Excluded {excluded_count} data points with outlier ROI values (>2 or <-2)")
+        
+        # Group outliers by agent for detailed logging
+        outlier_agents = outlier_data.groupby('agent_name')
+        for agent_name, agent_outliers in outlier_agents:
+            logger.info(f"Agent '{agent_name}' has {len(agent_outliers)} outlier values:")
+            for idx, row in agent_outliers.iterrows():
+                logger.info(f"  - ROI: {row['roi']}, timestamp: {row['timestamp']}")
+    
+    # Use the filtered data for all subsequent operations
+    df = df_filtered
+    
+    # Group by timestamp and calculate mean ROI
+    avg_roi_data = df.groupby('timestamp')['roi'].mean().reset_index()
+    
+    # Sort by timestamp
+    avg_roi_data = avg_roi_data.sort_values('timestamp')
+    
+    # Log the average ROI data
+    logger.info(f"Calculated average ROI data with {len(avg_roi_data)} points")
+    for idx, row in avg_roi_data.iterrows():
+        logger.info(f"  Average point {idx}: timestamp={row['timestamp']}, avg_roi={row['roi']}")
+    
+    # Calculate moving average based on a time window (3 days)
+    # Sort data by timestamp
+    df_sorted = df.sort_values('timestamp')
+    
+    # Create a new dataframe for the moving average
+    avg_roi_data_with_ma = avg_roi_data.copy()
+    avg_roi_data_with_ma['moving_avg'] = None  # Initialize the moving average column
+    
+    # Define the time window for the moving average (3 days)
+    time_window = pd.Timedelta(days=3)
+    logger.info(f"Calculating moving average with time window of {time_window}")
+    
+    # Calculate the moving averages for each timestamp
+    for i, row in avg_roi_data_with_ma.iterrows():
+        current_time = row['timestamp']
+        window_start = current_time - time_window
+        
+        # Get all data points within the 3-day time window
+        window_data = df_sorted[
+            (df_sorted['timestamp'] >= window_start) & 
+            (df_sorted['timestamp'] <= current_time)
+        ]
+        
+        # Calculate the average ROI for the 3-day time window
+        if not window_data.empty:
+            avg_roi_data_with_ma.at[i, 'moving_avg'] = window_data['roi'].mean()
+            logger.debug(f"ROI time window {window_start} to {current_time}: {len(window_data)} points, avg={window_data['roi'].mean()}")
+        else:
+            # If no data points in the window, use the current value
+            avg_roi_data_with_ma.at[i, 'moving_avg'] = row['roi']
+            logger.debug(f"No data points in time window for {current_time}, using current value {row['roi']}")
+    
+    logger.info(f"Calculated time-based moving averages with {len(avg_roi_data_with_ma)} points")
+    
+    # Plot individual agent data points with agent names in hover, but limit display for scalability
+    if not df.empty:
+        # Group by agent to use different colors for each agent
+        unique_agents = df['agent_name'].unique()
+        colors = px.colors.qualitative.Plotly[:len(unique_agents)]
+        
+        # Create a color map for agents
+        color_map = {agent: colors[i % len(colors)] for i, agent in enumerate(unique_agents)}
+        
+        # Calculate the total number of data points per agent to determine which are most active
+        agent_counts = df['agent_name'].value_counts()
+        
+        # Determine how many agents to show individually (limit to top 5 most active)
+        MAX_VISIBLE_AGENTS = 5
+        top_agents = agent_counts.nlargest(min(MAX_VISIBLE_AGENTS, len(agent_counts))).index.tolist()
+        
+        logger.info(f"Showing {len(top_agents)} agents by default out of {len(unique_agents)} total agents")
+        
+        # Add data points for each agent, but only make top agents visible by default
+        for agent_name in unique_agents:
+            agent_data = df[df['agent_name'] == agent_name]
+            
+            # Explicitly convert to Python lists
+            x_values = agent_data['timestamp'].tolist()
+            y_values = agent_data['roi'].tolist()
+            
+            # Change default visibility to False to hide all agent data points
+            is_visible = False
+            
+            # Add data points as markers for ROI
+            fig.add_trace(
+                go.Scatter(
+                    x=x_values,
+                    y=y_values,
+                    mode='markers',  # Only markers for original data
+                    marker=dict(
+                        color=color_map[agent_name],
+                        symbol='circle',
+                        size=10,
+                        line=dict(width=1, color='black')
+                    ),
+                    name=f'Agent: {agent_name} (ROI)',
+                    hovertemplate='Time: %{x}<br>ROI: %{y:.2f}<br>Agent: ' + agent_name + '<extra></extra>',
+                    visible=is_visible  # All agents hidden by default
+                )
+            )
+            logger.info(f"Added ROI data points for agent {agent_name} with {len(x_values)} points (visible: {is_visible})")
+        
+        # Add ROI moving average as a smooth line
+        x_values_ma = avg_roi_data_with_ma['timestamp'].tolist()
+        y_values_ma = avg_roi_data_with_ma['moving_avg'].tolist()
+        
+        # Create hover template for the ROI moving average line
+        hover_data_roi = []
+        for idx, row in avg_roi_data_with_ma.iterrows():
+            timestamp = row['timestamp']
+            hover_data_roi.append(
+                f"Time: {timestamp}<br>Avg ROI (3d window): {row['moving_avg']:.2f}"
+            )
+        
+        fig.add_trace(
+            go.Scatter(
+                x=x_values_ma,
+                y=y_values_ma,
+                mode='lines',  # Only lines for moving average
+                line=dict(color='blue', width=2),  # Thinner line
+                name='Average ROI (3d window)',
+                hovertext=hover_data_roi,
+                hoverinfo='text',
+                visible=True  # Visible by default
+            )
+        )
+        logger.info(f"Added 3-day moving average ROI trace with {len(x_values_ma)} points")
+    
+    # Update layout
+    fig.update_layout(
+        title=dict(
+            text="Modius Agents ROI",
+            font=dict(
+                family="Arial, sans-serif",
+                size=22,
+                color="black",
+                weight="bold"
+            )
+        ),
+        xaxis_title=None,  # Remove x-axis title to use annotation instead
+        yaxis_title=None,  # Remove the y-axis title as we'll use annotations instead
+        template="plotly_white",
+        height=600,  # Reduced height for better fit on smaller screens
+        autosize=True,  # Enable auto-sizing for responsiveness
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=1,
+            groupclick="toggleitem"
+        ),
+        margin=dict(r=30, l=120, t=40, b=50),  # Increased bottom margin for x-axis title
+        hovermode="closest"
+    )
+    
+    # Add annotations for y-axis regions
+    fig.add_annotation(
+        x=-0.08,  # Position further from the y-axis to avoid overlapping with tick labels
+        y=-0.5,    # Middle of the negative region
+        xref="paper",
+        yref="y",
+        text="Negative ROI [ratio]",
+        showarrow=False,
+        font=dict(size=16, family="Arial, sans-serif", color="black", weight="bold"),  # Adjusted font size
+        textangle=-90,  # Rotate text to be vertical
+        align="center"
+    )
+    
+    fig.add_annotation(
+        x=-0.08,  # Position further from the y-axis to avoid overlapping with tick labels
+        y=0.5,     # Middle of the positive region
+        xref="paper",
+        yref="y",
+        text="Positive ROI [ratio]",
+        showarrow=False,
+        font=dict(size=16, family="Arial, sans-serif", color="black", weight="bold"),  # Adjusted font size
+        textangle=-90,  # Rotate text to be vertical
+        align="center"
+    )
+    
+    # Update layout for legend
+    fig.update_layout(
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=1,
+            groupclick="toggleitem",
+            font=dict(
+                family="Arial, sans-serif",
+                size=14,  # Adjusted font size
+                color="black",
+                weight="bold"
+            )
+        )
+    )
+    
+    # Update y-axis with fixed range of -1 to +1 for ROI
+    fig.update_yaxes(
+        showgrid=True, 
+        gridwidth=1, 
+        gridcolor='rgba(0,0,0,0.1)',
+        # Use fixed range instead of autoscaling
+        autorange=False,  # Disable autoscaling
+        range=[-1, 1],  # Set fixed range from -1 to +1
+        tickformat=".2f",  # Format tick labels with 2 decimal places
+        tickfont=dict(size=14, family="Arial, sans-serif", color="black", weight="bold"),  # Adjusted font size
+        title=None  # Remove the built-in axis title since we're using annotations
+    )
+    
+    # Update x-axis with better formatting and fixed range
+    fig.update_xaxes(
+        showgrid=True, 
+        gridwidth=1, 
+        gridcolor='rgba(0,0,0,0.1)',
+        # Set fixed range with April 17 as start date
+        autorange=False,  # Disable autoscaling
+        range=[x_start_date, max_time],  # Set fixed range from April 17 to max date
+        tickformat="%b %d",  # Simplified date format without time
+        tickangle=-30,  # Angle the labels for better readability
+        tickfont=dict(size=14, family="Arial, sans-serif", color="black", weight="bold"),  # Adjusted font size
+        title=None  # Remove built-in title to use annotation instead
+    )
+    
+    try:
+        # Save the figure
+        graph_file = "modius_roi_graph.html"
+        fig.write_html(graph_file, include_plotlyjs='cdn', full_html=False)
+        
+        # Also save as image for compatibility
+        img_file = "modius_roi_graph.png"
+        try:
+            fig.write_image(img_file)
+            logger.info(f"ROI graph saved to {graph_file} and {img_file}")
+        except Exception as e:
+            logger.error(f"Error saving ROI image: {e}")
+            logger.info(f"ROI graph saved to {graph_file} only")
+        
+        # Return the figure object for direct use in Gradio
+        return fig
+    except Exception as e:
+        # If the complex graph approach fails, create a simpler one
+        logger.error(f"Error creating advanced ROI graph: {e}")
+        logger.info("Falling back to Simpler ROI graph")
+        
+        # Create a simpler graph as fallback
+        simple_fig = go.Figure()
+        
+        # Add zero line
+        simple_fig.add_shape(
+            type="line",
+            line=dict(dash="solid", width=1.5, color="black"),
+            y0=0, y1=0,
+            x0=min_time, x1=max_time
+        )
+        
+        # Simply plot the average ROI data with moving average
+        if not avg_roi_data.empty:
+            # Add moving average as a line
+            simple_fig.add_trace(
+                go.Scatter(
+                    x=avg_roi_data_with_ma['timestamp'],
+                    y=avg_roi_data_with_ma['moving_avg'],
+                    mode='lines',
+                    name='Average ROI (3d window)',
+                    line=dict(width=2, color='blue')  # Thinner line
+                )
+            )
+        
+        # Simplified layout with adjusted y-axis range
+        simple_fig.update_layout(
+            title=dict(
+                text="Modius Agents ROI",
+                font=dict(
+                    family="Arial, sans-serif",
+                    size=22,
+                    color="black",
+                    weight="bold"
+                )
+            ),
+            xaxis_title=None,
+            yaxis_title=None,
+            template="plotly_white",
+            height=600,
+            autosize=True,
+            margin=dict(r=30, l=120, t=40, b=50)
+        )
+        
+        # Update y-axis with fixed range of -1 to +1 for ROI
+        simple_fig.update_yaxes(
+            showgrid=True, 
+            gridwidth=1, 
+            gridcolor='rgba(0,0,0,0.1)',
+            autorange=False,
+            range=[-1, 1],
+            tickformat=".2f",
+            tickfont=dict(size=14, family="Arial, sans-serif", color="black", weight="bold")
+        )
+        
+        # Update x-axis with better formatting and fixed range
+        simple_fig.update_xaxes(
+            showgrid=True, 
+            gridwidth=1, 
+            gridcolor='rgba(0,0,0,0.1)',
+            autorange=False,
+            range=[x_start_date, max_time],
+            tickformat="%b %d",
+            tickangle=-30,
+            tickfont=dict(size=14, family="Arial, sans-serif", color="black", weight="bold")
+        )
+        
+        # Save the figure
+        graph_file = "modius_roi_graph.html"
+        simple_fig.write_html(graph_file, include_plotlyjs='cdn', full_html=False)
+        
+        # Return the simple figure
+        return simple_fig
+
+def save_roi_to_csv(df):
+    """Save the ROI data DataFrame to a CSV file and return the file path"""
+    if df.empty:
+        logger.error("No ROI data to save to CSV")
+        return None
+    
+    # Define the CSV file path
+    csv_file = "modius_roi_values.csv"
+    
+    # Save to CSV
+    df.to_csv(csv_file, index=False)
+    logger.info(f"ROI data saved to {csv_file}")
+    
+    return csv_file
+
 def create_time_series_graph_per_agent(df):
     """Create a time series graph for each agent using Plotly"""
     # Get unique agents
@@ -802,8 +1306,12 @@ def create_combined_time_series_graph(df):
     df['apr'] = df['apr'].astype(float)  # Ensure APR is float
     df['metric_type'] = df['metric_type'].astype(str)  # Ensure metric_type is string
     
-    # Set x-axis start date to April 17, 2025 as requested by user
-    x_start_date = datetime(2025, 4, 17, 0, 0, 0)
+    # Get min and max time for shapes
+    min_time = df['timestamp'].min()
+    max_time = df['timestamp'].max()
+    
+    # Use April 17th, 2025 as the fixed start date for APR graph
+    x_start_date = datetime(2025, 4, 17)
     
     # CRITICAL: Log the exact dataframe we're using for plotting to help debug
     logger.info(f"Graph data - shape: {df.shape}, columns: {df.columns}")
@@ -1908,182 +2416,290 @@ def dashboard():
     with gr.Blocks() as demo:
         gr.Markdown("# Average Modius Agent Performance")
         
-        # APR Metrics tab - the only tab
-        with gr.Tab("APR Metrics"):
-            with gr.Column():
-                refresh_btn = gr.Button("Refresh APR Data")
-                
-                # Create container for plotly figure with responsive sizing
+        # Create tabs for APR and ROI metrics
+        with gr.Tabs():
+            # APR Metrics tab
+            with gr.Tab("APR Metrics"):
                 with gr.Column():
-                    combined_graph = gr.Plot(label="APR for All Agents", elem_id="responsive_plot")
-                
-                # Create compact toggle controls at the bottom of the graph
-                with gr.Row(visible=True):
-                    gr.Markdown("##### Toggle Graph Lines", elem_id="toggle_title")
-                
-                with gr.Row():
-                    with gr.Column():
-                        with gr.Row(elem_id="toggle_container"):
-                            with gr.Column(scale=1, min_width=150):
-                                apr_toggle = gr.Checkbox(label="APR Average", value=True, elem_id="apr_toggle")
-                            
-                            with gr.Column(scale=1, min_width=150):
-                                adjusted_apr_toggle = gr.Checkbox(label="ETH Adjusted APR Average", value=True, elem_id="adjusted_apr_toggle")
-                
-                # Add custom CSS for making the plot responsive
-                gr.HTML("""
-                <style>
-                    /* Make plot responsive */
-                    #responsive_plot {
-                        width: 100% !important;
-                        max-width: 100% !important;
-                    }
-                    #responsive_plot > div {
-                        width: 100% !important;
-                        height: auto !important;
-                        min-height: 500px !important;
-                    }
+                    refresh_apr_btn = gr.Button("Refresh APR Data")
                     
-                    /* Existing toggle checkbox styling */
-                    #apr_toggle .gr-checkbox {
-                        accent-color: #e74c3c !important;
-                    }
+                    # Create container for plotly figure with responsive sizing
+                    with gr.Column():
+                        combined_apr_graph = gr.Plot(label="APR for All Agents", elem_id="responsive_apr_plot")
                     
-                    #adjusted_apr_toggle .gr-checkbox {
-                        accent-color: #2ecc71 !important;
-                    }
+                    # Create compact toggle controls at the bottom of the graph
+                    with gr.Row(visible=True):
+                        gr.Markdown("##### Toggle Graph Lines", elem_id="apr_toggle_title")
                     
-                    /* Make the toggle section more compact */
-                    #toggle_title {
-                        margin-bottom: 0;
-                        margin-top: 10px;
-                    }
+                    with gr.Row():
+                        with gr.Column():
+                            with gr.Row(elem_id="apr_toggle_container"):
+                                with gr.Column(scale=1, min_width=150):
+                                    apr_toggle = gr.Checkbox(label="APR Average", value=True, elem_id="apr_toggle")
+                                
+                                with gr.Column(scale=1, min_width=150):
+                                    adjusted_apr_toggle = gr.Checkbox(label="ETH Adjusted APR Average", value=True, elem_id="adjusted_apr_toggle")
                     
-                    #toggle_container {
-                        margin-top: 5px;
-                    }
+                    # Add a text area for status messages
+                    apr_status_text = gr.Textbox(label="Status", value="Ready", interactive=False)
+            
+            # ROI Metrics tab
+            with gr.Tab("ROI Metrics"):
+                with gr.Column():
+                    refresh_roi_btn = gr.Button("Refresh ROI Data")
                     
-                    /* Style the checkbox labels */
-                    .gr-form.gr-box {
-                        border: none !important;
-                        background: transparent !important;
-                    }
+                    # Create container for plotly figure with responsive sizing
+                    with gr.Column():
+                        combined_roi_graph = gr.Plot(label="ROI for All Agents", elem_id="responsive_roi_plot")
                     
-                    /* Make checkboxes and labels appear on the same line */
-                    .gr-checkbox-container {
-                        display: flex !important;
-                        align-items: center !important;
-                    }
+                    # Create compact toggle controls at the bottom of the graph
+                    with gr.Row(visible=True):
+                        gr.Markdown("##### Toggle Graph Lines", elem_id="roi_toggle_title")
                     
-                    /* Add colored indicators */
-                    #apr_toggle .gr-checkbox-label::before {
-                        content: "●";
-                        color: #e74c3c;
-                        margin-right: 5px;
-                    }
+                    with gr.Row():
+                        with gr.Column():
+                            with gr.Row(elem_id="roi_toggle_container"):
+                                with gr.Column(scale=1, min_width=150):
+                                    roi_toggle = gr.Checkbox(label="ROI Average", value=True, elem_id="roi_toggle")
                     
-                    #adjusted_apr_toggle .gr-checkbox-label::before {
-                        content: "●";
-                        color: #2ecc71;
-                        margin-right: 5px;
-                    }
-                </style>
-                """)
+                    # Add a text area for status messages
+                    roi_status_text = gr.Textbox(label="Status", value="Ready", interactive=False)
+        
+        # Add custom CSS for making the plots responsive
+        gr.HTML("""
+        <style>
+            /* Make plots responsive */
+            #responsive_apr_plot, #responsive_roi_plot {
+                width: 100% !important;
+                max-width: 100% !important;
+            }
+            #responsive_apr_plot > div, #responsive_roi_plot > div {
+                width: 100% !important;
+                height: auto !important;
+                min-height: 500px !important;
+            }
+            
+            /* Toggle checkbox styling */
+            #apr_toggle .gr-checkbox {
+                accent-color: #e74c3c !important;
+            }
+            
+            #adjusted_apr_toggle .gr-checkbox {
+                accent-color: #2ecc71 !important;
+            }
+            
+            #roi_toggle .gr-checkbox {
+                accent-color: #3498db !important;
+            }
+            
+            /* Make the toggle section more compact */
+            #apr_toggle_title, #roi_toggle_title {
+                margin-bottom: 0;
+                margin-top: 10px;
+            }
+            
+            #apr_toggle_container, #roi_toggle_container {
+                margin-top: 5px;
+            }
+            
+            /* Style the checkbox labels */
+            .gr-form.gr-box {
+                border: none !important;
+                background: transparent !important;
+            }
+            
+            /* Make checkboxes and labels appear on the same line */
+            .gr-checkbox-container {
+                display: flex !important;
+                align-items: center !important;
+            }
+            
+            /* Add colored indicators */
+            #apr_toggle .gr-checkbox-label::before {
+                content: "●";
+                color: #e74c3c;
+                margin-right: 5px;
+            }
+            
+            #adjusted_apr_toggle .gr-checkbox-label::before {
+                content: "●";
+                color: #2ecc71;
+                margin-right: 5px;
+            }
+            
+            #roi_toggle .gr-checkbox-label::before {
+                content: "●";
+                color: #3498db;
+                margin-right: 5px;
+            }
+        </style>
+        """)
+        
+        # Function to update the APR graph
+        def update_apr_graph(show_apr_ma=True, show_adjusted_apr_ma=True):
+            # Generate visualization and get figure object directly
+            try:
+                combined_fig, _ = generate_apr_visualizations()
                 
-                # Function to update the graph
-                def update_apr_graph(show_apr_ma=True, show_adjusted_apr_ma=True):
-                    # Generate visualization and get figure object directly
-                    try:
-                        combined_fig, _ = generate_apr_visualizations()
-                        
-                        # Update visibility of traces based on toggle values
-                        for i, trace in enumerate(combined_fig.data):
-                            # Check if this is a moving average trace
-                            if trace.name == 'Average APR (3d window)':
-                                trace.visible = show_apr_ma
-                            elif trace.name == 'Average ETH Adjusted APR (3d window)':
-                                trace.visible = show_adjusted_apr_ma
-                        
-                        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
+                # Update visibility of traces based on toggle values
+                for i, trace in enumerate(combined_fig.data):
+                    # Check if this is a moving average trace
+                    if trace.name == 'Average APR (3d window)':
+                        trace.visible = show_apr_ma
+                    elif trace.name == 'Average ETH Adjusted APR (3d window)':
+                        trace.visible = show_adjusted_apr_ma
                 
-                # Initialize the graph on load with a placeholder
-                placeholder_fig = go.Figure()
-                placeholder_fig.add_annotation(
-                    text="Click 'Refresh APR Data' to load APR graph", 
+                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)
+                    font=dict(size=15, color="red")
                 )
-                combined_graph.value = placeholder_fig
+                return error_fig
+        
+        # Function to update the ROI graph
+        def update_roi_graph(show_roi_ma=True):
+            # Generate visualization and get figure object directly
+            try:
+                combined_fig, _ = generate_roi_visualizations()
                 
-                # Function to update the graph based on toggle states
-                def update_graph_with_toggles(apr_visible, adjusted_apr_visible):
-                    return update_apr_graph(apr_visible, adjusted_apr_visible)
+                # Update visibility of traces based on toggle values
+                for i, trace in enumerate(combined_fig.data):
+                    # Check if this is a moving average trace
+                    if trace.name == 'Average ROI (3d window)':
+                        trace.visible = show_roi_ma
                 
-                # Function to update the graph without parameters (for refresh button)
-                def refresh_graph():
-                    """Refresh APR data from the database and update the visualization"""
-                    try:
-                        # Fetch new APR data
-                        logger.info("Manually refreshing APR data...")
-                        fetch_apr_data_from_db()
-                        
-                        # Verify data was fetched successfully
-                        if global_df is None or len(global_df) == 0:
-                            logger.error("Failed to fetch APR data")
-                            return combined_graph.value, "Error: Failed to fetch APR data. Check the logs for details."
-                        
-                        # Log info about fetched data with focus on adjusted_apr
-                        may_10_2025 = datetime(2025, 5, 10)
-                        if 'timestamp' in global_df and 'adjusted_apr' in global_df:
-                            after_may_10 = global_df[global_df['timestamp'] >= may_10_2025]
-                            with_adjusted_after_may_10 = after_may_10[after_may_10['adjusted_apr'].notna()]
-                            
-                            logger.info(f"Data points after May 10th, 2025: {len(after_may_10)}")
-                            logger.info(f"Data points with adjusted_apr after May 10th, 2025: {len(with_adjusted_after_may_10)}")
-                        
-                        # Generate new visualization
-                        logger.info("Generating new APR visualization...")
-                        new_graph = update_apr_graph(apr_toggle.value, adjusted_apr_toggle.value)
-                        return new_graph, "APR data refreshed successfully"
-                    except Exception as e:
-                        logger.error(f"Error refreshing APR data: {e}")
-                        return combined_graph.value, f"Error: {str(e)}"
+                return combined_fig
+            except Exception as e:
+                logger.exception("Error generating ROI 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
+        
+        # Initialize the APR graph on load with a placeholder
+        apr_placeholder_fig = go.Figure()
+        apr_placeholder_fig.add_annotation(
+            text="Click 'Refresh APR Data' to load APR graph", 
+            x=0.5, y=0.5, 
+            showarrow=False, 
+            font=dict(size=15)
+        )
+        combined_apr_graph.value = apr_placeholder_fig
+        
+        # Initialize the ROI graph on load with a placeholder
+        roi_placeholder_fig = go.Figure()
+        roi_placeholder_fig.add_annotation(
+            text="Click 'Refresh ROI Data' to load ROI graph", 
+            x=0.5, y=0.5, 
+            showarrow=False, 
+            font=dict(size=15)
+        )
+        combined_roi_graph.value = roi_placeholder_fig
+        
+        # Function to update the APR graph based on toggle states
+        def update_apr_graph_with_toggles(apr_visible, adjusted_apr_visible):
+            return update_apr_graph(apr_visible, adjusted_apr_visible)
+        
+        # Function to update the ROI graph based on toggle states
+        def update_roi_graph_with_toggles(roi_visible):
+            return update_roi_graph(roi_visible)
+        
+        # Function to refresh APR data
+        def refresh_apr_data():
+            """Refresh APR data from the database and update the visualization"""
+            try:
+                # Fetch new APR data
+                logger.info("Manually refreshing APR data...")
+                fetch_apr_data_from_db()
                 
-                # Add a text area for status messages
-                status_text = gr.Textbox(label="Status", value="Ready", interactive=False)
+                # Verify data was fetched successfully
+                if global_df is None or len(global_df) == 0:
+                    logger.error("Failed to fetch APR data")
+                    return combined_apr_graph.value, "Error: Failed to fetch APR data. Check the logs for details."
                 
-                # Set up the button click event for refresh
-                refresh_btn.click(
-                    fn=refresh_graph,
-                    inputs=[],
-                    outputs=[combined_graph, status_text]
-                )
+                # Log info about fetched data with focus on adjusted_apr
+                may_10_2025 = datetime(2025, 5, 10)
+                if 'timestamp' in global_df and 'adjusted_apr' in global_df:
+                    after_may_10 = global_df[global_df['timestamp'] >= may_10_2025]
+                    with_adjusted_after_may_10 = after_may_10[after_may_10['adjusted_apr'].notna()]
+                    
+                    logger.info(f"Data points after May 10th, 2025: {len(after_may_10)}")
+                    logger.info(f"Data points with adjusted_apr after May 10th, 2025: {len(with_adjusted_after_may_10)}")
                 
-                # Set up the toggle switch events
-                apr_toggle.change(
-                    fn=update_graph_with_toggles,
-                    inputs=[apr_toggle, adjusted_apr_toggle],
-                    outputs=[combined_graph]
-                )
+                # Generate new visualization
+                logger.info("Generating new APR visualization...")
+                new_graph = update_apr_graph(apr_toggle.value, adjusted_apr_toggle.value)
+                return new_graph, "APR data refreshed successfully"
+            except Exception as e:
+                logger.error(f"Error refreshing APR data: {e}")
+                return combined_apr_graph.value, f"Error: {str(e)}"
+        
+        # Function to refresh ROI data
+        def refresh_roi_data():
+            """Refresh ROI data from the database and update the visualization"""
+            try:
+                # Fetch new ROI data
+                logger.info("Manually refreshing ROI data...")
+                fetch_apr_data_from_db()  # This also fetches ROI data
                 
-                adjusted_apr_toggle.change(
-                    fn=update_graph_with_toggles,
-                    inputs=[apr_toggle, adjusted_apr_toggle],
-                    outputs=[combined_graph]
-                )
+                # Verify data was fetched successfully
+                if global_roi_df is None or len(global_roi_df) == 0:
+                    logger.error("Failed to fetch ROI data")
+                    return combined_roi_graph.value, "Error: Failed to fetch ROI data. Check the logs for details."
+                
+                # Generate new visualization
+                logger.info("Generating new ROI visualization...")
+                new_graph = update_roi_graph(roi_toggle.value)
+                return new_graph, "ROI data refreshed successfully"
+            except Exception as e:
+                logger.error(f"Error refreshing ROI data: {e}")
+                return combined_roi_graph.value, f"Error: {str(e)}"
+        
+        # Set up the button click event for APR refresh
+        refresh_apr_btn.click(
+            fn=refresh_apr_data,
+            inputs=[],
+            outputs=[combined_apr_graph, apr_status_text]
+        )
         
+        # Set up the button click event for ROI refresh
+        refresh_roi_btn.click(
+            fn=refresh_roi_data,
+            inputs=[],
+            outputs=[combined_roi_graph, roi_status_text]
+        )
+        
+        # Set up the toggle switch events for APR
+        apr_toggle.change(
+            fn=update_apr_graph_with_toggles,
+            inputs=[apr_toggle, adjusted_apr_toggle],
+            outputs=[combined_apr_graph]
+        )
+        
+        adjusted_apr_toggle.change(
+            fn=update_apr_graph_with_toggles,
+            inputs=[apr_toggle, adjusted_apr_toggle],
+            outputs=[combined_apr_graph]
+        )
+        
+        # Set up the toggle switch events for ROI
+        roi_toggle.change(
+            fn=update_roi_graph_with_toggles,
+            inputs=[roi_toggle],
+            outputs=[combined_roi_graph]
+        )
+    
     return demo
 
 # Launch the dashboard