Spaces:
Sleeping
Sleeping
Download src/gaia/utils/log_analyzer.py from jm-vis/Final_Assignment_GAIAAgent: direct link, hf CLI and curl.
- Browser
- Download file 33.7 kB
-
https://huggingface.co/spaces/jm-vis/Final_Assignment_GAIAAgent/resolve/main/src/gaia/utils/log_analyzer.py
- Command line
-
hf download hf://spaces/jm-vis/Final_Assignment_GAIAAgent/src/gaia/utils/log_analyzer.py
-
curl -L -o log_analyzer.py https://huggingface.co/spaces/jm-vis/Final_Assignment_GAIAAgent/resolve/main/src/gaia/utils/log_analyzer.py
33.7 kB
| """ | |
| Log Analyzer for Gaia System | |
| This module provides tools for analyzing log files generated by the Gaia system. | |
| It can parse log files, identify patterns, correlate errors across components, | |
| generate reports, and visualize execution flow. | |
| Features: | |
| - Parse and analyze log files | |
| - Identify error patterns and frequencies | |
| - Correlate errors across different components | |
| - Generate diagnostic reports | |
| - Visualize execution flow and timing | |
| """ | |
| import os | |
| import re | |
| import json | |
| import logging | |
| import datetime | |
| from typing import Dict, List, Any, Optional, Tuple, Set | |
| from collections import defaultdict, Counter | |
| import pandas as pd | |
| import matplotlib.pyplot as plt | |
| import numpy as np | |
| from pathlib import Path | |
| # Configure logging | |
| logging.basicConfig( | |
| level=logging.INFO, | |
| format="%(asctime)s - %(name)s - %(levelname)s - %(message)s" | |
| ) | |
| logger = logging.getLogger("gaia_log_analyzer") | |
| # Default log directory | |
| DEFAULT_LOG_DIR = "logs" | |
| class LogEntry: | |
| """Represents a parsed log entry.""" | |
| def __init__( | |
| self, | |
| timestamp: datetime.datetime, | |
| logger_name: str, | |
| level: str, | |
| trace_id: str, | |
| message: str, | |
| details: Optional[Dict[str, Any]] = None | |
| ): | |
| self.timestamp = timestamp | |
| self.logger_name = logger_name | |
| self.level = level | |
| self.trace_id = trace_id | |
| self.message = message | |
| self.details = details or {} | |
| def __repr__(self): | |
| return f"LogEntry({self.timestamp}, {self.logger_name}, {self.level}, {self.trace_id}, {self.message[:30]}...)" | |
| def from_line(cls, line: str) -> Optional['LogEntry']: | |
| """ | |
| Parse a log line into a LogEntry object. | |
| Args: | |
| line: The log line to parse | |
| Returns: | |
| LogEntry object or None if parsing failed | |
| """ | |
| # Regular expression to match log lines | |
| # Format: timestamp - logger_name - level - [trace_id] - message | |
| pattern = r"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3}) - ([^-]+) - ([^-]+) - \[([^\]]+)\] - (.+)" | |
| match = re.match(pattern, line) | |
| if not match: | |
| return None | |
| timestamp_str, logger_name, level, trace_id, message = match.groups() | |
| try: | |
| timestamp = datetime.datetime.strptime(timestamp_str, "%Y-%m-%d %H:%M:%S,%f") | |
| except ValueError: | |
| timestamp = datetime.datetime.now() # Fallback | |
| # Extract JSON details if present | |
| details = None | |
| if ": {" in message and message.endswith("}"): | |
| try: | |
| json_start = message.index(": {") + 2 | |
| json_str = message[json_start:] | |
| details = json.loads(json_str) | |
| message = message[:json_start-2] # Remove JSON from message | |
| except (ValueError, json.JSONDecodeError): | |
| pass | |
| return cls( | |
| timestamp=timestamp, | |
| logger_name=logger_name.strip(), | |
| level=level.strip(), | |
| trace_id=trace_id.strip(), | |
| message=message.strip(), | |
| details=details | |
| ) | |
| class LogAnalyzer: | |
| """ | |
| Analyzes log files to identify patterns and generate reports. | |
| """ | |
| def __init__(self, log_dir: str = DEFAULT_LOG_DIR): | |
| """ | |
| Initialize the log analyzer. | |
| Args: | |
| log_dir: Directory containing log files | |
| """ | |
| self.log_dir = log_dir | |
| self.log_files = { | |
| "main": os.path.join(log_dir, "gaia_main.log"), | |
| "error": os.path.join(log_dir, "gaia_errors.log"), | |
| "performance": os.path.join(log_dir, "gaia_performance.log"), | |
| "api": os.path.join(log_dir, "gaia_api.log"), | |
| "tool": os.path.join(log_dir, "gaia_tools.log") | |
| } | |
| # Initialize data structures | |
| self.entries_by_trace: Dict[str, List[LogEntry]] = defaultdict(list) | |
| self.errors_by_trace: Dict[str, List[LogEntry]] = defaultdict(list) | |
| self.api_calls_by_trace: Dict[str, List[LogEntry]] = defaultdict(list) | |
| self.tool_usage_by_trace: Dict[str, List[LogEntry]] = defaultdict(list) | |
| self.performance_by_trace: Dict[str, List[LogEntry]] = defaultdict(list) | |
| # Statistics | |
| self.error_counts: Counter = Counter() | |
| self.api_error_counts: Counter = Counter() | |
| self.tool_error_counts: Counter = Counter() | |
| self.trace_durations: Dict[str, float] = {} | |
| self.trace_error_counts: Dict[str, int] = {} | |
| # Load log files | |
| self._load_logs() | |
| def _load_logs(self): | |
| """Load and parse all log files.""" | |
| logger.info(f"Loading logs from {self.log_dir}") | |
| for log_type, log_file in self.log_files.items(): | |
| if not os.path.exists(log_file): | |
| logger.warning(f"Log file not found: {log_file}") | |
| continue | |
| logger.info(f"Parsing {log_type} log: {log_file}") | |
| self._parse_log_file(log_file, log_type) | |
| logger.info(f"Parsed logs for {len(self.entries_by_trace)} trace IDs") | |
| # Calculate statistics | |
| self._calculate_statistics() | |
| def _parse_log_file(self, log_file: str, log_type: str): | |
| """ | |
| Parse a log file and extract entries. | |
| Args: | |
| log_file: Path to the log file | |
| log_type: Type of log file (main, error, etc.) | |
| """ | |
| try: | |
| with open(log_file, 'r', encoding='utf-8') as f: | |
| for line in f: | |
| entry = LogEntry.from_line(line.strip()) | |
| if entry: | |
| # Add to trace-specific collections | |
| self.entries_by_trace[entry.trace_id].append(entry) | |
| # Add to type-specific collections | |
| if log_type == "error" or entry.level in ["ERROR", "CRITICAL"]: | |
| self.errors_by_trace[entry.trace_id].append(entry) | |
| elif log_type == "api": | |
| self.api_calls_by_trace[entry.trace_id].append(entry) | |
| elif log_type == "tool": | |
| self.tool_usage_by_trace[entry.trace_id].append(entry) | |
| elif log_type == "performance": | |
| self.performance_by_trace[entry.trace_id].append(entry) | |
| except Exception as e: | |
| logger.error(f"Error parsing log file {log_file}: {str(e)}") | |
| def _calculate_statistics(self): | |
| """Calculate statistics from parsed logs.""" | |
| # Error counts by type | |
| for trace_id, errors in self.errors_by_trace.items(): | |
| for error in errors: | |
| if "ERROR_DETAILS" in error.message: | |
| if error.details and "error_type" in error.details: | |
| self.error_counts[error.details["error_type"]] += 1 | |
| else: | |
| # Extract error type from message | |
| error_type_match = re.search(r"ERROR: ([^-]+) -", error.message) | |
| if error_type_match: | |
| self.error_counts[error_type_match.group(1).strip()] += 1 | |
| else: | |
| self.error_counts["Unknown"] += 1 | |
| # Count errors per trace | |
| self.trace_error_counts[trace_id] = len(errors) | |
| # API error counts | |
| for trace_id, api_calls in self.api_calls_by_trace.items(): | |
| for call in api_calls: | |
| if "API ERROR" in call.message: | |
| api_name = "Unknown" | |
| api_match = re.search(r"API ERROR: ([^-]+) -", call.message) | |
| if api_match: | |
| api_name = api_match.group(1).strip() | |
| self.api_error_counts[api_name] += 1 | |
| # Tool error counts | |
| for trace_id, tool_usages in self.tool_usage_by_trace.items(): | |
| for usage in tool_usages: | |
| if "TOOL EXECUTION FAILURE" in usage.message: | |
| tool_name = "Unknown" | |
| tool_match = re.search(r"TOOL EXECUTION FAILURE: ([^-]+) -", usage.message) | |
| if tool_match: | |
| tool_name = tool_match.group(1).strip() | |
| self.tool_error_counts[tool_name] += 1 | |
| # Calculate trace durations | |
| for trace_id, entries in self.entries_by_trace.items(): | |
| if entries: | |
| # Sort entries by timestamp | |
| sorted_entries = sorted(entries, key=lambda e: e.timestamp) | |
| start_time = sorted_entries[0].timestamp | |
| end_time = sorted_entries[-1].timestamp | |
| duration = (end_time - start_time).total_seconds() | |
| self.trace_durations[trace_id] = duration | |
| def get_error_summary(self) -> Dict[str, Any]: | |
| """ | |
| Get a summary of errors. | |
| Returns: | |
| Dict containing error statistics | |
| """ | |
| return { | |
| "total_errors": sum(self.error_counts.values()), | |
| "error_types": dict(self.error_counts.most_common()), | |
| "api_errors": dict(self.api_error_counts.most_common()), | |
| "tool_errors": dict(self.tool_error_counts.most_common()), | |
| "traces_with_errors": len(self.errors_by_trace), | |
| "avg_errors_per_trace": sum(self.trace_error_counts.values()) / len(self.trace_error_counts) if self.trace_error_counts else 0 | |
| } | |
| def get_performance_summary(self) -> Dict[str, Any]: | |
| """ | |
| Get a summary of performance metrics. | |
| Returns: | |
| Dict containing performance statistics | |
| """ | |
| # Extract timing data from performance logs | |
| timing_data = [] | |
| for trace_id, entries in self.performance_by_trace.items(): | |
| for entry in entries: | |
| if "TIMING_DATA" in entry.message and entry.details: | |
| timing_data.append(entry.details) | |
| # Group timing data by category | |
| timing_by_category = defaultdict(list) | |
| for data in timing_data: | |
| if "category" in data and "duration" in data: | |
| timing_by_category[data["category"]].append(data["duration"]) | |
| # Calculate statistics | |
| category_stats = {} | |
| for category, durations in timing_by_category.items(): | |
| if durations: | |
| category_stats[category] = { | |
| "count": len(durations), | |
| "avg_duration": sum(durations) / len(durations), | |
| "min_duration": min(durations), | |
| "max_duration": max(durations), | |
| "total_duration": sum(durations) | |
| } | |
| return { | |
| "trace_count": len(self.entries_by_trace), | |
| "avg_trace_duration": sum(self.trace_durations.values()) / len(self.trace_durations) if self.trace_durations else 0, | |
| "min_trace_duration": min(self.trace_durations.values()) if self.trace_durations else 0, | |
| "max_trace_duration": max(self.trace_durations.values()) if self.trace_durations else 0, | |
| "category_stats": category_stats | |
| } | |
| def get_api_summary(self) -> Dict[str, Any]: | |
| """ | |
| Get a summary of API usage. | |
| Returns: | |
| Dict containing API usage statistics | |
| """ | |
| # Extract API call data | |
| api_calls = [] | |
| for trace_id, entries in self.api_calls_by_trace.items(): | |
| for entry in entries: | |
| if "API REQUEST DETAILS" in entry.message and entry.details: | |
| api_calls.append({ | |
| "trace_id": trace_id, | |
| "type": "request", | |
| "api_name": entry.details.get("api_name", "Unknown"), | |
| "endpoint": entry.details.get("endpoint", "Unknown"), | |
| "method": entry.details.get("method", "Unknown"), | |
| "timestamp": entry.timestamp | |
| }) | |
| elif "API RESPONSE DETAILS" in entry.message and entry.details: | |
| api_calls.append({ | |
| "trace_id": trace_id, | |
| "type": "response", | |
| "api_name": entry.details.get("api_name", "Unknown"), | |
| "endpoint": entry.details.get("endpoint", "Unknown"), | |
| "status_code": entry.details.get("status_code", 0), | |
| "duration": entry.details.get("duration", 0), | |
| "timestamp": entry.timestamp | |
| }) | |
| # Count API calls by name | |
| api_call_counts = Counter() | |
| api_error_counts = Counter() | |
| api_durations = defaultdict(list) | |
| for call in api_calls: | |
| if call["type"] == "request": | |
| api_call_counts[call["api_name"]] += 1 | |
| elif call["type"] == "response": | |
| if call["status_code"] >= 400: | |
| api_error_counts[call["api_name"]] += 1 | |
| if "duration" in call: | |
| api_durations[call["api_name"]].append(call["duration"]) | |
| # Calculate average durations | |
| api_avg_durations = {} | |
| for api_name, durations in api_durations.items(): | |
| if durations: | |
| api_avg_durations[api_name] = sum(durations) / len(durations) | |
| return { | |
| "total_api_calls": sum(api_call_counts.values()), | |
| "api_call_counts": dict(api_call_counts.most_common()), | |
| "api_error_counts": dict(api_error_counts.most_common()), | |
| "api_avg_durations": api_avg_durations | |
| } | |
| def get_tool_summary(self) -> Dict[str, Any]: | |
| """ | |
| Get a summary of tool usage. | |
| Returns: | |
| Dict containing tool usage statistics | |
| """ | |
| # Extract tool usage data | |
| tool_usages = [] | |
| for trace_id, entries in self.tool_usage_by_trace.items(): | |
| for entry in entries: | |
| if "TOOL SELECTION DETAILS" in entry.message and entry.details: | |
| tool_usages.append({ | |
| "trace_id": trace_id, | |
| "type": "selection", | |
| "tool_name": entry.details.get("tool_name", "Unknown"), | |
| "reason": entry.details.get("reason", "Unknown"), | |
| "timestamp": entry.timestamp | |
| }) | |
| elif "TOOL EXECUTION DETAILS" in entry.message and entry.details: | |
| tool_usages.append({ | |
| "trace_id": trace_id, | |
| "type": "execution", | |
| "tool_name": entry.details.get("tool_name", "Unknown"), | |
| "success": entry.details.get("success", False), | |
| "duration": entry.details.get("duration", 0), | |
| "timestamp": entry.timestamp | |
| }) | |
| # Count tool selections and executions | |
| tool_selection_counts = Counter() | |
| tool_execution_counts = Counter() | |
| tool_success_counts = Counter() | |
| tool_failure_counts = Counter() | |
| tool_durations = defaultdict(list) | |
| for usage in tool_usages: | |
| if usage["type"] == "selection": | |
| tool_selection_counts[usage["tool_name"]] += 1 | |
| elif usage["type"] == "execution": | |
| tool_execution_counts[usage["tool_name"]] += 1 | |
| if usage["success"]: | |
| tool_success_counts[usage["tool_name"]] += 1 | |
| else: | |
| tool_failure_counts[usage["tool_name"]] += 1 | |
| if "duration" in usage: | |
| tool_durations[usage["tool_name"]].append(usage["duration"]) | |
| # Calculate average durations and success rates | |
| tool_avg_durations = {} | |
| tool_success_rates = {} | |
| for tool_name, durations in tool_durations.items(): | |
| if durations: | |
| tool_avg_durations[tool_name] = sum(durations) / len(durations) | |
| for tool_name, executions in tool_execution_counts.items(): | |
| if executions > 0: | |
| successes = tool_success_counts.get(tool_name, 0) | |
| tool_success_rates[tool_name] = (successes / executions) * 100 | |
| return { | |
| "total_tool_selections": sum(tool_selection_counts.values()), | |
| "total_tool_executions": sum(tool_execution_counts.values()), | |
| "tool_selection_counts": dict(tool_selection_counts.most_common()), | |
| "tool_execution_counts": dict(tool_execution_counts.most_common()), | |
| "tool_success_counts": dict(tool_success_counts.most_common()), | |
| "tool_failure_counts": dict(tool_failure_counts.most_common()), | |
| "tool_avg_durations": tool_avg_durations, | |
| "tool_success_rates": tool_success_rates | |
| } | |
| def get_trace_summary(self, trace_id: str) -> Dict[str, Any]: | |
| """ | |
| Get a summary of a specific trace. | |
| Args: | |
| trace_id: The trace ID to summarize | |
| Returns: | |
| Dict containing trace summary | |
| """ | |
| if trace_id not in self.entries_by_trace: | |
| return {"error": f"Trace ID {trace_id} not found"} | |
| entries = self.entries_by_trace[trace_id] | |
| errors = self.errors_by_trace.get(trace_id, []) | |
| api_calls = self.api_calls_by_trace.get(trace_id, []) | |
| tool_usages = self.tool_usage_by_trace.get(trace_id, []) | |
| performance = self.performance_by_trace.get(trace_id, []) | |
| # Sort entries by timestamp | |
| sorted_entries = sorted(entries, key=lambda e: e.timestamp) | |
| # Extract workflow steps | |
| workflow_steps = [] | |
| for entry in entries: | |
| if "WORKFLOW STEP" in entry.message: | |
| step_match = re.search(r"WORKFLOW STEP: ([^-]+) - (.+)", entry.message) | |
| if step_match: | |
| step_name, description = step_match.groups() | |
| workflow_steps.append({ | |
| "step_name": step_name.strip(), | |
| "description": description.strip(), | |
| "timestamp": entry.timestamp | |
| }) | |
| # Extract timing data | |
| timing_data = [] | |
| for entry in performance: | |
| if "TIMING_DATA" in entry.message and entry.details: | |
| timing_data.append(entry.details) | |
| # Calculate duration | |
| duration = 0 | |
| if sorted_entries: | |
| start_time = sorted_entries[0].timestamp | |
| end_time = sorted_entries[-1].timestamp | |
| duration = (end_time - start_time).total_seconds() | |
| return { | |
| "trace_id": trace_id, | |
| "entry_count": len(entries), | |
| "error_count": len(errors), | |
| "api_call_count": len(api_calls), | |
| "tool_usage_count": len(tool_usages), | |
| "duration": duration, | |
| "start_time": sorted_entries[0].timestamp if sorted_entries else None, | |
| "end_time": sorted_entries[-1].timestamp if sorted_entries else None, | |
| "workflow_steps": workflow_steps, | |
| "timing_data": timing_data, | |
| "errors": [{"message": e.message, "timestamp": e.timestamp} for e in errors] | |
| } | |
| def find_common_error_patterns(self) -> List[Dict[str, Any]]: | |
| """ | |
| Find common error patterns across traces. | |
| Returns: | |
| List of error patterns with frequency and examples | |
| """ | |
| # Extract error messages and stack traces | |
| error_messages = [] | |
| for trace_id, errors in self.errors_by_trace.items(): | |
| for error in errors: | |
| error_type = "Unknown" | |
| error_msg = error.message | |
| # Extract error type and message | |
| if "ERROR_DETAILS" in error.message and error.details: | |
| if "error_type" in error.details: | |
| error_type = error.details["error_type"] | |
| if "error_message" in error.details: | |
| error_msg = error.details["error_message"] | |
| else: | |
| # Try to extract from message | |
| error_match = re.search(r"ERROR: ([^-]+) - (.+)", error.message) | |
| if error_match: | |
| error_type, error_msg = error_match.groups() | |
| error_messages.append({ | |
| "trace_id": trace_id, | |
| "error_type": error_type.strip(), | |
| "error_message": error_msg.strip(), | |
| "timestamp": error.timestamp | |
| }) | |
| # Group similar error messages | |
| error_patterns = defaultdict(list) | |
| for error in error_messages: | |
| # Create a simplified key for grouping | |
| # Remove specific values like IDs, timestamps, etc. | |
| simplified_msg = re.sub(r'\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b', '<UUID>', error["error_message"]) | |
| simplified_msg = re.sub(r'\b\d+\.\d+\.\d+\.\d+\b', '<IP>', simplified_msg) | |
| simplified_msg = re.sub(r'\b\d{4}-\d{2}-\d{2}\b', '<DATE>', simplified_msg) | |
| simplified_msg = re.sub(r'\b\d+\b', '<NUM>', simplified_msg) | |
| key = f"{error['error_type']}:{simplified_msg}" | |
| error_patterns[key].append(error) | |
| # Create summary of patterns | |
| patterns = [] | |
| for key, errors in error_patterns.items(): | |
| if len(errors) >= 2: # Only include patterns that occur multiple times | |
| patterns.append({ | |
| "error_type": errors[0]["error_type"], | |
| "pattern": errors[0]["error_message"], | |
| "count": len(errors), | |
| "examples": [e["trace_id"] for e in errors[:5]], | |
| "first_occurrence": min(e["timestamp"] for e in errors), | |
| "last_occurrence": max(e["timestamp"] for e in errors) | |
| }) | |
| # Sort by frequency | |
| patterns.sort(key=lambda p: p["count"], reverse=True) | |
| return patterns | |
| def find_correlated_errors(self) -> List[Dict[str, Any]]: | |
| """ | |
| Find errors that are correlated (occur together). | |
| Returns: | |
| List of correlated error pairs | |
| """ | |
| # Group errors by trace | |
| errors_by_trace = {} | |
| for trace_id, errors in self.errors_by_trace.items(): | |
| error_types = set() | |
| for error in errors: | |
| error_type = "Unknown" | |
| if "ERROR_DETAILS" in error.message and error.details: | |
| if "error_type" in error.details: | |
| error_type = error.details["error_type"] | |
| else: | |
| # Try to extract from message | |
| error_match = re.search(r"ERROR: ([^-]+) -", error.message) | |
| if error_match: | |
| error_type = error_match.group(1).strip() | |
| error_types.add(error_type) | |
| errors_by_trace[trace_id] = error_types | |
| # Find co-occurring error types | |
| error_pairs = Counter() | |
| for trace_id, error_types in errors_by_trace.items(): | |
| if len(error_types) >= 2: | |
| # Create pairs of error types | |
| for error1 in error_types: | |
| for error2 in error_types: | |
| if error1 < error2: # Avoid duplicates | |
| error_pairs[(error1, error2)] += 1 | |
| # Create correlation summary | |
| correlations = [] | |
| for (error1, error2), count in error_pairs.most_common(): | |
| correlations.append({ | |
| "error_types": [error1, error2], | |
| "count": count, | |
| "examples": [ | |
| trace_id for trace_id, error_types in errors_by_trace.items() | |
| if error1 in error_types and error2 in error_types | |
| ][:5] | |
| }) | |
| return correlations | |
| def identify_bottlenecks(self) -> List[Dict[str, Any]]: | |
| """ | |
| Identify performance bottlenecks. | |
| Returns: | |
| List of identified bottlenecks | |
| """ | |
| # Extract timing data | |
| timing_data = [] | |
| for trace_id, entries in self.performance_by_trace.items(): | |
| for entry in entries: | |
| if "TIMING_DATA" in entry.message and entry.details: | |
| timing_data.append({ | |
| "trace_id": trace_id, | |
| **entry.details | |
| }) | |
| # Group by category and function/name | |
| timing_by_key = defaultdict(list) | |
| for data in timing_data: | |
| if "category" in data and "duration" in data: | |
| key = data["category"] | |
| if "function" in data: | |
| key += f":{data['function']}" | |
| elif "name" in data: | |
| key += f":{data['name']}" | |
| timing_by_key[key].append(data["duration"]) | |
| # Calculate statistics and identify bottlenecks | |
| bottlenecks = [] | |
| for key, durations in timing_by_key.items(): | |
| if len(durations) >= 3: # Only consider operations that occur multiple times | |
| avg_duration = sum(durations) / len(durations) | |
| max_duration = max(durations) | |
| min_duration = min(durations) | |
| total_duration = sum(durations) | |
| # Check if this is a potential bottleneck | |
| # Criteria: high average duration or high variability | |
| is_bottleneck = avg_duration > 1.0 or (max_duration / min_duration > 5.0 if min_duration > 0 else False) | |
| if is_bottleneck: | |
| category, name = key.split(":") if ":" in key else (key, "") | |
| bottlenecks.append({ | |
| "category": category, | |
| "name": name, | |
| "count": len(durations), | |
| "avg_duration": avg_duration, | |
| "min_duration": min_duration, | |
| "max_duration": max_duration, | |
| "total_duration": total_duration, | |
| "variability": max_duration / min_duration if min_duration > 0 else float('inf') | |
| }) | |
| # Sort by average duration | |
| bottlenecks.sort(key=lambda b: b["avg_duration"], reverse=True) | |
| return bottlenecks | |
| def generate_diagnostic_report(self, output_file: str = "gaia_diagnostic_report.json") -> Dict[str, Any]: | |
| """ | |
| Generate a comprehensive diagnostic report. | |
| Args: | |
| output_file: File to save the report to | |
| Returns: | |
| Dict containing the diagnostic report | |
| """ | |
| # Collect all diagnostic information | |
| report = { | |
| "timestamp": datetime.datetime.now().isoformat(), | |
| "trace_count": len(self.entries_by_trace), | |
| "error_summary": self.get_error_summary(), | |
| "performance_summary": self.get_performance_summary(), | |
| "api_summary": self.get_api_summary(), | |
| "tool_summary": self.get_tool_summary(), | |
| "error_patterns": self.find_common_error_patterns(), | |
| "correlated_errors": self.find_correlated_errors(), | |
| "bottlenecks": self.identify_bottlenecks() | |
| } | |
| # Save to file | |
| with open(output_file, 'w', encoding='utf-8') as f: | |
| json.dump(report, f, indent=2, default=str) | |
| logger.info(f"Diagnostic report saved to {output_file}") | |
| return report | |
| def visualize_error_distribution(self, output_file: str = "error_distribution.png"): | |
| """ | |
| Visualize the distribution of errors by type. | |
| Args: | |
| output_file: File to save the visualization to | |
| """ | |
| if not self.error_counts: | |
| logger.warning("No errors found to visualize") | |
| return | |
| # Get top 10 error types | |
| top_errors = self.error_counts.most_common(10) | |
| # Create the plot | |
| plt.figure(figsize=(12, 6)) | |
| labels = [e[0] for e in top_errors] | |
| values = [e[1] for e in top_errors] | |
| plt.bar(labels, values, color='salmon') | |
| plt.xlabel('Error Type') | |
| plt.ylabel('Count') | |
| plt.title('Error Distribution by Type') | |
| plt.xticks(rotation=45, ha='right') | |
| plt.tight_layout() | |
| # Save the figure | |
| plt.savefig(output_file) | |
| logger.info(f"Error distribution visualization saved to {output_file}") | |
| plt.close() | |
| def visualize_performance_breakdown(self, output_file: str = "performance_breakdown.png"): | |
| """ | |
| Visualize the performance breakdown by category. | |
| Args: | |
| output_file: File to save the visualization to | |
| """ | |
| # Extract timing data | |
| timing_by_category = defaultdict(list) | |
| for trace_id, entries in self.performance_by_trace.items(): | |
| for entry in entries: | |
| if "TIMING_DATA" in entry.message and entry.details: | |
| if "category" in entry.details and "duration" in entry.details: | |
| timing_by_category[entry.details["category"]].append(entry.details["duration"]) | |
| if not timing_by_category: | |
| logger.warning("No performance data found to visualize") | |
| return | |
| # Calculate average durations | |
| categories = [] | |
| avg_durations = [] | |
| for category, durations in timing_by_category.items(): | |
| if durations: | |
| categories.append(category) | |
| avg_durations.append(sum(durations) / len(durations)) | |
| # Sort by average duration | |
| sorted_indices = np.argsort(avg_durations)[::-1] | |
| categories = [categories[i] for i in sorted_indices] | |
| avg_durations = [avg_durations[i] for i in sorted_indices] | |
| # Create the plot | |
| plt.figure(figsize=(12, 6)) | |
| plt.bar(categories, avg_durations, color='skyblue') | |
| plt.xlabel('Category') | |
| plt.ylabel('Average Duration (seconds)') | |
| plt.title('Performance Breakdown by Category') | |
| plt.xticks(rotation=45, ha='right') | |
| plt.tight_layout() | |
| # Save the figure | |
| plt.savefig(output_file) | |
| logger.info(f"Performance breakdown visualization saved to {output_file}") | |
| plt.close() | |
| def main(): | |
| """Main entry point for the log analyzer.""" | |
| import argparse | |
| parser = argparse.ArgumentParser(description="Gaia Log Analyzer") | |
| parser.add_argument("--log-dir", type=str, default="logs", help="Directory containing log files") | |
| parser.add_argument("--report", type=str, default="gaia_diagnostic_report.json", help="Output file for diagnostic report") | |
| parser.add_argument("--trace-id", type=str, help="Specific trace ID to analyze") | |
| parser.add_argument("--visualize", action="store_true", help="Generate visualizations") | |
| args = parser.parse_args() | |
| # Create the analyzer | |
| analyzer = LogAnalyzer(log_dir=args.log_dir) | |
| # Generate diagnostic report | |
| report = analyzer.generate_diagnostic_report(output_file=args.report) | |
| # Print summary | |
| print(f"Analyzed {report['trace_count']} traces") | |
| print(f"Found {report['error_summary']['total_errors']} errors") | |
| print(f"Average trace duration: {report['performance_summary']['avg_trace_duration']:.2f} seconds") | |
| # Generate visualizations if requested | |
| if args.visualize: | |
| analyzer.visualize_error_distribution() | |
| analyzer.visualize_performance_breakdown() | |
| # Analyze specific trace if requested | |
| if args.trace_id: | |
| trace_summary = analyzer.get_trace_summary(args.trace_id) | |
| if "error" in trace_summary: | |
| print(f"Error: {trace_summary['error']}") | |
| else: | |
| print(f"\nTrace ID: {args.trace_id}") | |
| print(f"Duration: {trace_summary['duration']:.2f} seconds") | |
| print(f"Errors: {trace_summary['error_count']}") | |
| print(f"API calls: {trace_summary['api_call_count']}") | |
| print(f"Tool usages: {trace_summary['tool_usage_count']}") | |
| if trace_summary['workflow_steps']: | |
| print("\nWorkflow steps:") | |
| for step in trace_summary['workflow_steps']: | |
| print(f"- {step['step_name']}: {step['description']}") | |
| if trace_summary['errors']: | |
| print("\nErrors:") | |
| for error in trace_summary['errors']: | |
| print(f"- {error['message']}") | |
| if __name__ == "__main__": | |
| main() |