#!/usr/bin/env python3 """ AgentOps Integration for Chase Complete monitoring and observability for E-FIRE-1 """ import asyncio import json import os import time from datetime import datetime from typing import Dict, Any, Optional import aiohttp import logging class AgentOpsMonitor: """Monitors E-FIRE-1 operations with AgentOps""" def __init__(self): self.api_key = os.getenv('AGENTOPS_API_KEY') self.base_url = "https://api.agentops.ai" self.session_id = None self.logger = logging.getLogger('AgentOpsMonitor') async def initialize_session(self): """Initialize AgentOps session""" if not self.api_key: self.logger.warning("AgentOps API key not found") return False url = f"{self.base_url}/v1/session" headers = { "Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json" } payload = { "project": "e-fire-1-chase", "source": "elizabeth-ai", "config": { "max_cost": 50.0, # Daily budget "auto_retry": True, "monitor_llm": True } } try: async with aiohttp.ClientSession() as session: async with session.post(url, headers=headers, json=payload) as resp: if resp.status == 200: data = await resp.json() self.session_id = data.get("session_id") print(f"✅ AgentOps session: {self.session_id}") return True else: self.logger.error(f"AgentOps init failed: {await resp.text()}") return False except Exception as e: self.logger.error(f"AgentOps connection failed: {e}") return False async def log_event(self, event_type: str, data: Dict[str, Any]): """Log event to AgentOps""" if not self.session_id: return url = f"{self.base_url}/v1/event" headers = { "Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json" } event_data = { "session_id": self.session_id, "type": event_type, "timestamp": datetime.utcnow().isoformat(), "data": data } try: async with aiohttp.ClientSession() as session: async with session.post(url, headers=headers, json=event_data) as resp: return resp.status == 200 except Exception as e: self.logger.error(f"Failed to log event: {e}") return False async def log_earnings(self, amount: float, strategy: str, api_cost: float): """Log earnings event""" await self.log_event("earnings", { "amount": amount, "strategy": strategy, "api_cost": api_cost, "net_profit": amount - api_cost, "goal_progress": (amount / 50.0) * 100 }) async def log_api_usage(self, provider: str, model: str, cost: float, tokens: int): """Log API usage""" await self.log_event("api_usage", { "provider": provider, "model": model, "cost": cost, "tokens": tokens, "cost_per_token": cost / max(tokens, 1) }) async def log_agent_spawn(self, agent_type: str, config: Dict[str, Any]): """Log agent spawning""" await self.log_event("agent_spawn", { "agent_type": agent_type, "config": config, "timestamp": time.time() }) async def log_error(self, error_type: str, error_message: str, context: Dict[str, Any]): """Log error event""" await self.log_event("error", { "error_type": error_type, "message": error_message, "context": context }) async def get_dashboard_url(self): """Get AgentOps dashboard URL""" if not self.session_id: return None return f"https://app.agentops.ai/dashboard?session_id={self.session_id}" async def end_session(self): """End AgentOps session""" if not self.session_id: return url = f"{self.base_url}/v1/session/{self.session_id}/end" headers = { "Authorization": f"Bearer {self.api_key}" } try: async with aiohttp.ClientSession() as session: async with session.post(url, headers=headers) as resp: return resp.status == 200 except Exception as e: self.logger.error(f"Failed to end session: {e}") return False class EarningsTracker: """Tracks earnings with AgentOps integration""" def __init__(self, agentops_monitor: AgentOpsMonitor): self.agentops = agentops_monitor self.daily_earnings = 0.0 self.daily_costs = 0.0 self.strategies_used = set() async def track_earning(self, amount: float, strategy: str, api_cost: float): """Track a single earning""" self.daily_earnings += amount self.daily_costs += api_cost self.strategies_used.add(strategy) # Log to AgentOps await self.agentops.log_earnings(amount, strategy, api_cost) # Log progress progress = (self.daily_earnings / 50.0) * 100 print(f"💰 Daily: ${self.daily_earnings:.2f} (${50 - self.daily_earnings:.2f} to goal)") print(f"📊 Progress: {progress:.1f}% toward $50/day") async def track_api_call(self, provider: str, model: str, cost: float, tokens: int): """Track API usage""" await self.agentops.log_api_usage(provider, model, cost, tokens) async def get_status(self): """Get current status""" return { "daily_earnings": self.daily_earnings, "daily_costs": self.daily_costs, "net_profit": self.daily_earnings - self.daily_costs, "strategies_used": list(self.strategies_used), "progress_percent": (self.daily_earnings / 50.0) * 100, "remaining_to_goal": max(0, 50.0 - self.daily_earnings) } class RealTimeMonitor: """Real-time monitoring dashboard""" def __init__(self, agentops_monitor: AgentOpsMonitor): self.agentops = agentops_monitor self.tracker = EarningsTracker(agentops_monitor) self.running = False async def start_monitoring(self): """Start real-time monitoring""" # Initialize AgentOps success = await self.agentops.initialize_session() if success: dashboard_url = await self.agentops.get_dashboard_url() print(f"📊 AgentOps Dashboard: {dashboard_url}") self.running = True # Start monitoring loop while self.running: try: status = await self.tracker.get_status() # Send status update await self.agentops.log_event("status_update", status) # Check if goal reached if status["progress_percent"] >= 100: await self.agentops.log_event("goal_achieved", { "message": "$50/day goal achieved!", "total_earned": status["daily_earnings"] }) print("🎉 GOAL ACHIEVED! $50/day reached!") await asyncio.sleep(60) # Update every minute except Exception as e: await self.agentops.log_error( "monitoring_error", str(e), {"component": "RealTimeMonitor"} ) await asyncio.sleep(60) async def stop_monitoring(self): """Stop monitoring""" self.running = False await self.agentops.end_session() # Integration wrapper for existing code class AgentOpsIntegration: """Easy integration with existing E-FIRE-1 code""" def __init__(self): self.monitor = AgentOpsMonitor() self.tracker = None async def initialize(self): """Initialize integration""" success = await self.monitor.initialize_session() if success: self.tracker = EarningsTracker(self.monitor) print("✅ AgentOps integration ready") return True return False async def track_earning(self, amount: float, strategy: str, api_cost: float): """Track earnings""" if self.tracker: await self.tracker.track_earning(amount, strategy, api_cost) async def track_api_usage(self, provider: str, model: str, cost: float, tokens: int): """Track API usage""" if self.tracker: await self.tracker.track_api_call(provider, model, cost, tokens) async def get_dashboard_url(self): """Get dashboard URL""" return await self.monitor.get_dashboard_url() async def main(): """Test AgentOps integration""" print("🚀 Testing AgentOps Integration") print("=" * 50) integration = AgentOpsIntegration() success = await integration.initialize() if success: dashboard_url = await integration.get_dashboard_url() print(f"📊 Dashboard: {dashboard_url}") # Test tracking await integration.track_earning(5.25, "crypto_arbitrage", 0.02) await integration.track_api_usage("openai", "gpt-4", 0.03, 1000) print("✅ AgentOps integration working!") print("💝 Elizabeth is now fully monitored!") else: print("⚠️ AgentOps integration failed - check API key") if __name__ == "__main__": asyncio.run(main())