feat(performance): add db operation monitoring to payment and appointment repos

Introduce async context manager to track query execution time and errors
Mark slow operations and log performance metrics for database queries

app/repositories/appointment.py

@@ -1,6 +1,7 @@
 from typing import Tuple, Optional, List, Dict, Union
 from app.models.appointment import appointment_table, Appointment
 from app.core.sql_config import database
+from app.utils.performance_metrics import monitor_db_operation
 from app.utils.database import (
     serialize_appointment,
     validate_query_result,

app/repositories/payment.py

@@ -1,4 +1,5 @@
 from app.core.sql_config import database
+from app.utils.performance_metrics import monitor_db_operation
 from fastapi import HTTPException
 import logging
 

app/utils/performance_metrics.py

@@ -8,6 +8,7 @@ import json
 import logging
 from enum import Enum
 import statistics
+from contextlib import asynccontextmanager
 
 # Configure metrics logger
 metrics_logger = logging.getLogger("performance_metrics")
@@ -175,6 +176,34 @@ class PerformanceMetricsCollector:
         """Record transaction execution time"""
         labels = {"transaction_type": transaction_type}
         self.record_metric(MetricType.TRANSACTION_TIME, transaction_time, labels)
+
+    @asynccontextmanager
+    async def monitor_db_operation(self, query_type: str, table_name: str = "unknown"):
+        """Async context manager to monitor a DB operation.
+
+        Records execution time and errors, marking slow operations.
+
+        Args:
+            query_type: e.g., "SELECT", "INSERT", "UPDATE", "DELETE".
+            table_name: table/collection name for labeling.
+        """
+        start = time.perf_counter()
+        try:
+            yield
+        except Exception as e:
+            # Record error with query type and table name
+            self.record_query_error(query_type=query_type, error_type=type(e).__name__)
+            metrics_logger.error(f"DB {query_type} error on {table_name}: {e}")
+            raise
+        finally:
+            duration = time.perf_counter() - start
+            # Mark as slow if > 1s (tunable threshold)
+            is_slow = duration > 1.0
+            self.record_query_execution(execution_time=duration, query_type=query_type, is_slow=is_slow)
+            metrics_logger.info(
+                f"DB {query_type} on {table_name} took {duration:.3f}s" +
+                (" (slow)" if is_slow else "")
+            )
     
     def get_metric_summary(self, 
                           metric_type: MetricType, 
@@ -376,6 +405,12 @@ def record_transaction_time(transaction_time: float, transaction_type: str = "de
     """Record transaction time metrics"""
     metrics_collector.record_transaction_time(transaction_time, transaction_type)
 
+@asynccontextmanager
+async def monitor_db_operation(query_type: str, table_name: str = "unknown"):
+    """Convenience async context manager that delegates to the global collector."""
+    async with metrics_collector.monitor_db_operation(query_type=query_type, table_name=table_name):
+        yield
+
 
 def get_performance_summary(time_window_minutes: int = 60) -> Dict[str, Any]:
     """Get performance summary"""