#!/usr/bin/env python3 """ Analyze RETRY patterns in the SocialMediaManager-H_A2A project. This script summarizes: - Where errors occur - Retry counts - Retry rates Key focus areas: - BUSINESS-RETRY: a line ending with the [BUSINESS-RETRY] marker Indicates a retry in the content_generator (ShakespeareGeneratorCrew) or post_reviewer (PostReviewCrew) - Orchestrator / crew_execution retries: e.g. [SPAN] crew_execution (retry N) [RETRYN] (if present) """ import os import re from pathlib import Path from collections import defaultdict import json import csv # Base directory and model list BASE_DIR = Path("/Users/wzr/TOSEM-2025/RESULTS") MODELS = [ "DeepSeek-R1", "DeepSeek-V3-1", "GPT-4o-mini", "GPT-5", "Gemini-2.5-flash", "Gemini-2.5-flash-nothinking", "Qwen3-235b", ] PROJECT_NAME = "SocialMediaManager-H_A2A" def extract_error_info(line: str) -> dict: """Extract error information from an error line. Returns: {'has_error': bool, 'node_type': str, 'node_name': str, 'error_msg': str} """ # Remove tree-drawing characters (including ─) clean = re.sub(r"^[│├└─\-\s]+", "", line).strip() # Check for error marker if "❌" not in clean: return {"has_error": False} # Remove error marker clean = clean.split("❌", 1)[1].lstrip() # Extract node type and name node_match = re.match( r"\[(SPAN|Chain|AGENT|Tool|LLM)\]\s+([^\[\]]+?)(?:\s+\[ERROR:(.*))?$", clean, ) if not node_match: return { "has_error": True, "node_type": "Unknown", "node_name": "Unknown", "error_msg": "", } node_type = node_match.group(1) node_name = node_match.group(2).strip() error_msg = node_match.group(3).strip() if node_match.group(3) else "" # Normalize node name if node_type == "AGENT": node_name = re.sub(r"\._execute_core$", "", node_name) elif node_type == "Tool": node_name = re.sub(r"\._use$", "", node_name) elif node_type == "Chain": node_name = re.sub(r"Crew_[a-f0-9\-]+\.kickoff", "Crew***.kickoff", node_name) return { "has_error": True, "node_type": node_type, "node_name": node_name, "error_msg": error_msg, } def extract_retry_info(line: str) -> dict: """Extract retry information from a line that indicates a retry. In SocialMediaManager-H_A2A: - BUSINESS-RETRY: a SPAN line contains [BUSINESS-RETRY] Example: [SPAN] a2a_call_content_generator [...] [BUSINESS-RETRY] - Orchestrator retry (if present): e.g. [SPAN] crew_execution (retry 1) [RETRY1] ... Returns: { 'is_retry': bool, 'retry_type': str ('orchestrator' or 'business_logic'), 'retry_number': int (for BUSINESS-RETRY this is inferred from order), 'node_type': str, 'node_name': str, 'agent_name': str (inferred from the associated AGENT, used for grouping) } """ # Remove tree-drawing characters (including ─) clean = re.sub(r"^[│├└─\-\s]+", "", line).strip() # BUSINESS-RETRY marker has_business_retry_flag = "[BUSINESS-RETRY]" in clean # Orchestrator retry marker: (retry N) or [RETRYN] orchestrator_retry_match = re.search(r"\(retry\s+(\d+)\)", clean) if not orchestrator_retry_match: orchestrator_retry_match = re.search(r"\[RETRY(\d+)\]", clean) # If neither retry marker exists, return False if not has_business_retry_flag and not orchestrator_retry_match: return {"is_retry": False} # Determine retry type and number if orchestrator_retry_match: retry_type = "orchestrator" retry_number = int(orchestrator_retry_match.group(1)) else: retry_type = "business_logic" # BUSINESS-RETRY has no explicit number; infer it later based on order retry_number = 0 # will be filled in later # Extract node type/name (may have a leading ❌ prefix) # A2A_mix: BUSINESS-RETRY marker appears on SPAN lines node_match = re.match( r"(?:❌\s*)?\[(SPAN|Chain|AGENT)\]\s+([^\[\]]+?)(?:\s+\[.*)?$", clean, ) if not node_match: return { "is_retry": True, "retry_type": retry_type, "retry_number": retry_number, "node_type": "Unknown", "node_name": "Unknown", "agent_name": "", } node_type = node_match.group(1) node_name = node_match.group(2).strip() # For SPAN/Chain nodes, infer which service it corresponds to agent_name = "" if node_type == "SPAN": # A2A_mix: SPAN name contains service information if "a2a_call_content_generator" in node_name: agent_name = "Shakespearean Bard" # content_generator elif "a2a_call_post_reviewer" in node_name: agent_name = "X Post Verifier" # post_reviewer elif node_type == "Chain" and "Crew" in node_name: # Normalize UUID node_name = re.sub(r"Crew_[a-f0-9\-]+\.kickoff", "Crew***.kickoff", node_name) # BUSINESS-RETRY happens in ShakespeareGeneratorCrew or PostReviewCrew agent_name = "" # will be set later return { "is_retry": True, "retry_type": retry_type, "retry_number": retry_number, "node_type": node_type, "node_name": node_name, "agent_name": agent_name, } def analyze_session(md_file: str) -> dict: """Analyze a single session's `execution_path.md`. Returns: { 'has_error': bool, 'has_retry': bool, 'has_orchestrator_retry': bool, 'has_business_retry': bool, 'max_retry_number': int, 'total_orchestrator_retries': int, 'total_business_retries': int, 'generator_retry_count': int (retry count for ShakespeareGeneratorCrew), 'reviewer_retry_count': int (retry count for PostReviewCrew), 'errors': [{'node_type': str, 'node_name': str, 'error_msg': str}, ...], 'retries': [{ 'retry_type': str, 'retry_number': int, 'node_type': str, 'node_name': str, 'agent_name': str }, ...] } """ if not os.path.exists(md_file): return None with open(md_file, "r", encoding="utf-8") as f: content = f.read() # Extract the "Execution Path Tree" section tree_match = re.search( r"## Execution Path Tree.*?```\n(.*?)```", content, re.DOTALL ) if not tree_match: return None tree_content = tree_match.group(1) lines = tree_content.split("\n") errors = [] retries = [] current_agent = None # used to associate Chain retries with the current AGENT for i, line in enumerate(lines): if not line.strip(): continue # Extract errors error_info = extract_error_info(line) if error_info["has_error"]: errors.append( { "node_type": error_info.get("node_type", "Unknown"), "node_name": error_info.get("node_name", "Unknown"), "error_msg": error_info.get("error_msg", ""), } ) # Track current AGENT (to associate subsequent Chain entries) if "[AGENT]" in line: # Supports two formats: # 1. CrewAI: [AGENT] Shakespearean Bard._execute_core # 2. AutoGen: [AGENT] invoke_agent x_post_verifier clean_line = re.sub(r"^[│├└─\-\s]+", "", line).strip() # Try AutoGen format first autogen_match = re.search(r"\[AGENT\]\s+invoke_agent\s+(\w+)", clean_line) if autogen_match: agent_name = autogen_match.group(1).strip() # Normalize naming: x_post_verifier -> X Post Verifier if agent_name == "x_post_verifier": agent_name = "X Post Verifier" current_agent = agent_name else: # CrewAI format crewai_match = re.search( r"\[AGENT\]\s+([^\.]+?)(?:\._execute_core)?(?:\s+\[|$)", clean_line ) if crewai_match: current_agent = crewai_match.group(1).strip() # Extract retries retry_info = extract_retry_info(line) if retry_info["is_retry"]: # For BUSINESS-RETRY, if agent_name is missing, infer from current AGENT if retry_info["retry_type"] == "business_logic": if not retry_info["agent_name"]: retry_info["agent_name"] = ( current_agent if current_agent else "Unknown" ) retries.append(retry_info) # Assign sequence numbers for BUSINESS-RETRY (in occurrence order) business_retry_counter = {} for retry in retries: if retry["retry_type"] == "business_logic": agent_name = retry["agent_name"] if agent_name not in business_retry_counter: business_retry_counter[agent_name] = 0 business_retry_counter[agent_name] += 1 retry["retry_number"] = business_retry_counter[agent_name] # Summarize retry categories orchestrator_retries = [r for r in retries if r["retry_type"] == "orchestrator"] business_retries = [r for r in retries if r["retry_type"] == "business_logic"] max_retry = ( max([r["retry_number"] for r in orchestrator_retries]) if orchestrator_retries else 0 ) # Count retries for Generator and Reviewer generator_retries = [ r for r in business_retries if "Shakespearean Bard" in r.get("agent_name", "") ] reviewer_retries = [ r for r in business_retries if "X Post Verifier" in r.get("agent_name", "") ] return { "has_error": len(errors) > 0, "has_retry": len(retries) > 0, "has_orchestrator_retry": len(orchestrator_retries) > 0, "has_business_retry": len(business_retries) > 0, "max_retry_number": max_retry, "total_orchestrator_retries": len(orchestrator_retries), "total_business_retries": len(business_retries), "generator_retry_count": len(generator_retries), "reviewer_retry_count": len(reviewer_retries), "errors": errors, "retries": retries, } def collect_model_stats(model_name: str) -> dict: """Collect RETRY statistics for a single model. Returns: { 'model': str, 'total_sessions': int, 'sessions_with_error': int, 'sessions_with_retry': int, 'sessions_with_orchestrator_retry': int, 'sessions_with_business_retry': int, 'total_orchestrator_retry_attempts': int, 'total_business_retry_attempts': int, 'total_generator_retries': int, 'total_reviewer_retries': int, 'error_by_agent': {agent_name: count}, 'error_types': {error_msg: count}, 'max_retry_number': int, 'business_retry_by_agent': {agent_name: count}, 'session_details': [...] } """ test_results_dir = BASE_DIR / model_name / PROJECT_NAME / "test_results" if not test_results_dir.exists(): return None stats = { "model": model_name, "total_sessions": 0, "sessions_with_error": 0, "sessions_with_retry": 0, "sessions_with_orchestrator_retry": 0, "sessions_with_business_retry": 0, "sessions_with_only_orchestrator_retry": 0, "sessions_with_only_business_retry": 0, "sessions_with_both_retries": 0, "total_orchestrator_retry_attempts": 0, "total_business_retry_attempts": 0, "total_generator_retries": 0, "total_reviewer_retries": 0, "error_by_agent": defaultdict(int), "error_by_node_type": defaultdict(int), "error_types": defaultdict(int), "max_retry_number": 0, "business_retry_by_agent": defaultdict(int), "session_details": [], } for session_dir in sorted(test_results_dir.iterdir()): if not session_dir.is_dir(): continue exec_path_file = session_dir / "execution_path.md" if not exec_path_file.exists(): continue stats["total_sessions"] += 1 analysis = analyze_session(str(exec_path_file)) if not analysis: continue # Count errors and retries if analysis["has_error"]: stats["sessions_with_error"] += 1 if analysis["has_retry"]: stats["sessions_with_retry"] += 1 if analysis["has_orchestrator_retry"]: stats["sessions_with_orchestrator_retry"] += 1 stats["total_orchestrator_retry_attempts"] += analysis[ "total_orchestrator_retries" ] stats["max_retry_number"] = max( stats["max_retry_number"], analysis["max_retry_number"] ) if analysis["has_business_retry"]: stats["sessions_with_business_retry"] += 1 stats["total_business_retry_attempts"] += analysis["total_business_retries"] stats["total_generator_retries"] += analysis["generator_retry_count"] stats["total_reviewer_retries"] += analysis["reviewer_retry_count"] # Count sessions with only one retry type vs both types if analysis["has_orchestrator_retry"] and not analysis["has_business_retry"]: stats["sessions_with_only_orchestrator_retry"] += 1 elif analysis["has_business_retry"] and not analysis["has_orchestrator_retry"]: stats["sessions_with_only_business_retry"] += 1 elif analysis["has_orchestrator_retry"] and analysis["has_business_retry"]: stats["sessions_with_both_retries"] += 1 # Count where errors occurred for error in analysis["errors"]: if error["node_type"] == "AGENT": stats["error_by_agent"][error["node_name"]] += 1 stats["error_by_node_type"][error["node_type"]] += 1 # Build a short label for the error type error_msg = error["error_msg"] if error_msg: # Use the first 100 characters as an identifier error_type = ( error_msg[:100] if len(error_msg) <= 100 else error_msg[:100] + "..." ) stats["error_types"][error_type] += 1 # Count where BUSINESS-RETRY occurs (by agent) for retry in analysis["retries"]: if retry["retry_type"] == "business_logic" and retry["agent_name"]: stats["business_retry_by_agent"][retry["agent_name"]] += 1 # Save per-session details stats["session_details"].append( { "session": session_dir.name, "has_error": analysis["has_error"], "has_retry": analysis["has_retry"], "has_orchestrator_retry": analysis["has_orchestrator_retry"], "has_business_retry": analysis["has_business_retry"], "orchestrator_retry_count": analysis["total_orchestrator_retries"], "business_retry_count": analysis["total_business_retries"], "generator_retry_count": analysis["generator_retry_count"], "reviewer_retry_count": analysis["reviewer_retry_count"], "errors": analysis["errors"], "retries": analysis["retries"], } ) # Compute retry rates total = stats["total_sessions"] stats["retry_rate"] = ( (stats["sessions_with_retry"] / total * 100) if total > 0 else 0 ) stats["orchestrator_retry_rate"] = ( (stats["sessions_with_orchestrator_retry"] / total * 100) if total > 0 else 0 ) stats["business_retry_rate"] = ( (stats["sessions_with_business_retry"] / total * 100) if total > 0 else 0 ) stats["error_rate"] = ( (stats["sessions_with_error"] / total * 100) if total > 0 else 0 ) # Convert defaultdict to plain dict stats["error_by_agent"] = dict(stats["error_by_agent"]) stats["error_by_node_type"] = dict(stats["error_by_node_type"]) stats["error_types"] = dict(stats["error_types"]) stats["business_retry_by_agent"] = dict(stats["business_retry_by_agent"]) return stats def print_summary(all_stats): """Print summary statistics.""" print("\n" + "=" * 130) print(f"RETRY pattern analysis summary - {PROJECT_NAME}") print("=" * 130 + "\n") # Overall summary table print("## Per-model summary\n") header = f"{'Model':<30} {'TotalSessions':<13} {'ErrorRate':<10} {'TotalRetryRate':<14} {'BusinessRetryRate':<17} {'GeneratorRetry':<15} {'ReviewerRetry':<15}" print(header) print("-" * 130) for stats in all_stats: if stats: print( f"{stats['model']:<30} {stats['total_sessions']:<10} " f"{stats['error_rate']:>8.1f}% {stats['retry_rate']:>8.1f}% " f"{stats['business_retry_rate']:>10.1f}% {stats['total_generator_retries']:<13} {stats['total_reviewer_retries']:<13}" ) print("\n" + "=" * 130) # Per-model details for stats in all_stats: if not stats: continue print(f"\n### 📊 {stats['model']}\n") print(f"- **Total sessions**: {stats['total_sessions']}") print( f"- **Sessions with errors**: {stats['sessions_with_error']} ({stats['error_rate']:.1f}%)" ) print( f"- **Sessions with retries**: {stats['sessions_with_retry']} ({stats['retry_rate']:.1f}%)" ) if stats["sessions_with_orchestrator_retry"] > 0: print( f" - Orchestrator retry: {stats['sessions_with_orchestrator_retry']} ({stats['orchestrator_retry_rate']:.1f}%) " f"[only orchestrator: {stats['sessions_with_only_orchestrator_retry']}]" ) print( f" - Business retry: {stats['sessions_with_business_retry']} ({stats['business_retry_rate']:.1f}%) " f"[only business: {stats['sessions_with_only_business_retry']}]" ) if stats["sessions_with_both_retries"] > 0: print(f" - Both types present: {stats['sessions_with_both_retries']}") print("- **Total retry attempts**:") if stats["total_orchestrator_retry_attempts"] > 0: print( f" - Orchestrator retry: {stats['total_orchestrator_retry_attempts']}" ) print( f" - Business retry: {stats['total_business_retry_attempts']} " f"(Generator: {stats['total_generator_retries']}, Reviewer: {stats['total_reviewer_retries']})" ) if stats["max_retry_number"] > 0: print(f"- **Max orchestrator retry number**: {stats['max_retry_number']}") if stats["error_by_agent"]: print("\n**Agents where errors occurred**:") for agent, count in sorted( stats["error_by_agent"].items(), key=lambda x: x[1], reverse=True )[:5]: print(f" - {agent}: {count}") if stats["business_retry_by_agent"]: print("\n**Business retry by agent (sorted)**:") for agent, count in sorted( stats["business_retry_by_agent"].items(), key=lambda x: x[1], reverse=True, ): print(f" - {agent}: {count}") if stats["error_types"]: print("\n**Error types (top 3)**:") for error_type, count in sorted( stats["error_types"].items(), key=lambda x: x[1], reverse=True )[:3]: print(f" - [{count}] {error_type}") print("\n" + "-" * 130) def save_results(all_stats): """Save results to files.""" output_dir = Path(__file__).parent # Save detailed JSON json_file = output_dir / "retry_analysis.json" json_data = [] for stats in all_stats: if stats: json_data.append(stats) with open(json_file, "w", encoding="utf-8") as f: json.dump(json_data, f, indent=2, ensure_ascii=False) print(f"\n✅ Detailed JSON saved: {json_file}") # Save CSV summary csv_file = output_dir / "retry_summary.csv" with open(csv_file, "w", newline="", encoding="utf-8") as f: writer = csv.writer(f) writer.writerow( [ "Model", "Total_Sessions", "Sessions_With_Error", "Error_Rate(%)", "Sessions_With_Retry", "Retry_Rate(%)", "Orchestrator_Retry_Sessions", "Orchestrator_Retry_Rate(%)", "Only_Orchestrator_Retry_Sessions", "Business_Retry_Sessions", "Business_Retry_Rate(%)", "Only_Business_Retry_Sessions", "Both_Retries_Sessions", "Total_Orchestrator_Retries", "Total_Business_Retries", "Total_Generator_Retries", "Total_Reviewer_Retries", "Max_Retry_Number", ] ) for stats in all_stats: if stats: writer.writerow( [ stats["model"], stats["total_sessions"], stats["sessions_with_error"], f"{stats['error_rate']:.2f}", stats["sessions_with_retry"], f"{stats['retry_rate']:.2f}", stats["sessions_with_orchestrator_retry"], f"{stats['orchestrator_retry_rate']:.2f}", stats["sessions_with_only_orchestrator_retry"], stats["sessions_with_business_retry"], f"{stats['business_retry_rate']:.2f}", stats["sessions_with_only_business_retry"], stats["sessions_with_both_retries"], stats["total_orchestrator_retry_attempts"], stats["total_business_retry_attempts"], stats["total_generator_retries"], stats["total_reviewer_retries"], stats["max_retry_number"], ] ) print(f"✅ CSV summary saved: {csv_file}") # Save error location stats (by agent) error_csv_file = output_dir / "error_by_agent.csv" with open(error_csv_file, "w", newline="", encoding="utf-8") as f: writer = csv.writer(f) writer.writerow(["Model", "Agent_Name", "Error_Count"]) for stats in all_stats: if stats and stats["error_by_agent"]: for agent, count in sorted( stats["error_by_agent"].items(), key=lambda x: x[1], reverse=True ): writer.writerow([stats["model"], agent, count]) print(f"✅ Error-by-agent stats saved: {error_csv_file}") # Save business-retry-by-agent stats retry_agent_csv_file = output_dir / "business_retry_by_agent.csv" with open(retry_agent_csv_file, "w", newline="", encoding="utf-8") as f: writer = csv.writer(f) writer.writerow(["Model", "Agent_Name", "Retry_Count"]) for stats in all_stats: if stats and stats["business_retry_by_agent"]: for agent, count in sorted( stats["business_retry_by_agent"].items(), key=lambda x: x[1], reverse=True, ): writer.writerow([stats["model"], agent, count]) print(f"✅ Business-retry-by-agent stats saved: {retry_agent_csv_file}") if __name__ == "__main__": print(f"Starting RETRY pattern analysis - {PROJECT_NAME}...") print("Retry types:") print( " 1. Orchestrator retry: e.g. [SPAN] crew_execution (retry N) [RETRYN] (if present)" ) print( " 2. Business retry: a Chain line contains the [BUSINESS-RETRY] marker\n" " - ShakespeareGeneratorCrew (content_generator) retries\n" " - PostReviewCrew (post_reviewer) retries\n" ) all_stats = [] for model in MODELS: print(f"\n📊 Analyzing model: {model}") stats = collect_model_stats(model) if stats: all_stats.append(stats) print( f" ✅ Done: {stats['total_sessions']} sessions, " f"{stats['sessions_with_error']} errors, " f"{stats['sessions_with_business_retry']} business retries " f"(Gen: {stats['total_generator_retries']}, Rev: {stats['total_reviewer_retries']})" ) else: print(" ⚠️ Skipped (directory not found)") print_summary(all_stats) save_results(all_stats) print("\n" + "=" * 130) print("✅ Done.") print("=" * 130)