""" REST API Endpoints for Crypto API Monitoring System Implements comprehensive monitoring, status tracking, and management endpoints """ from datetime import datetime, timedelta from typing import Optional, List, Dict, Any from fastapi import APIRouter, HTTPException, Query, Body from pydantic import BaseModel, Field # Import core modules from database.db_manager import db_manager from config import config from monitoring.health_checker import HealthChecker from monitoring.rate_limiter import rate_limiter from utils.logger import setup_logger # Setup logger logger = setup_logger("api_endpoints") # Create APIRouter instance router = APIRouter(prefix="/api", tags=["monitoring"]) # ============================================================================ # Pydantic Models for Request/Response Validation # ============================================================================ class TriggerCheckRequest(BaseModel): """Request model for triggering immediate health check""" provider: str = Field(..., description="Provider name to check") class TestKeyRequest(BaseModel): """Request model for testing API key""" provider: str = Field(..., description="Provider name to test") # ============================================================================ # GET /api/status - System Overview # ============================================================================ @router.get("/status") async def get_system_status(): """ Get comprehensive system status overview Returns: System overview with provider counts, health metrics, and last update """ try: # Get latest system metrics from database latest_metrics = db_manager.get_latest_system_metrics() if latest_metrics: return { "total_apis": latest_metrics.total_providers, "online": latest_metrics.online_count, "degraded": latest_metrics.degraded_count, "offline": latest_metrics.offline_count, "avg_response_time_ms": round(latest_metrics.avg_response_time_ms, 2), "last_update": latest_metrics.timestamp.isoformat(), "system_health": latest_metrics.system_health } # Fallback: Calculate from providers if no metrics available providers = db_manager.get_all_providers() # Get recent connection attempts for each provider status_counts = {"online": 0, "degraded": 0, "offline": 0} response_times = [] for provider in providers: attempts = db_manager.get_connection_attempts( provider_id=provider.id, hours=1, limit=10 ) if attempts: recent = attempts[0] if recent.status == "success" and recent.response_time_ms and recent.response_time_ms < 2000: status_counts["online"] += 1 response_times.append(recent.response_time_ms) elif recent.status == "success": status_counts["degraded"] += 1 if recent.response_time_ms: response_times.append(recent.response_time_ms) else: status_counts["offline"] += 1 else: status_counts["offline"] += 1 avg_response_time = sum(response_times) / len(response_times) if response_times else 0 # Determine system health total = len(providers) online_pct = (status_counts["online"] / total * 100) if total > 0 else 0 if online_pct >= 90: system_health = "healthy" elif online_pct >= 70: system_health = "degraded" else: system_health = "unhealthy" return { "total_apis": total, "online": status_counts["online"], "degraded": status_counts["degraded"], "offline": status_counts["offline"], "avg_response_time_ms": round(avg_response_time, 2), "last_update": datetime.utcnow().isoformat(), "system_health": system_health } except Exception as e: logger.error(f"Error getting system status: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get system status: {str(e)}") # ============================================================================ # GET /api/categories - Category Statistics # ============================================================================ @router.get("/categories") async def get_categories(): """ Get statistics for all provider categories Returns: List of category statistics with provider counts and health metrics """ try: categories = config.get_categories() category_stats = [] for category in categories: providers = db_manager.get_all_providers(category=category) if not providers: continue total_sources = len(providers) online_sources = 0 response_times = [] rate_limited_count = 0 last_updated = None for provider in providers: # Get recent attempts attempts = db_manager.get_connection_attempts( provider_id=provider.id, hours=1, limit=5 ) if attempts: recent = attempts[0] # Update last_updated if not last_updated or recent.timestamp > last_updated: last_updated = recent.timestamp # Count online sources if recent.status == "success" and recent.response_time_ms and recent.response_time_ms < 2000: online_sources += 1 response_times.append(recent.response_time_ms) # Count rate limited if recent.status == "rate_limited": rate_limited_count += 1 # Calculate metrics online_ratio = round(online_sources / total_sources, 2) if total_sources > 0 else 0 avg_response_time = round(sum(response_times) / len(response_times), 2) if response_times else 0 # Determine status if online_ratio >= 0.9: status = "healthy" elif online_ratio >= 0.7: status = "degraded" else: status = "critical" category_stats.append({ "name": category, "total_sources": total_sources, "online_sources": online_sources, "online_ratio": online_ratio, "avg_response_time_ms": avg_response_time, "rate_limited_count": rate_limited_count, "last_updated": last_updated.isoformat() if last_updated else None, "status": status }) return category_stats except Exception as e: logger.error(f"Error getting categories: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get categories: {str(e)}") # ============================================================================ # GET /api/providers - Provider List with Filters # ============================================================================ @router.get("/providers") async def get_providers( category: Optional[str] = Query(None, description="Filter by category"), status: Optional[str] = Query(None, description="Filter by status (online/degraded/offline)"), search: Optional[str] = Query(None, description="Search by provider name") ): """ Get list of providers with optional filtering Args: category: Filter by provider category status: Filter by provider status search: Search by provider name Returns: List of providers with detailed information """ try: # Get providers from database providers = db_manager.get_all_providers(category=category) result = [] for provider in providers: # Apply search filter if search and search.lower() not in provider.name.lower(): continue # Get recent connection attempts attempts = db_manager.get_connection_attempts( provider_id=provider.id, hours=1, limit=10 ) # Determine provider status provider_status = "offline" response_time_ms = 0 last_fetch = None if attempts: recent = attempts[0] last_fetch = recent.timestamp if recent.status == "success": if recent.response_time_ms and recent.response_time_ms < 2000: provider_status = "online" else: provider_status = "degraded" response_time_ms = recent.response_time_ms or 0 elif recent.status == "rate_limited": provider_status = "degraded" else: provider_status = "offline" # Apply status filter if status and provider_status != status: continue # Get rate limit info rate_limit_status = rate_limiter.get_status(provider.name) rate_limit = None if rate_limit_status: rate_limit = f"{rate_limit_status['current_usage']}/{rate_limit_status['limit_value']} {rate_limit_status['limit_type']}" elif provider.rate_limit_type and provider.rate_limit_value: rate_limit = f"0/{provider.rate_limit_value} {provider.rate_limit_type}" # Get schedule config schedule_config = db_manager.get_schedule_config(provider.id) result.append({ "id": provider.id, "name": provider.name, "category": provider.category, "status": provider_status, "response_time_ms": response_time_ms, "rate_limit": rate_limit, "last_fetch": last_fetch.isoformat() if last_fetch else None, "has_key": provider.requires_key, "endpoints": provider.endpoint_url }) return result except Exception as e: logger.error(f"Error getting providers: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get providers: {str(e)}") # ============================================================================ # GET /api/logs - Query Logs with Pagination # ============================================================================ @router.get("/logs") async def get_logs( from_time: Optional[str] = Query(None, alias="from", description="Start time (ISO format)"), to_time: Optional[str] = Query(None, alias="to", description="End time (ISO format)"), provider: Optional[str] = Query(None, description="Filter by provider name"), status: Optional[str] = Query(None, description="Filter by status"), page: int = Query(1, ge=1, description="Page number"), per_page: int = Query(50, ge=1, le=500, description="Items per page") ): """ Get connection attempt logs with filtering and pagination Args: from_time: Start time filter to_time: End time filter provider: Provider name filter status: Status filter page: Page number per_page: Items per page Returns: Paginated log entries with metadata """ try: # Calculate time range if from_time: from_dt = datetime.fromisoformat(from_time.replace('Z', '+00:00')) else: from_dt = datetime.utcnow() - timedelta(hours=24) if to_time: to_dt = datetime.fromisoformat(to_time.replace('Z', '+00:00')) else: to_dt = datetime.utcnow() hours = (to_dt - from_dt).total_seconds() / 3600 # Get provider ID if filter specified provider_id = None if provider: prov = db_manager.get_provider(name=provider) if prov: provider_id = prov.id # Get all matching logs (no limit for now) all_logs = db_manager.get_connection_attempts( provider_id=provider_id, status=status, hours=int(hours) + 1, limit=10000 # Large limit to get all ) # Filter by time range filtered_logs = [ log for log in all_logs if from_dt <= log.timestamp <= to_dt ] # Calculate pagination total = len(filtered_logs) total_pages = (total + per_page - 1) // per_page start_idx = (page - 1) * per_page end_idx = start_idx + per_page # Get page of logs page_logs = filtered_logs[start_idx:end_idx] # Format logs for response logs = [] for log in page_logs: # Get provider name prov = db_manager.get_provider(provider_id=log.provider_id) provider_name = prov.name if prov else "Unknown" logs.append({ "id": log.id, "timestamp": log.timestamp.isoformat(), "provider": provider_name, "endpoint": log.endpoint, "status": log.status, "response_time_ms": log.response_time_ms, "http_status_code": log.http_status_code, "error_type": log.error_type, "error_message": log.error_message, "retry_count": log.retry_count, "retry_result": log.retry_result }) return { "logs": logs, "pagination": { "page": page, "per_page": per_page, "total": total, "total_pages": total_pages, "has_next": page < total_pages, "has_prev": page > 1 } } except Exception as e: logger.error(f"Error getting logs: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get logs: {str(e)}") # ============================================================================ # GET /api/schedule - Schedule Status # ============================================================================ @router.get("/schedule") async def get_schedule(): """ Get schedule status for all providers Returns: List of schedule information for each provider """ try: configs = db_manager.get_all_schedule_configs(enabled_only=False) schedule_list = [] for config in configs: # Get provider info provider = db_manager.get_provider(provider_id=config.provider_id) if not provider: continue # Calculate on-time percentage total_runs = config.on_time_count + config.late_count on_time_percentage = round((config.on_time_count / total_runs * 100), 1) if total_runs > 0 else 100.0 # Get today's runs compliance_today = db_manager.get_schedule_compliance( provider_id=config.provider_id, hours=24 ) total_runs_today = len(compliance_today) successful_runs = sum(1 for c in compliance_today if c.on_time) skipped_runs = config.skip_count # Determine status if not config.enabled: status = "disabled" elif on_time_percentage >= 95: status = "on_schedule" elif on_time_percentage >= 80: status = "acceptable" else: status = "behind_schedule" schedule_list.append({ "provider": provider.name, "category": provider.category, "schedule": config.schedule_interval, "last_run": config.last_run.isoformat() if config.last_run else None, "next_run": config.next_run.isoformat() if config.next_run else None, "on_time_percentage": on_time_percentage, "status": status, "total_runs_today": total_runs_today, "successful_runs": successful_runs, "skipped_runs": skipped_runs }) return schedule_list except Exception as e: logger.error(f"Error getting schedule: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get schedule: {str(e)}") # ============================================================================ # POST /api/schedule/trigger - Trigger Immediate Check # ============================================================================ @router.post("/schedule/trigger") async def trigger_check(request: TriggerCheckRequest): """ Trigger immediate health check for a provider Args: request: Request containing provider name Returns: Health check result """ try: # Verify provider exists provider = db_manager.get_provider(name=request.provider) if not provider: raise HTTPException(status_code=404, detail=f"Provider not found: {request.provider}") # Create health checker and run check checker = HealthChecker() result = await checker.check_provider(request.provider) await checker.close() if not result: raise HTTPException(status_code=500, detail=f"Health check failed for {request.provider}") return { "provider": result.provider_name, "status": result.status.value, "response_time_ms": result.response_time, "timestamp": datetime.fromtimestamp(result.timestamp).isoformat(), "error_message": result.error_message, "triggered_at": datetime.utcnow().isoformat() } except HTTPException: raise except Exception as e: logger.error(f"Error triggering check: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to trigger check: {str(e)}") # ============================================================================ # GET /api/freshness - Data Freshness # ============================================================================ @router.get("/freshness") async def get_freshness(): """ Get data freshness information for all providers Returns: List of data freshness metrics """ try: providers = db_manager.get_all_providers() freshness_list = [] for provider in providers: # Get most recent data collection collections = db_manager.get_data_collections( provider_id=provider.id, hours=24, limit=1 ) if not collections: continue collection = collections[0] # Calculate staleness now = datetime.utcnow() fetch_age_minutes = (now - collection.actual_fetch_time).total_seconds() / 60 # Determine TTL based on category ttl_minutes = 5 # Default if provider.category == "market_data": ttl_minutes = 1 elif provider.category == "blockchain_explorers": ttl_minutes = 5 elif provider.category == "news": ttl_minutes = 15 # Determine status if fetch_age_minutes <= ttl_minutes: status = "fresh" elif fetch_age_minutes <= ttl_minutes * 2: status = "stale" else: status = "expired" freshness_list.append({ "provider": provider.name, "category": provider.category, "fetch_time": collection.actual_fetch_time.isoformat(), "data_timestamp": collection.data_timestamp.isoformat() if collection.data_timestamp else None, "staleness_minutes": round(fetch_age_minutes, 2), "ttl_minutes": ttl_minutes, "status": status }) return freshness_list except Exception as e: logger.error(f"Error getting freshness: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get freshness: {str(e)}") # ============================================================================ # GET /api/failures - Failure Analysis # ============================================================================ @router.get("/failures") async def get_failures(): """ Get comprehensive failure analysis Returns: Failure analysis with error distribution and recommendations """ try: # Get failure analysis from database analysis = db_manager.get_failure_analysis(hours=24) # Get recent failures recent_failures = db_manager.get_failure_logs(hours=1, limit=10) recent_list = [] for failure in recent_failures: provider = db_manager.get_provider(provider_id=failure.provider_id) recent_list.append({ "timestamp": failure.timestamp.isoformat(), "provider": provider.name if provider else "Unknown", "error_type": failure.error_type, "error_message": failure.error_message, "http_status": failure.http_status, "retry_attempted": failure.retry_attempted, "retry_result": failure.retry_result }) # Generate remediation suggestions remediation_suggestions = [] error_type_distribution = analysis.get('failures_by_error_type', []) for error_stat in error_type_distribution: error_type = error_stat['error_type'] count = error_stat['count'] if error_type == 'timeout' and count > 5: remediation_suggestions.append({ "issue": "High timeout rate", "suggestion": "Increase timeout values or check network connectivity", "priority": "high" }) elif error_type == 'rate_limit' and count > 3: remediation_suggestions.append({ "issue": "Rate limit errors", "suggestion": "Implement request throttling or add additional API keys", "priority": "medium" }) elif error_type == 'auth_error' and count > 0: remediation_suggestions.append({ "issue": "Authentication failures", "suggestion": "Verify API keys are valid and not expired", "priority": "critical" }) return { "error_type_distribution": error_type_distribution, "top_failing_providers": analysis.get('top_failing_providers', []), "recent_failures": recent_list, "remediation_suggestions": remediation_suggestions } except Exception as e: logger.error(f"Error getting failures: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get failures: {str(e)}") # ============================================================================ # GET /api/rate-limits - Rate Limit Status # ============================================================================ @router.get("/rate-limits") async def get_rate_limits(): """ Get rate limit status for all providers Returns: List of rate limit information """ try: statuses = rate_limiter.get_all_statuses() rate_limit_list = [] for provider_name, status_info in statuses.items(): if status_info: rate_limit_list.append({ "provider": status_info['provider'], "limit_type": status_info['limit_type'], "limit_value": status_info['limit_value'], "current_usage": status_info['current_usage'], "percentage": status_info['percentage'], "reset_time": status_info['reset_time'], "reset_in_seconds": status_info['reset_in_seconds'], "status": status_info['status'] }) # Add providers with configured limits but no tracking yet providers = db_manager.get_all_providers() tracked_providers = {rl['provider'] for rl in rate_limit_list} for provider in providers: if provider.name not in tracked_providers and provider.rate_limit_type and provider.rate_limit_value: rate_limit_list.append({ "provider": provider.name, "limit_type": provider.rate_limit_type, "limit_value": provider.rate_limit_value, "current_usage": 0, "percentage": 0.0, "reset_time": (datetime.utcnow() + timedelta(hours=1)).isoformat(), "reset_in_seconds": 3600, "status": "ok" }) return rate_limit_list except Exception as e: logger.error(f"Error getting rate limits: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get rate limits: {str(e)}") # ============================================================================ # GET /api/config/keys - API Keys Status # ============================================================================ @router.get("/config/keys") async def get_api_keys(): """ Get API key status for all providers Returns: List of API key information (masked) """ try: providers = db_manager.get_all_providers() keys_list = [] for provider in providers: if not provider.requires_key: continue # Determine key status if provider.api_key_masked: key_status = "configured" else: key_status = "missing" # Get usage quota from rate limits if available rate_status = rate_limiter.get_status(provider.name) usage_quota_remaining = None if rate_status: percentage_used = rate_status['percentage'] usage_quota_remaining = f"{100 - percentage_used:.1f}%" keys_list.append({ "provider": provider.name, "key_masked": provider.api_key_masked or "***NOT_SET***", "created_at": provider.created_at.isoformat(), "expires_at": None, # Not tracked in current schema "status": key_status, "usage_quota_remaining": usage_quota_remaining }) return keys_list except Exception as e: logger.error(f"Error getting API keys: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get API keys: {str(e)}") # ============================================================================ # POST /api/config/keys/test - Test API Key # ============================================================================ @router.post("/config/keys/test") async def test_api_key(request: TestKeyRequest): """ Test an API key by performing a health check Args: request: Request containing provider name Returns: Test result """ try: # Verify provider exists and requires key provider = db_manager.get_provider(name=request.provider) if not provider: raise HTTPException(status_code=404, detail=f"Provider not found: {request.provider}") if not provider.requires_key: raise HTTPException(status_code=400, detail=f"Provider {request.provider} does not require an API key") if not provider.api_key_masked: raise HTTPException(status_code=400, detail=f"No API key configured for {request.provider}") # Perform health check to test key checker = HealthChecker() result = await checker.check_provider(request.provider) await checker.close() if not result: raise HTTPException(status_code=500, detail=f"Failed to test API key for {request.provider}") # Determine if key is valid based on result key_valid = result.status.value == "online" or result.status.value == "degraded" # Check for auth-specific errors if result.error_message and ('auth' in result.error_message.lower() or 'key' in result.error_message.lower() or '401' in result.error_message or '403' in result.error_message): key_valid = False return { "provider": request.provider, "key_valid": key_valid, "test_timestamp": datetime.utcnow().isoformat(), "response_time_ms": result.response_time, "status_code": result.status_code, "error_message": result.error_message, "test_endpoint": result.endpoint_tested } except HTTPException: raise except Exception as e: logger.error(f"Error testing API key: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to test API key: {str(e)}") # ============================================================================ # GET /api/charts/health-history - Health History for Charts # ============================================================================ @router.get("/charts/health-history") async def get_health_history( hours: int = Query(24, ge=1, le=168, description="Hours of history to retrieve") ): """ Get health history data for charts Args: hours: Number of hours of history to retrieve Returns: Time series data for health metrics """ try: # Get system metrics history metrics = db_manager.get_system_metrics(hours=hours) if not metrics: return { "timestamps": [], "success_rate": [], "avg_response_time": [] } # Sort by timestamp metrics.sort(key=lambda x: x.timestamp) timestamps = [] success_rates = [] avg_response_times = [] for metric in metrics: timestamps.append(metric.timestamp.isoformat()) # Calculate success rate total = metric.online_count + metric.degraded_count + metric.offline_count success_rate = round((metric.online_count / total * 100), 2) if total > 0 else 0 success_rates.append(success_rate) avg_response_times.append(round(metric.avg_response_time_ms, 2)) return { "timestamps": timestamps, "success_rate": success_rates, "avg_response_time": avg_response_times } except Exception as e: logger.error(f"Error getting health history: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get health history: {str(e)}") # ============================================================================ # GET /api/charts/compliance - Compliance History for Charts # ============================================================================ @router.get("/charts/compliance") async def get_compliance_history( days: int = Query(7, ge=1, le=30, description="Days of history to retrieve") ): """ Get schedule compliance history for charts Args: days: Number of days of history to retrieve Returns: Time series data for compliance metrics """ try: # Get all providers with schedule configs configs = db_manager.get_all_schedule_configs(enabled_only=True) if not configs: return { "dates": [], "compliance_percentage": [] } # Generate date range end_date = datetime.utcnow().date() dates = [] compliance_percentages = [] for day_offset in range(days - 1, -1, -1): current_date = end_date - timedelta(days=day_offset) dates.append(current_date.isoformat()) # Calculate compliance for this day day_start = datetime.combine(current_date, datetime.min.time()) day_end = datetime.combine(current_date, datetime.max.time()) total_checks = 0 on_time_checks = 0 for config in configs: compliance_records = db_manager.get_schedule_compliance( provider_id=config.provider_id, hours=24 ) # Filter for current date day_records = [ r for r in compliance_records if day_start <= r.timestamp <= day_end ] total_checks += len(day_records) on_time_checks += sum(1 for r in day_records if r.on_time) # Calculate percentage compliance_pct = round((on_time_checks / total_checks * 100), 2) if total_checks > 0 else 100.0 compliance_percentages.append(compliance_pct) return { "dates": dates, "compliance_percentage": compliance_percentages } except Exception as e: logger.error(f"Error getting compliance history: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get compliance history: {str(e)}") # ============================================================================ # GET /api/charts/rate-limit-history - Rate Limit History for Charts # ============================================================================ @router.get("/charts/rate-limit-history") async def get_rate_limit_history( hours: int = Query(24, ge=1, le=168, description="Hours of history to retrieve") ): """ Get rate limit usage history data for charts Args: hours: Number of hours of history to retrieve Returns: Time series data for rate limit usage by provider """ try: # Get all providers with rate limits providers = db_manager.get_all_providers() providers_with_limits = [p for p in providers if p.rate_limit_type and p.rate_limit_value] if not providers_with_limits: return { "timestamps": [], "providers": [] } # Generate hourly timestamps end_time = datetime.utcnow() start_time = end_time - timedelta(hours=hours) # Create hourly buckets timestamps = [] current_time = start_time while current_time <= end_time: timestamps.append(current_time.strftime("%H:%M")) current_time += timedelta(hours=1) # Get rate limit usage data for each provider provider_data = [] for provider in providers_with_limits[:5]: # Limit to top 5 for readability # Get rate limit usage records for this provider rate_limit_records = db_manager.get_rate_limit_usage( provider_id=provider.id, hours=hours ) if not rate_limit_records: continue # Group by hour and calculate average percentage usage_percentages = [] current_time = start_time for _ in range(len(timestamps)): hour_end = current_time + timedelta(hours=1) # Get records in this hour bucket hour_records = [ r for r in rate_limit_records if current_time <= r.timestamp < hour_end ] if hour_records: # Calculate average percentage for this hour avg_percentage = sum(r.percentage for r in hour_records) / len(hour_records) usage_percentages.append(round(avg_percentage, 2)) else: # No data for this hour, use 0 usage_percentages.append(0.0) current_time = hour_end provider_data.append({ "name": provider.name, "usage_percentage": usage_percentages }) return { "timestamps": timestamps, "providers": provider_data } except Exception as e: logger.error(f"Error getting rate limit history: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get rate limit history: {str(e)}") # ============================================================================ # GET /api/charts/freshness-history - Data Freshness History for Charts # ============================================================================ @router.get("/charts/freshness-history") async def get_freshness_history( hours: int = Query(24, ge=1, le=168, description="Hours of history to retrieve") ): """ Get data freshness (staleness) history for charts Args: hours: Number of hours of history to retrieve Returns: Time series data for data staleness by provider """ try: # Get all providers providers = db_manager.get_all_providers() if not providers: return { "timestamps": [], "providers": [] } # Generate hourly timestamps end_time = datetime.utcnow() start_time = end_time - timedelta(hours=hours) # Create hourly buckets timestamps = [] current_time = start_time while current_time <= end_time: timestamps.append(current_time.strftime("%H:%M")) current_time += timedelta(hours=1) # Get freshness data for each provider provider_data = [] for provider in providers[:5]: # Limit to top 5 for readability # Get data collection records for this provider collections = db_manager.get_data_collections( provider_id=provider.id, hours=hours, limit=1000 # Get more records for analysis ) if not collections: continue # Group by hour and calculate average staleness staleness_values = [] current_time = start_time for _ in range(len(timestamps)): hour_end = current_time + timedelta(hours=1) # Get records in this hour bucket hour_records = [ c for c in collections if current_time <= c.actual_fetch_time < hour_end ] if hour_records: # Calculate average staleness for this hour staleness_list = [] for record in hour_records: if record.staleness_minutes is not None: staleness_list.append(record.staleness_minutes) elif record.data_timestamp and record.actual_fetch_time: # Calculate staleness if not already stored staleness_seconds = (record.actual_fetch_time - record.data_timestamp).total_seconds() staleness_minutes = staleness_seconds / 60 staleness_list.append(staleness_minutes) if staleness_list: avg_staleness = sum(staleness_list) / len(staleness_list) staleness_values.append(round(avg_staleness, 2)) else: staleness_values.append(0.0) else: # No data for this hour, use null staleness_values.append(None) current_time = hour_end # Only add provider if it has some data if any(v is not None and v > 0 for v in staleness_values): provider_data.append({ "name": provider.name, "staleness_minutes": staleness_values }) return { "timestamps": timestamps, "providers": provider_data } except Exception as e: logger.error(f"Error getting freshness history: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get freshness history: {str(e)}") # ============================================================================ # Health Check Endpoint # ============================================================================ @router.get("/health") async def api_health(): """ API health check endpoint Returns: API health status """ try: # Check database connection db_health = db_manager.health_check() return { "status": "healthy" if db_health['status'] == 'healthy' else "unhealthy", "timestamp": datetime.utcnow().isoformat(), "database": db_health['status'], "version": "1.0.0" } except Exception as e: logger.error(f"Health check failed: {e}", exc_info=True) return { "status": "unhealthy", "timestamp": datetime.utcnow().isoformat(), "error": str(e), "version": "1.0.0" } # ============================================================================ # Initialize Logger # ============================================================================ logger.info("API endpoints module loaded successfully")