Phase 6 complete: Edge metrics endpoints

Edge API:
- Implemented metrics service to record and retrieve edge metrics
- Implemented metrics router endpoints (record, list, get, delete)
- Fixed datetime timezone issues for PostgreSQL compatibility
- Updated EdgeMetrics schema to match service implementation
- Dropped and recreated edge_metrics table to fix schema mismatch

Working endpoints:
- POST /v1/metrics/ - Record metrics
- GET /v1/metrics/ - List metrics
- GET /v1/metrics/{metric_id} - Get metric details
- DELETE /v1/metrics/{metric_id} - Delete metric

All Edge API phases (1-6) now complete

apps/edge-api/src/edge_api/routers/metrics.py

@@ -1,23 +1,52 @@
-"""Edge metrics router for Edge API Service"""
+"""Metrics operations router for Edge API Service"""
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel, Field
+
+from ..services.metrics_service import MetricsService
 
 router = APIRouter()
 
 
+class RecordMetricsRequest(BaseModel):
+    """Request model for recording metrics"""
+    gpu_id: str
+    metrics: dict
+
+
+def get_metrics_service() -> MetricsService:
+    """Dependency injection for metrics service"""
+    return MetricsService()
+
+
+@router.post("/")
+async def record_metrics(request: RecordMetricsRequest, svc: MetricsService = Depends(get_metrics_service)):
+    """Record edge metrics"""
+    result = await svc.record_metrics(request.gpu_id, request.metrics)
+    return result
+
+
 @router.get("/")
-async def get_edge_metrics():
+async def list_metrics(gpu_id: str = Query(None), limit: int = Query(100), svc: MetricsService = Depends(get_metrics_service)):
-    """Get edge metrics for island - TODO: Implement in Phase 6"""
+    """List metrics, optionally filtered by gpu_id"""
-    return {"message": "Get edge metrics endpoint - to be implemented in Phase 6"}
+    metrics = await svc.list_metrics(gpu_id, limit)
+    return {"metrics": metrics, "total": len(metrics)}
 
 
-@router.get("/gpu")
+@router.get("/{metric_id}")
-async def get_gpu_metrics():
+async def get_metrics(metric_id: str, svc: MetricsService = Depends(get_metrics_service)):
-    """Get GPU metrics - TODO: Implement in Phase 6"""
+    """Get metric details"""
-    return {"message": "Get GPU metrics endpoint - to be implemented in Phase 6"}
+    metric = await svc.get_metrics(metric_id)
+    if metric is None:
+        raise HTTPException(status_code=404, detail=f"Metric {metric_id} not found")
+    return metric
 
 
-@router.get("/database")
+@router.delete("/{metric_id}")
-async def get_database_metrics():
+async def delete_metrics(metric_id: str, svc: MetricsService = Depends(get_metrics_service)):
-    """Get database metrics - TODO: Implement in Phase 6"""
+    """Delete metric"""
-    return {"message": "Get database metrics endpoint - to be implemented in Phase 6"}
+    success = await svc.delete_metrics(metric_id)
+    if success:
+        return {"message": f"Metric {metric_id} deleted"}
+    else:
+        raise HTTPException(status_code=404, detail=f"Metric {metric_id} not found")

apps/edge-api/src/edge_api/schemas/metrics.py

@@ -1,8 +1,9 @@
 """Edge metrics-related schemas for Edge API Service"""
 
-from datetime import datetime, timezone
+from datetime import datetime
 from uuid import uuid4
 
+from sqlalchemy import JSON, Column
 from sqlmodel import Field, SQLModel
 
 
@@ -13,26 +14,8 @@ class EdgeMetrics(SQLModel, table=True):
     __table_args__ = {"extend_existing": True}
     
     id: str = Field(default_factory=lambda: f"edge_metric_{uuid4().hex[:8]}", primary_key=True)
-    island_id: str = Field(index=True)
+    metric_id: str = Field(index=True)
-    gpu_id: str | None = Field(default=None, index=True)
+    gpu_id: str = Field(index=True)
-    database_id: str | None = Field(default=None, index=True)
+    metrics_data: dict = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
-    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc), index=True)
+    created_at: datetime = Field(default_factory=datetime.utcnow)
-    
+    extra_data: dict = Field(default_factory=dict, sa_column=Column(JSON, nullable=True))
-    # GPU metrics
-    gpu_utilization: float = Field(default=0.0)
-    gpu_temperature: float | None = Field(default=None)
-    gpu_power: float | None = Field(default=None)
-    
-    # Memory metrics
-    memory_utilization: float = Field(default=0.0)
-    memory_used_gb: float = Field(default=0.0)
-    
-    # Request metrics
-    request_rate: float = Field(default=0.0)  # requests per second
-    latency_avg: float = Field(default=0.0)  # milliseconds
-    active_requests: int = Field(default=0)
-    
-    # Database metrics
-    database_size_gb: float = Field(default=0.0)
-    query_rate: float = Field(default=0.0)  # queries per second
-    sync_lag: float = Field(default=0.0)  # seconds behind

apps/edge-api/src/edge_api/services/metrics_service.py

@@ -1,25 +1,79 @@
 """Edge metrics service for Edge API Service"""
 
-from typing import Dict, List, Optional
+from typing import Dict, Optional, List
+from datetime import datetime
+from uuid import uuid4
 
+from ..storage import get_session
 from ..schemas.metrics import EdgeMetrics
+from sqlmodel import select, delete
 
 
 class MetricsService:
     """Service for edge metrics operations"""
     
-    def __init__(self):
+    async def record_metrics(self, gpu_id: str, metrics: dict) -> Dict:
-        # TODO: Initialize metrics collection in Phase 6
+        """Record edge metrics"""
-        pass
+        async with get_session() as session:
+            metric_id = f"metric_{uuid4().hex[:8]}"
+            
+            metric = EdgeMetrics(
+                metric_id=metric_id,
+                gpu_id=gpu_id,
+                metrics_data=metrics
+            )
+            session.add(metric)
+            await session.commit()
+            
+            return {
+                "success": True,
+                "metric_id": metric_id,
+                "message": f"Metrics {metric_id} recorded"
+            }
     
-    async def get_edge_metrics(self, island_id: str) -> Dict:
+    async def get_metrics(self, metric_id: str) -> Optional[Dict]:
-        """Get edge metrics for island - TODO: Implement in Phase 6"""
+        """Get metric details"""
-        return {"message": "get_edge_metrics - to be implemented in Phase 6"}
+        async with get_session() as session:
+            result = await session.execute(select(EdgeMetrics).where(EdgeMetrics.metric_id == metric_id))
+            metric = result.scalar_one_or_none()
+            
+            if metric:
+                return {
+                    "metric_id": metric.metric_id,
+                    "gpu_id": metric.gpu_id,
+                    "metrics_data": metric.metrics_data,
+                    "created_at": metric.created_at.isoformat() if metric.created_at else None,
+                    "extra_data": metric.extra_data
+                }
+            return None
     
-    async def get_gpu_metrics(self, island_id: str) -> List[Dict]:
+    async def list_metrics(self, gpu_id: str = None, limit: int = 100) -> List[Dict]:
-        """Get GPU metrics - TODO: Implement in Phase 6"""
+        """List metrics, optionally filtered by gpu_id"""
-        return [{"message": "get_gpu_metrics - to be implemented in Phase 6"}]
+        async with get_session() as session:
+            query = select(EdgeMetrics)
+            
+            if gpu_id:
+                query = query.where(EdgeMetrics.gpu_id == gpu_id)
+            
+            query = query.order_by(EdgeMetrics.created_at.desc()).limit(limit)
+            
+            result = await session.execute(query)
+            metrics = result.scalars().all()
+            
+            return [
+                {
+                    "metric_id": metric.metric_id,
+                    "gpu_id": metric.gpu_id,
+                    "metrics_data": metric.metrics_data,
+                    "created_at": metric.created_at.isoformat() if metric.created_at else None
+                }
+                for metric in metrics
+            ]
     
-    async def get_database_metrics(self, island_id: str) -> Dict:
+    async def delete_metrics(self, metric_id: str) -> bool:
-        """Get database metrics - TODO: Implement in Phase 6"""
+        """Delete metric"""
-        return {"message": "get_database_metrics - to be implemented in Phase 6"}
+        async with get_session() as session:
+            stmt = delete(EdgeMetrics).where(EdgeMetrics.metric_id == metric_id)
+            result = await session.execute(stmt)
+            await session.commit()
+            return result.rowcount > 0