improved logging

app.py

@@ -82,9 +82,13 @@
 import gradio as gr
 import asyncio
 from rasa_socketio_client import RasaSocketIOClient
-from custom_logging import get_logger
+import logging
+import custom_logging
+
+# Obtain a logger for this module
+logger = logging.getLogger("gradio_app")
+logger.important(f"Logger handlers: {logger.handlers}")
 
-logger = get_logger(__name__)
 rasa_io_url = "https://clairify.ai/socket.io"
 theme = gr.themes.Default(primary_hue="cyan", secondary_hue="violet")
 
@@ -107,6 +111,7 @@ with gr.Blocks(theme=theme) as demo:
             else:
                 new_entry = (None, message.get('text', ''))
             chat_history.append(new_entry)
+            logger.important(f"Latest chat history: {chat_history}")
             yield "", chat_history
 
     async def handle_clear_button():

custom_logging.py

@@ -1,16 +1,58 @@
 import logging
+import time
 
+# Define a new logging level
 IMPORTANT_LEVEL_NUM = 25
 logging.addLevelName(IMPORTANT_LEVEL_NUM, "IMPORTANT")
 
 def important(self, message, *args, **kws):
     if self.isEnabledFor(IMPORTANT_LEVEL_NUM):
+        # Use _log directly with the custom level
         self._log(IMPORTANT_LEVEL_NUM, message, args, **kws)
 
+# Patch the Logger class with the new method
 logging.Logger.important = important
 
-logging.basicConfig(level=IMPORTANT_LEVEL_NUM, format='%(asctime)s - %(levelname)s - %(message)s')
+class CustomFormatter(logging.Formatter):
+    def formatTime(self, record, datefmt=None):
+        # Custom time format: Human-readable + Unix time with milliseconds
+        local_time = time.strftime('%b-%d %I:%M:%S %p', time.localtime(record.created))
+        unix_time_with_milliseconds = f"{record.created:.3f}"
+        return f"{local_time} ({unix_time_with_milliseconds})"
+
+    # Initializing with a format that includes the logger name, level, and message
+    def __init__(self, fmt="%(asctime)s - %(name)s - %(levelname)s - %(message)s"):
+        super().__init__(fmt)
+
+def configure_logging():
+    # Configure the root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(IMPORTANT_LEVEL_NUM)  # Only log IMPORTANT and above
+
+    # Clear existing handlers (if re-running this configuration in notebooks, etc.)
+    root_logger.handlers = []
+
+    # Create and set the formatter
+    formatter = CustomFormatter()
+
+    # Create a console handler using the formatter
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    console_handler.setLevel(IMPORTANT_LEVEL_NUM)
+
+    # Add the console handler to the root logger
+    root_logger.addHandler(console_handler)
+
+    # Disable propagation for all loggers created with getLogger()
+    root_logger.propagate = False
+
+# Call the function to configure logging
+configure_logging()
+
+# Example usage
+logger = logging.getLogger(__name__)
+logger.important("This is an important message.")
+logger.info("This info message should not appear.")
+
 
-def get_logger(name):
-    return logging.getLogger(name)
 

rasa_socketio_client.py

@@ -93,13 +93,16 @@
 
 import asyncio
 import socketio
-from custom_logging import get_logger
+import logging
+import custom_logging
 
-logger = get_logger(__name__)
+
+# Obtain a logger for this module
+logger = logging.getLogger(__name__)
 
 class RasaSocketIOClient:
     def __init__(self, uri, update_chat_history_callback=None):
-        self.sio = socketio.AsyncClient(logger=True, engineio_logger=True)
+        self.sio = socketio.AsyncClient(logger=False, engineio_logger=False)
         self.uri = uri
         self.message_queue = asyncio.Queue()
         self.register_event_handlers()
@@ -129,18 +132,21 @@ class RasaSocketIOClient:
         try:
             await self.sio.emit('user_uttered', {'message': user_message})
             logger.important(f"Message sent: {user_message}")
-            timeout = 2.0  # Timeout in seconds after the last message is received
+            timeout = 5.0  # Timeout in seconds after the last message is received
             while True:
                 try:
                     data = await asyncio.wait_for(self.message_queue.get(), timeout)
+                    logger.important(f"Message in queue: {user_message}")
                     yield data
                 except asyncio.TimeoutError:
+                    logger.important(f"send_message function timed out")
                     break
         except Exception as e:
             logger.error(f"Failed to send message: {e}")
 
     async def disconnect(self):
         try:
+            logger.important(f"Attempting to disconnect: {id(self.sio)}")
             await self.sio.disconnect()
             logger.important("Disconnected from the server.")
         except Exception as e: