feat: add timezone adjustment function and enhance logging for timestamp handling

app.py

@@ -28,6 +28,24 @@ 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)
+
 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}")
@@ -93,10 +111,12 @@ def extract_apr_value(attr: Dict[str, Any]) -> Dict[str, Any]:
     try:
         # 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}
         
         # 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')}")
             json_data = json.loads(attr["json_value"])
         else:
             json_data = attr["json_value"]
@@ -104,10 +124,24 @@ 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)}")
+        
         # 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}
     except (json.JSONDecodeError, KeyError, TypeError) as e:
@@ -120,6 +154,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
+    
     try:
         # Step 1: Find the Modius agent type
         modius_type = get_agent_type_by_name("Modius")
@@ -158,6 +197,10 @@ def fetch_apr_data_from_db():
         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
@@ -180,6 +223,12 @@ def fetch_apr_data_from_db():
             return global_df
         
         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()}")
+        
         return global_df
         
     except requests.exceptions.RequestException as e:
@@ -379,11 +428,32 @@ 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}")
+    
+    # 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}")
+    
+    # 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']}")
+    
     # 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)]
@@ -428,7 +498,9 @@ def create_combined_time_series_graph(df):
         
         # Sort the data by timestamp
         agent_data = agent_data.sort_values('timestamp')
-        print("agent_data_combined",agent_data)
+        logger.info(f"Agent {agent_name} data points: {len(agent_data)}")
+        logger.info(f"Agent {agent_name} timestamps: {agent_data['timestamp'].tolist()}")
+        
         # Add the combined line for both APR and Performance
         fig.add_trace(
             go.Scatter(
@@ -444,7 +516,7 @@ def create_combined_time_series_graph(df):
         
         # Add scatter points for APR values
         apr_data = agent_data[agent_data['metric_type'] == 'APR']
-        print("apr_data_combined",apr_data)
+        logger.info(f"Agent {agent_name} APR points: {len(apr_data)}")
         if not apr_data.empty:
             fig.add_trace(
                 go.Scatter(
@@ -461,7 +533,7 @@ def create_combined_time_series_graph(df):
         
         # Add scatter points for Performance values
         perf_data = agent_data[agent_data['metric_type'] == 'Performance']
-        print("perf_data_combined",perf_data)
+        logger.info(f"Agent {agent_name} Performance points: {len(perf_data)}")
         if not perf_data.empty:
             fig.add_trace(
                 go.Scatter(
@@ -478,7 +550,7 @@ def create_combined_time_series_graph(df):
     
     # Update layout
     fig.update_layout(
-        title="APR and Performance Values for All Agents",
+        title=f"APR and Performance Values for All Agents - {environment_tag} - {current_time}",
         xaxis_title="Time",
         yaxis_title="Value",
         template="plotly_white",
@@ -492,8 +564,17 @@ def create_combined_time_series_graph(df):
             x=1,
             groupclick="toggleitem"
         ),
-        margin=dict(r=20, l=20, t=30, b=20),
-        hovermode="closest"
+        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")
+            )
+        ]
     )
     
     # Update axes