Add comprehensive logging to the application

app.py

@@ -8,8 +8,10 @@ from chainlit.prompt import Prompt, PromptMessage  # importing prompt tools
 from chainlit.playground.providers import ChatOpenAI  # importing ChatOpenAI tools
 from dotenv import load_dotenv
 from prompt_manager import PromptManager
+from logger_config import logger
 
 load_dotenv()
+logger.info("Environment variables loaded")
 
 # Initialize prompt manager
 prompt_manager = PromptManager()
@@ -128,6 +130,7 @@ USER_TEMPLATES = {
 
 @cl.on_chat_start
 async def start_chat():
+    logger.info("Starting new chat session")
     # Create aspect selection buttons with descriptions
     aspects = prompt_manager.get_aspect_names()
     actions = []
@@ -147,6 +150,7 @@ async def start_chat():
         content="Welcome! Please select an aspect for our conversation. Hover over each option to see examples and descriptions:",
         actions=actions
     ).send()
+    logger.info("Welcome message sent with aspect selection buttons")
 
 @cl.action_callback("Concept Simplification")
 @cl.action_callback("Summarization")
@@ -157,16 +161,20 @@ async def start_chat():
 async def on_action(action):
     # Store the selected aspect in the user session
     cl.user_session.set("selected_aspect", action.value)
+    logger.info(f"User selected aspect: {action.value}")
     
     # Send confirmation message with examples
     await cl.Message(
         content=prompt_manager.get_confirmation_message(action.value)
     ).send()
+    logger.debug(f"Confirmation message sent for aspect: {action.value}")
 
 @cl.on_message
 async def main(message: cl.Message):
     # Get the selected aspect from the session
     selected_aspect = cl.user_session.get("selected_aspect")
+    logger.info(f"Processing message with aspect: {selected_aspect}")
+    logger.debug(f"User message: {message.content}")
     
     settings = {
         "model": "gpt-4-turbo-preview",  # Upgraded to GPT-4 Turbo
@@ -176,11 +184,13 @@ async def main(message: cl.Message):
         "frequency_penalty": 0.3,  # Added to reduce repetition
         "presence_penalty": 0.3,  # Added to encourage diverse topics
     }
+    logger.debug(f"OpenAI settings: {settings}")
 
     client = AsyncOpenAI()
 
     # Get the appropriate templates for the selected aspect
     system_template, user_template = prompt_manager.get_templates(selected_aspect)
+    logger.debug("Templates retrieved for message processing")
 
     prompt = Prompt(
         provider=ChatOpenAI.id,
@@ -199,21 +209,30 @@ async def main(message: cl.Message):
         inputs={"input": message.content},
         settings=settings,
     )
+    logger.debug("Prompt created for OpenAI API call")
 
     msg = cl.Message(content="")
-
-    # Call OpenAI
-    async for stream_resp in await client.chat.completions.create(
-        messages=[m.to_openai() for m in prompt.messages], stream=True, **settings
-    ):
-        token = stream_resp.choices[0].delta.content
-        if not token:
-            token = ""
-        await msg.stream_token(token)
-
-    # Update the prompt object with the completion
-    prompt.completion = msg.content
-    msg.prompt = prompt
-
-    # Send and close the message stream
-    await msg.send()
+    logger.info("Starting OpenAI API call")
+
+    try:
+        # Call OpenAI
+        async for stream_resp in await client.chat.completions.create(
+            messages=[m.to_openai() for m in prompt.messages], stream=True, **settings
+        ):
+            token = stream_resp.choices[0].delta.content
+            if not token:
+                token = ""
+            await msg.stream_token(token)
+        
+        # Update the prompt object with the completion
+        prompt.completion = msg.content
+        msg.prompt = prompt
+
+        # Send and close the message stream
+        await msg.send()
+        logger.info("Response successfully sent to user")
+    except Exception as e:
+        logger.error(f"Error during OpenAI API call: {str(e)}")
+        await cl.Message(
+            content="I apologize, but I encountered an error processing your request. Please try again."
+        ).send()

logger_config.py

@@ -0,0 +1,38 @@
+import logging
+import os
+from datetime import datetime
+
+# Create logs directory if it doesn't exist
+os.makedirs("logs", exist_ok=True)
+
+# Configure logging
+def setup_logger():
+    # Create a logger
+    logger = logging.getLogger("chainlit_chatbot")
+    logger.setLevel(logging.INFO)
+    
+    # Create handlers
+    # Console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+    
+    # File handler - log to file with timestamp
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    file_handler = logging.FileHandler(f"logs/chatbot_{timestamp}.log")
+    file_handler.setLevel(logging.DEBUG)
+    
+    # Create formatters and add it to handlers
+    console_format = logging.Formatter('%(levelname)s - %(message)s')
+    file_format = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    
+    console_handler.setFormatter(console_format)
+    file_handler.setFormatter(file_format)
+    
+    # Add handlers to the logger
+    logger.addHandler(console_handler)
+    logger.addHandler(file_handler)
+    
+    return logger
+
+# Create and export the logger
+logger = setup_logger() 

prompt_manager.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from typing import Dict, List
+from logger_config import logger
 
 @dataclass
 class AspectInfo:
@@ -10,6 +11,7 @@ class AspectInfo:
 
 class PromptManager:
     def __init__(self):
+        logger.info("Initializing PromptManager")
         # Default template for when no aspect is selected
         self.default_aspect = AspectInfo(
             description="General purpose AI assistant with balanced capabilities",
@@ -24,6 +26,7 @@ Adapt your communication style based on the user's needs and the complexity of t
             user_template="""{input}
 Think through your response step by step."""
         )
+        logger.debug("Default aspect template created")
 
         self.aspects = {
             "Concept Simplification": AspectInfo(
@@ -117,22 +120,27 @@ Adapt your communication style to match the user's level of expertise.""",
 - How does this relate to everyday experience?"""
             )
         }
+        logger.info(f"Initialized {len(self.aspects)} aspects")
 
     def get_aspect_names(self) -> List[str]:
         """Get list of available aspect names."""
+        logger.debug("Getting aspect names")
         return list(self.aspects.keys())
 
     def get_aspect_info(self, aspect_name: str) -> AspectInfo:
         """Get information for a specific aspect."""
+        logger.debug(f"Getting aspect info for: {aspect_name}")
         return self.aspects.get(aspect_name, self.default_aspect)
 
     def get_action_description(self, aspect_name: str) -> str:
         """Get formatted description for action button."""
+        logger.debug(f"Getting action description for: {aspect_name}")
         info = self.aspects[aspect_name]
         return f"{info.description}\n\nExample tasks:\n" + "\n".join(f"• {example}" for example in info.examples)
 
     def get_confirmation_message(self, aspect_name: str) -> str:
         """Get formatted confirmation message for selected aspect."""
+        logger.debug(f"Getting confirmation message for: {aspect_name}")
         info = self.aspects[aspect_name]
         examples = "\n".join(f"• {example}" for example in info.examples[:2])
         return f"""You've selected: {aspect_name}
@@ -145,7 +153,9 @@ Try asking something like:
     def get_templates(self, aspect_name: str | None) -> tuple[str, str]:
         """Get system and user templates for an aspect."""
         if aspect_name is None:
+            logger.info("No aspect selected, using default template")
             info = self.default_aspect
         else:
+            logger.info(f"Using templates for aspect: {aspect_name}")
             info = self.aspects.get(aspect_name, self.default_aspect)
         return info.system_template, info.user_template