Update app.py

app.py

@@ -5,7 +5,7 @@ import os
 from collections import defaultdict
 from datetime import datetime, timezone
 from typing import Dict, List, Optional, Tuple
-
+from time import perf_counter
 from bson import ObjectId
 from dotenv import load_dotenv
 from fastapi import FastAPI, HTTPException
@@ -32,7 +32,11 @@ class MonthlyExpense(BaseModel):
     year: int
     month: int
     total: float = Field(..., description="Total expenses recorded for the month")
-
+    
+class APIResponse(BaseModel):
+    status: str
+    message: str
+    data: Optional[PredictionResponse] = None
 
 class CategoryPrediction(BaseModel):
     headCategoryId: str
@@ -56,6 +60,7 @@ class MongoConnection:
         self._database = self._client.get_default_database()
         self.transactions: Collection = self._database["transactions"]
         self.headcategories: Collection = self._database["headcategories"]
+        self.api_logs: Collection = self._database["api_logs"]
 
 
 mongo = MongoConnection()
@@ -82,6 +87,31 @@ def index_to_month(idx: int) -> Tuple[int, int]:
     year = idx // 12
     month = (idx % 12) + 1
     return year, month
+
+def log_api_event(
+    name: str,
+    status: str,
+    response_time: float,
+    user_id: Optional[str] = None,
+    error_message: Optional[str] = None,
+):
+    payload = {
+        "name": name,
+        "status": status,
+        "response_time": round(response_time, 3),
+        "user_id": user_id or "anonymous",
+        "timestamp": datetime.now(timezone.utc),
+    }
+
+    if error_message:
+        payload["error_message"] = error_message
+
+    try:
+        mongo.api_logs.insert_one(payload)
+    except Exception:
+        # never crash API because of logging
+        pass
+
 # ------------------------------------------------
 
 # ----------------- Time series utilities -----------------
@@ -466,98 +496,145 @@ def _predict_next_month(history: List[MonthlyExpense]) -> float:
 
 
 # ----------------- API endpoint -----------------
-@app.get("/users/{user_id}/expense-prediction", response_model=PredictionResponse)
-def predict_expense(user_id: str) -> PredictionResponse:
+@app.get("/users/{user_id}/expense-prediction",response_model=APIResponse,)
+def predict_expense(user_id: str):
+    start_time = perf_counter()
+
     try:
         user_object_id = ObjectId(user_id)
-    except Exception as exc:
-        raise HTTPException(status_code=400, detail="Invalid user id") from exc
-
-    now = datetime.now(timezone.utc)
-    # fetch up to MAX_HISTORY_MONTHS of history
-    start_period = _shift_months(_first_day_of_month(now), -MAX_HISTORY_MONTHS + 1)
-    prediction_month = _shift_months(_first_day_of_month(now), 1)
-
-    pipeline = [
-        {
-            "$match": {
-                "user": user_object_id,
-                "type": "EXPENSE",
-                "headCategory": {"$ne": None},
-                "date": {"$gte": start_period},
-            }
-        },
-        {
-            "$project": {
-                "amount": 1,
-                "headCategory": 1,
-                "year": {"$year": "$date"},
-                "month": {"$month": "$date"},
-            }
-        },
-        {
-            "$group": {
-                "_id": {
-                    "headCategory": "$headCategory",
-                    "year": "$year",
-                    "month": "$month",
-                },
-                "total": {"$sum": "$amount"},
-            }
-        },
-        {
-            "$lookup": {
-                "from": "headcategories",
-                "localField": "_id.headCategory",
-                "foreignField": "_id",
-                "as": "headCategoryDoc",
-            }
-        },
-        {"$unwind": "$headCategoryDoc"},
-        {"$sort": {"_id.headCategory": 1, "_id.year": 1, "_id.month": 1}},
-    ]
-
-    results = list(mongo.transactions.aggregate(pipeline))
-
-    grouped: Dict[ObjectId, Dict[str, List[MonthlyExpense]]] = defaultdict(lambda: {"history": []})
-
-    for item in results:
-        head_category_id: ObjectId = item["_id"]["headCategory"]
-        category_record = grouped[head_category_id]
-        category_record["title"] = item["headCategoryDoc"].get("title", "Unknown")
-        category_record["history"].append(
-            MonthlyExpense(
-                year=item["_id"]["year"],
-                month=item["_id"]["month"],
-                total=float(item["total"]),
-            )
+    except Exception:
+        log_api_event(
+            name="Expense Prediction",
+            status="failed",
+            response_time=0,
+            user_id=user_id,
+            error_message="Invalid user id",
         )
+        raise HTTPException(status_code=400, detail="Invalid user id")
+
+    try:
+        now = datetime.now(timezone.utc)
+        start_period = _shift_months(_first_day_of_month(now), -MAX_HISTORY_MONTHS + 1)
+        prediction_month = _shift_months(_first_day_of_month(now), 1)
+
+        pipeline = [
+            {
+                "$match": {
+                    "user": user_object_id,
+                    "type": "EXPENSE",
+                    "headCategory": {"$ne": None},
+                    "date": {"$gte": start_period},
+                }
+            },
+            {
+                "$project": {
+                    "amount": 1,
+                    "headCategory": 1,
+                    "year": {"$year": "$date"},
+                    "month": {"$month": "$date"},
+                }
+            },
+            {
+                "$group": {
+                    "_id": {
+                        "headCategory": "$headCategory",
+                        "year": "$year",
+                        "month": "$month",
+                    },
+                    "total": {"$sum": "$amount"},
+                }
+            },
+            {
+                "$lookup": {
+                    "from": "headcategories",
+                    "localField": "_id.headCategory",
+                    "foreignField": "_id",
+                    "as": "headCategoryDoc",
+                }
+            },
+            {"$unwind": "$headCategoryDoc"},
+            {"$sort": {"_id.headCategory": 1, "_id.year": 1, "_id.month": 1}},
+        ]
+
+        results = list(mongo.transactions.aggregate(pipeline))
+
+        grouped: Dict[ObjectId, Dict[str, List[MonthlyExpense]]] = defaultdict(lambda: {"history": []})
+
+        for item in results:
+            head_category_id: ObjectId = item["_id"]["headCategory"]
+            category_record = grouped[head_category_id]
+            category_record["title"] = item["headCategoryDoc"].get("title", "Unknown")
+            category_record["history"].append(
+                MonthlyExpense(
+                    year=item["_id"]["year"],
+                    month=item["_id"]["month"],
+                    total=float(item["total"]),
+                )
+            )
 
-    categories: List[CategoryPrediction] = []
-    for head_category_id, record in grouped.items():
-        history = sorted(record["history"], key=lambda doc: (doc.year, doc.month))
-        predicted_total = _predict_next_month(history)
-
-        categories.append(
-            CategoryPrediction(
-                headCategoryId=str(head_category_id),
-                title=record.get("title", "Unknown"),
-                history=history,
-                predictionMonth=MonthlyExpense(
-                    year=prediction_month.year,
-                    month=prediction_month.month,
-                    total=predicted_total,
-                ),
+        categories: List[CategoryPrediction] = []
+        for head_category_id, record in grouped.items():
+            history = sorted(record["history"], key=lambda doc: (doc.year, doc.month))
+            predicted_total = _predict_next_month(history)
+
+            categories.append(
+                CategoryPrediction(
+                    headCategoryId=str(head_category_id),
+                    title=record.get("title", "Unknown"),
+                    history=history,
+                    predictionMonth=MonthlyExpense(
+                        year=prediction_month.year,
+                        month=prediction_month.month,
+                        total=predicted_total,
+                    ),
+                )
             )
+
+        response_data = PredictionResponse(userId=user_id, categories=categories)
+
+        log_api_event(
+            name="Expense Prediction",
+            status="success",
+            response_time=perf_counter() - start_time,
+            user_id=user_id,
+        )
+
+        return APIResponse(
+            status="success",
+            message="Expense prediction generated successfully",
+            data=response_data,
         )
 
-    return PredictionResponse(userId=user_id, categories=categories)
+    except Exception as exc:
+        log_api_event(
+            name="Expense Prediction",
+            status="failed",
+            response_time=perf_counter() - start_time,
+            user_id=user_id,
+            error_message=str(exc),
+        )
+        raise HTTPException(status_code=500, detail="Internal server error")
 
 
-# Optional: health check
 @app.get("/health")
 def health():
-    return {"status": "healthy"}
+    try:
+        mongo._client.admin.command("ping")
+        return {
+            "status": "ok",
+            "message": "Service is healthy",
+            "timestamp": datetime.now(timezone.utc),
+        }
+    except Exception as exc:
+        raise HTTPException(
+            status_code=503,
+            detail={
+                "status": "down",
+                "message": "Database connectivity failed",
+                "error": str(exc),
+            },
+        )
+