feat: enhance api_response decorator with improved error handling and logging

app/api/chat_api.py

@@ -1,25 +1,27 @@
 # chat api 
 
 from typing import List
-from fastapi import APIRouter, HTTPException, Depends
+from fastapi import APIRouter, HTTPException, Depends, Request
 from app.schema.chat_schema import ChatCompletionRequest, ChatCompletionResponse, MessageResponse, PlotResponse
 from app.schema.conversation import ConversationResponse, ConversationItemResponse
 from app.service.chat_service import ChatService
 from app.security.auth_service import AuthService
 from app.core.api_response import api_response
-
+from loguru import logger
 
 router = APIRouter(prefix="/v1", tags=["chat"])
 service = ChatService()
 auth_service = AuthService()
 
+
+
 ################
 # chat completion api list
 ################
 # create a chat completion
-@api_response()
 @router.post("/chat/completions", response_model=ChatCompletionResponse)
-async def create_chat_completion(req: ChatCompletionRequest, username: str = Depends(auth_service.verify_credentials)):
+@api_response()
+async def create_chat_completion(chat_completion: ChatCompletionRequest, request: Request, username: str = Depends(auth_service.verify_credentials)):
     """
     Chat completion API - Given a list of messages comprising a conversation, the model will return a response.
     If completion_id is not provided, start a new chat completion by providing a list of messages.
@@ -27,14 +29,15 @@ async def create_chat_completion(req: ChatCompletionRequest, username: str = Dep
     Summary: question -> Send button from chat interface(UI)
     """
     try:
-        return await service.handle_chat_completion(req)
+        return await service.handle_chat_completion(chat_completion)
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 
 # get all chat completions
 @router.get("/chat/completions", response_model=List[ChatCompletionResponse])
-async def list_chat_completions(username: str = Depends(auth_service.verify_credentials)):
+@api_response()
+async def list_chat_completions(request: Request, username: str = Depends(auth_service.verify_credentials)):
     """
     Get all chat completions
     Summary: First load the chat interface(UI) for list of chat completions on the left side.
@@ -52,9 +55,10 @@ async def list_chat_completions(username: str = Depends(auth_service.verify_cred
         raise HTTPException(status_code=500, detail=str(e))
 
 
-# get a chat completion by id
+# get a chat completion by id 
 @router.get("/chat/completions/{completion_id}", response_model=ChatCompletionResponse)
-async def retrieve_chat_completion(completion_id: str, username: str = Depends(auth_service.verify_credentials)):
+@api_response()
+async def retrieve_chat_completion(completion_id: str, request: Request, username: str = Depends(auth_service.verify_credentials)):
     """
     Get a chat completion by id
     Summary: Click on a chat completion on the left side to load the chat completion on the right side.
@@ -65,9 +69,10 @@ async def retrieve_chat_completion(completion_id: str, username: str = Depends(a
         raise HTTPException(status_code=500, detail=str(e))
 
 
-# get all messages for a chat completion
+# get all messages for a chat completion 
 @router.get("/chat/completions/{completion_id}/messages", response_model=List[MessageResponse])
-async def list_messages(completion_id: str, username: str = Depends(auth_service.verify_credentials)):
+@api_response()
+async def list_messages(completion_id: str, request: Request, username: str = Depends(auth_service.verify_credentials)):
     """
     Get all messages for a chat completion
     Summary: Click on a chat completion on the left side to load the chat completion on the right side.
@@ -81,9 +86,10 @@ async def list_messages(completion_id: str, username: str = Depends(auth_service
 ################
 # plot api list
 ################
-# get a plot for a message
+# get a plot for a message 
 @router.get("/chat/completions/{completion_id}/messages/{message_id}/plot", response_model=PlotResponse)
-async def retrieve_plot(completion_id: str, message_id: str, username: str = Depends(auth_service.verify_credentials)):
+@api_response()
+async def retrieve_plot(completion_id: str, message_id: str, request: Request, username: str = Depends(auth_service.verify_credentials)):
     """
     Get a plot figure for a message to visualize the data
     Summary: Click on a message on the right side to load the plot on the right side.
@@ -101,24 +107,35 @@ async def retrieve_plot(completion_id: str, message_id: str, username: str = Dep
 # GET https://chatgpt.com/backend-api/conversations/{completion_id}
 
 
-# get all conversations
-@api_response()
+# get all conversations 
 @router.get("/conversations", response_model=ConversationResponse)
-async def list_conversations(username: str = Depends(auth_service.verify_credentials)):
+@api_response()
+async def list_conversations(request: Request, username: str = Depends(auth_service.verify_credentials)):
     """
     Get all conversations
     """
+    logger.debug(f"Listing conversations for username: {username}")
     try:
-        return await service.find_all_conversations(username)
+        #return await service.find_all_conversations(username)
+        return {
+            "items": [],
+            "total": 0,
+            "limit": 10,
+            "offset": 0
+        }
     except Exception as e:
+        logger.error(f"Error in list_conversations: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
 # get a conversation by id
+
 @router.get("/conversations/{completion_id}", response_model=ConversationItemResponse)
-async def retrieve_conversation(completion_id: str, username: str = Depends(auth_service.verify_credentials)):
+@api_response()
+async def retrieve_conversation(completion_id: str, request: Request, username: str = Depends(auth_service.verify_credentials)):
     """
     Get a conversation by id
     """
+    logger.debug(f"Retrieving conversation with completion_id: {completion_id}")
     try:
         return await service.find_conversation_by_id(completion_id)
     except Exception as e:

app/core/api_response.py

@@ -68,20 +68,39 @@ def get_mock_response(url_path: str, method: str) -> Dict:
 def api_response():
     """Decorator to handle mock/real API responses."""
     def decorator(func):
+        logger.debug(f"BEGIN: decorator: {func}")
         @wraps(func)
         async def wrapper(request: Request, *args, **kwargs):
-            url_path = request.url.path
-            method = request.method
-            logger.debug(f"BEGIN: url_path: {url_path} method: {method}")
+            logger.debug(f"BEGIN: wrapper: {request}")
+            if not request:
+                logger.error("Request object not found in args or kwargs")
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail="Request object not found"
+                )
+
+            logger.debug(f"USE_MOCK value: {USE_MOCK}")
+            logger.debug(f"Request path: {request.url.path}")
+            logger.debug(f"Request method: {request.method}")
+
             if USE_MOCK:
                 logger.warning("Using mock response")
-                result = get_mock_response(url_path, method)
-                logger.trace(f"END: result: {result}")
-                return result
+                try:
+                    result = get_mock_response(request.url.path, request.method)
+                    logger.debug(f"Mock response: {result}")
+                    return result
+                except Exception as e:
+                    logger.error(f"Error getting mock response: {str(e)}")
+                    raise
             else:
-                # Call original function for real response
-                result = await func(request, *args, **kwargs)
-                logger.trace(f"END: result: {result}")
-                return result
+                logger.warning("Using real response")
+                try:
+                    result = await func(*args, **kwargs)
+                    logger.debug(f"Real response: {result}")
+                    return result
+                except Exception as e:
+                    logger.error(f"Error getting real response: {str(e)}")
+                    raise
+
         return wrapper
     return decorator

main.py

@@ -9,8 +9,7 @@ from app.db.client import mongodb
 
 env = Env()
 env.read_env()
-
-USE_MOCK = env.bool("USE_MOCK", False)
+ 
 STORAGE_TYPE = env.str("STORAGE_TYPE", "mongodb")
 
 
@@ -74,6 +73,7 @@ app = FastAPI(
     openapi_url= "/openapi.json",
     lifespan= lifespan,
     openapi_tags= openapi_tags,
+    debug= True,
 )
 
 # Configure OpenAPI security scheme