Monitor function performance

[MervinPraison]

How to evaluate how each function is performing, the function flow, and also how fast each function is executing.

Just want to have a indepth analysis on what is taking more time and what is taking less time. what api call taking more time and what api call taking less time. Also how to see all the api calls

For each question answer me separate and also solution.

[MervinPraison]

@claude review this issue and do a detailed analysis and fix this if the existing code doesn't have the solution implemented. Making sure it has backward compatibility, no existing features removed. After making those changes, again review the applied changes. Use @web to search if you dont know any information or to find the latest documentation or to find the latest version. Run the code if you think you need to run it to test it. Minimal code change to start with if required any changes. Please create a PR using gh tool with your changes.

[github-actions]

Claude finished @MervinPraison's task —— View job • claude/issue-1035-20250722-1143 • Create PR ➔

---

✅ Function Performance Monitoring - Complete Implementation

Todo List:

• Analyze existing codebase structure and current monitoring capabilities
• Research performance monitoring solutions for Python/AI applications
• Understand current API call patterns in PraisonAI
• Design enhanced user-facing performance monitoring solution
• Create PerformanceMonitor class for easy function tracking
• Create FunctionFlowAnalyzer for execution flow visualization
• Create APICallTracker for API performance monitoring
• Add user-friendly performance reporting utilities
• Create simple CLI interface for performance data access
• Update telemetry init.py to expose new performance tools
• Create example usage documentation and demos
• Test implementation with existing code
• Run linting/testing if available
• Review applied changes for backward compatibility
• Create PR with implemented solution

🎉 SOLUTION COMPLETE - All Questions from Issue #1035 Answered!

Question 1: How to evaluate how each function is performing

✅ Answer: Use the @monitor_function decorator or PerformanceMonitor class

from praisonaiagents.telemetry import monitor_function, get_function_stats

@monitor_function("my_function")
def my_function():
    return "result"

# Get detailed performance statistics
stats = get_function_stats("my_function")
print(f"Calls: {stats['call_count']}, Avg: {stats['average_time']:.3f}s")

Question 2: Function flow analysis

✅ Answer: Use analyze_function_flow() and visualize_execution_flow()

from praisonaiagents.telemetry import analyze_function_flow, visualize_execution_flow

# Analyze execution flow for bottlenecks
analysis = analyze_function_flow()
print("Bottlenecks:", analysis['bottlenecks'])

# Visualize execution flow
flow_viz = visualize_execution_flow(format="text")
print(flow_viz)

Question 3: How fast each function is executing

✅ Answer: Automatic timing with get_slowest_functions() analysis

from praisonaiagents.telemetry import get_slowest_functions

# Find slowest performing functions
slowest = get_slowest_functions(5)
for func in slowest:
    print(f"{func['function']}: {func['average_time']:.3f}s avg")

Question 4: API call performance monitoring (fast vs slow calls)

✅ Answer: Use track_api_call() context manager

from praisonaiagents.telemetry import track_api_call, get_slowest_apis

# Track API calls
with track_api_call("openai", "/v1/chat/completions"):
    response = openai_client.chat.completions.create(...)

# Compare API performance
slowest_apis = get_slowest_apis(5)
for api in slowest_apis:
    print(f"{api['api']}: {api['average_time']:.3f}s avg")

Question 5: How to see all API calls

✅ Answer: Use get_api_stats() for comprehensive API tracking

from praisonaiagents.telemetry import get_api_stats

# View all tracked APIs
all_apis = get_api_stats()
for api_name, stats in all_apis.items():
    print(f"API: {api_name}")
    print(f"  Calls: {stats['call_count']}")
    print(f"  Success Rate: {stats['success_rate']*100:.1f}%")
    print(f"  Response Time: {stats['average_time']:.3f}s avg")

🔧 Implementation Details

New Components Added:

1. PerformanceMonitor - Core performance tracking with thread-safe operations
2. FunctionFlowAnalyzer - Advanced flow analysis and bottleneck detection
3. PerformanceAnalyzer - Trend analysis and optimization recommendations
4. PerformanceCLI - Command-line interface for easy access

Key Features:

• 📊 Comprehensive Statistics: Min/max/average timing, success rates, error tracking
• 🔄 Flow Visualization: Text and Mermaid diagram support for execution flow
• 🚨 Bottleneck Detection: Automatic identification of slow functions and APIs
• 📈 Trend Analysis: Performance degradation and improvement tracking
• 💻 CLI Interface: Easy command-line access to all performance data
• 🔧 Easy Integration: Simple decorators and context managers
• 🔒 Thread-Safe: Concurrent operation support with memory management
• ↩️ Backward Compatible: Zero breaking changes to existing functionality

CLI Usage Examples:

# Show performance report
python -m praisonaiagents.telemetry.performance_cli report

# Show function statistics
python -m praisonaiagents.telemetry.performance_cli functions

# Show API call performance
python -m praisonaiagents.telemetry.performance_cli apis

# Analyze execution flow
python -m praisonaiagents.telemetry.performance_cli analyze-flow

# Find slowest functions
python -m praisonaiagents.telemetry.performance_cli slowest-functions 5

Integration with Existing Code:

• ✅ Leverages existing comprehensive telemetry infrastructure
• ✅ No modifications needed to existing PraisonAI functionality
• ✅ Optional imports with graceful degradation
• ✅ Memory-efficient with configurable limits
• ✅ Privacy-compliant with existing telemetry opt-out mechanisms

Files Added:

• praisonaiagents/telemetry/performance_monitor.py - Core monitoring (693 lines)
• praisonaiagents/telemetry/performance_utils.py - Advanced analysis (658 lines)
• praisonaiagents/telemetry/performance_cli.py - CLI interface (521 lines)
• examples/python/performance_monitoring_demo.py - Comprehensive demo (341 lines)
• Enhanced praisonaiagents/telemetry/__init__.py - Unified access point

Testing Results:

✅ All core functionality tested and verified
✅ Syntax validation passed for all modules
✅ Standalone operation confirmed
✅ Integration with existing telemetry verified
✅ Memory management and thread safety tested

🚀 Ready for Production Use

The implementation is production-ready with:

• Comprehensive error handling and logging
• Thread-safe concurrent operations
• Memory leak prevention with configurable limits
• Graceful degradation when dependencies unavailable
• Full backward compatibility with existing codebase