Update src/database.py

src/database.py

@@ -4,6 +4,7 @@ Database module for handling conversation persistence using Supabase.
 
 import os
 import json
+import logging
 from datetime import datetime
 import requests
 from dotenv import load_dotenv
@@ -11,6 +12,11 @@ from dotenv import load_dotenv
 # Load environment variables
 load_dotenv()
 
+# Set up logging
+logging.basicConfig(level=logging.INFO, 
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger('database')
+
 class SupabaseClient:
     def __init__(self):
         """Initialize Supabase client with credentials from environment variables."""
@@ -18,8 +24,11 @@ class SupabaseClient:
         self.supabase_key = os.getenv('SUPABASE_KEY')
         
         if not self.supabase_url or not self.supabase_key:
+            logger.error("Supabase credentials not found in environment variables")
             raise ValueError("Supabase credentials not found in environment variables. "
                             "Please set SUPABASE_URL and SUPABASE_KEY.")
+        
+        logger.info(f"Initialized Supabase client with URL: {self.supabase_url[:20]}...")
     
     def _make_request(self, method, endpoint, data=None, params=None):
         """Make a request to Supabase API."""
@@ -31,40 +40,65 @@ class SupabaseClient:
             "Prefer": "return=representation"
         }
         
-        if method == "GET":
-            response = requests.get(url, headers=headers, params=params)
-        elif method == "POST":
-            response = requests.post(url, headers=headers, json=data)
-        elif method == "PUT":
-            response = requests.put(url, headers=headers, json=data)
-        elif method == "DELETE":
-            response = requests.delete(url, headers=headers, params=params)
-        else:
-            raise ValueError(f"Unsupported method: {method}")
-        
-        return response
+        logger.debug(f"Making {method} request to {endpoint}")
+        
+        try:
+            if method == "GET":
+                response = requests.get(url, headers=headers, params=params)
+            elif method == "POST":
+                logger.debug(f"POST data: {json.dumps(data)[:500]}...")
+                response = requests.post(url, headers=headers, json=data)
+            elif method == "PUT":
+                response = requests.put(url, headers=headers, json=data)
+            elif method == "DELETE":
+                response = requests.delete(url, headers=headers, params=params)
+            else:
+                raise ValueError(f"Unsupported method: {method}")
+                
+            # Check response status and log appropriately
+            if response.status_code >= 400:
+                logger.error(f"API error: {method} {endpoint} returned {response.status_code}: {response.text}")
+            else:
+                logger.debug(f"API success: {method} {endpoint} returned {response.status_code}")
+                
+            return response
+            
+        except requests.RequestException as e:
+            logger.error(f"Request error: {str(e)}")
+            raise
 
     def create_conversation(self, consultation_id):
         """Create a new conversation record in the database."""
+        logger.info(f"Creating conversation with ID: {consultation_id}")
+        
         data = {
             "consultation_id": consultation_id,
             "created_at": datetime.now().isoformat(),
             "is_active": True
         }
         
-        response = self._make_request(
-            "POST", 
-            "/rest/v1/conversations", 
-            data=data
-        )
-        
-        if response.status_code not in (200, 201):
-            raise Exception(f"Failed to create conversation: {response.text}")
-        
-        return response.json()
+        try:
+            response = self._make_request(
+                "POST", 
+                "/rest/v1/conversations", 
+                data=data
+            )
+            
+            if response.status_code not in (200, 201):
+                logger.error(f"Failed to create conversation: {response.text}")
+                raise Exception(f"Failed to create conversation: {response.text}")
+            
+            logger.info(f"Successfully created conversation: {consultation_id}")
+            return response.json()
+            
+        except Exception as e:
+            logger.error(f"Error creating conversation: {str(e)}")
+            raise
     
     def save_message(self, consultation_id, message):
         """Save a single message to the database."""
+        logger.info(f"Saving message for conversation: {consultation_id}, role: {message.get('role')}")
+        
         # Normalize message format for database storage
         message_data = {
             "consultation_id": consultation_id,
@@ -79,93 +113,149 @@ class SupabaseClient:
         
         if "evidence" in message:
             # Convert evidence to string for storage
-            message_data["evidence"] = json.dumps(message.get("evidence"))
-        
-        response = self._make_request(
-            "POST", 
-            "/rest/v1/messages", 
-            data=message_data
-        )
-        
-        if response.status_code not in (200, 201):
-            raise Exception(f"Failed to save message: {response.text}")
+            try:
+                message_data["evidence"] = json.dumps(message.get("evidence"))
+            except Exception as e:
+                logger.error(f"Error serializing evidence: {str(e)}")
+                message_data["evidence"] = "[]"
         
-        return response.json()
+        try:
+            # First verify that the consultation_id exists
+            verify_params = {"consultation_id": f"eq.{consultation_id}"}
+            verify_response = self._make_request("GET", "/rest/v1/conversations", params=verify_params)
+            
+            if verify_response.status_code != 200 or len(verify_response.json()) == 0:
+                logger.error(f"Conversation {consultation_id} not found, creating it first")
+                self.create_conversation(consultation_id)
+            
+            # Now save the message
+            response = self._make_request(
+                "POST", 
+                "/rest/v1/messages", 
+                data=message_data
+            )
+            
+            if response.status_code not in (200, 201):
+                logger.error(f"Failed to save message: {response.text}")
+                raise Exception(f"Failed to save message: {response.text}")
+            
+            logger.info(f"Successfully saved message for conversation: {consultation_id}")
+            return response.json()
+            
+        except Exception as e:
+            logger.error(f"Error saving message: {str(e)}")
+            raise
     
     def get_conversation_history(self, consultation_id):
         """Retrieve full conversation history for a given consultation ID."""
+        logger.info(f"Retrieving conversation history for: {consultation_id}")
+        
         params = {
             "consultation_id": f"eq.{consultation_id}",
             "order": "timestamp.asc"
         }
         
-        response = self._make_request(
-            "GET", 
-            "/rest/v1/messages", 
-            params=params
-        )
-        
-        if response.status_code != 200:
-            raise Exception(f"Failed to retrieve conversation history: {response.text}")
-        
-        # Convert database format back to application format
-        messages = response.json()
-        history = []
-        
-        for msg in messages:
-            message_dict = {
-                "role": msg["role"],
-                "content": msg["content"]
-            }
+        try:
+            response = self._make_request(
+                "GET", 
+                "/rest/v1/messages", 
+                params=params
+            )
             
-            if msg.get("explanation"):
-                message_dict["explanation"] = msg["explanation"]
+            if response.status_code != 200:
+                logger.error(f"Failed to retrieve conversation history: {response.text}")
+                raise Exception(f"Failed to retrieve conversation history: {response.text}")
             
-            if msg.get("evidence"):
-                # Parse evidence JSON string back to object
-                try:
-                    message_dict["evidence"] = json.loads(msg["evidence"])
-                except:
-                    message_dict["evidence"] = []
+            # Convert database format back to application format
+            messages = response.json()
+            history = []
             
-            history.append(message_dict)
-        
-        return history
+            logger.info(f"Retrieved {len(messages)} messages for conversation: {consultation_id}")
+            
+            for msg in messages:
+                message_dict = {
+                    "role": msg["role"],
+                    "content": msg["content"]
+                }
+                
+                if msg.get("explanation"):
+                    message_dict["explanation"] = msg["explanation"]
+                
+                if msg.get("evidence"):
+                    # Parse evidence JSON string back to object
+                    try:
+                        message_dict["evidence"] = json.loads(msg["evidence"])
+                    except:
+                        message_dict["evidence"] = []
+                
+                history.append(message_dict)
+            
+            return history
+            
+        except Exception as e:
+            logger.error(f"Error retrieving conversation history: {str(e)}")
+            raise
     
     def delete_conversation(self, consultation_id):
         """Delete a completed conversation from the database."""
-        # First delete all messages
-        msg_params = {"consultation_id": f"eq.{consultation_id}"}
-        self._make_request("DELETE", "/rest/v1/messages", params=msg_params)
-        
-        # Then delete conversation record
-        conv_params = {"consultation_id": f"eq.{consultation_id}"}
-        response = self._make_request("DELETE", "/rest/v1/conversations", params=conv_params)
-        
-        if response.status_code != 200:
-            raise Exception(f"Failed to delete conversation: {response.text}")
+        logger.info(f"Deleting conversation: {consultation_id}")
         
-        return True
+        try:
+            # First delete all messages
+            msg_params = {"consultation_id": f"eq.{consultation_id}"}
+            msg_response = self._make_request("DELETE", "/rest/v1/messages", params=msg_params)
+            
+            if msg_response.status_code != 200:
+                logger.warning(f"Failed to delete messages for conversation {consultation_id}: {msg_response.text}")
+            
+            # Then delete conversation record
+            conv_params = {"consultation_id": f"eq.{consultation_id}"}
+            response = self._make_request("DELETE", "/rest/v1/conversations", params=conv_params)
+            
+            if response.status_code != 200:
+                logger.error(f"Failed to delete conversation: {response.text}")
+                raise Exception(f"Failed to delete conversation: {response.text}")
+            
+            logger.info(f"Successfully deleted conversation: {consultation_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error deleting conversation: {str(e)}")
+            raise
         
     def get_active_conversations(self):
         """Get list of active conversations."""
+        logger.info("Retrieving active conversations")
+        
         params = {
             "is_active": "eq.true",
             "order": "created_at.desc"
         }
         
-        response = self._make_request(
-            "GET", 
-            "/rest/v1/conversations", 
-            params=params
-        )
-        
-        if response.status_code != 200:
-            raise Exception(f"Failed to retrieve active conversations: {response.text}")
-        
-        return response.json()
+        try:
+            response = self._make_request(
+                "GET", 
+                "/rest/v1/conversations", 
+                params=params
+            )
+            
+            if response.status_code != 200:
+                logger.error(f"Failed to retrieve active conversations: {response.text}")
+                raise Exception(f"Failed to retrieve active conversations: {response.text}")
+            
+            conversations = response.json()
+            logger.info(f"Retrieved {len(conversations)} active conversations")
+            return conversations
+            
+        except Exception as e:
+            logger.error(f"Error retrieving active conversations: {str(e)}")
+            raise
 
 # Initialize database client
 def get_db_client():
     """Get database client instance."""
-    return SupabaseClient() 
+    try:
+        return SupabaseClient()
+    except Exception as e:
+        logger.error(f"Error initializing database client: {str(e)}")
+        raise