Add logging functionality to app.py and blob_utils.py for improved traceability and debugging

app.py

@@ -19,10 +19,14 @@ from utils import (
 )
 from flagging import HuggingFaceDatasetSaver
 from blob_utils import decode_blob_data, is_blob_data
+from logging_config import get_logger
 
 import install_private_repos  # noqa: F401
 from seavision import load_model
 
+# Get loggers
+logger = get_logger()
+
 
 TITLE = """
 <h1> 🌊 SEA.AI's Vision Demo ✨ </h1>
@@ -48,6 +52,8 @@ h1 {
 }
 """
 
+# Load model
+logger.info("Loading detection model...")
 model = load_model("experimental/ahoy6-MIX-1280-b1.onnx")
 model.det_conf_thresh = 0.1
 model.hor_conf_thresh = 0.1
@@ -56,18 +62,24 @@ model.hor_conf_thresh = 0.1
 # @spaces.GPU
 def inference(image):
     """Run inference on image and return annotated image."""
+    logger.debug("Running inference on image")
     results = model(image)
+    logger.debug("Inference completed")
     return results.draw(image)
 
 
 def flag_img_input(
     image: gr.Image, flag_option: str = "misdetection", username: str = "anonymous"
 ):
-    """Wrapper for flagging"""    
+    """Wrapper for flagging"""
+    logger.info("Flagging image - option: %s, user: %s", flag_option, username)
+
     # Decode blob data if necessary
     if is_blob_data(image):
         image = decode_blob_data(image)
+
     hf_writer.flag([image], flag_option=flag_option, username=username)
+    logger.info("Image flagged successfully")
 
 
 # Flagging

blob_utils.py

@@ -6,6 +6,10 @@ Handles conversion of blob data to proper image file formats.
 import hashlib
 import os
 from typing import Dict, Any
+from logging_config import get_logger
+
+# Module logger
+logger = get_logger("blob_utils")
 
 
 class BlobConverter:
@@ -86,35 +90,35 @@ class BlobConverter:
         if not cls.is_blob_data(image_data):
             return image_data
 
-        print(f"DEBUG: Converting blob data: {image_data}")
+        logger.info("Converting blob data: %s", image_data)
 
         blob_path = image_data["path"]
-        print(f"DEBUG: Blob path: {blob_path}")
+        logger.debug("Blob path: %s", blob_path)
 
         # Read blob content
         with open(blob_path, "rb") as f:
             content = f.read()
 
         file_size = len(content)
-        print(f"DEBUG: File size: {file_size}")
+        logger.debug("File size: %d bytes", file_size)
 
         # Detect format
         extension, mime_type = cls.detect_format(content)
-        print(f"DEBUG: Detected format: {extension}, MIME type: {mime_type}")
+        logger.debug("Detected format: %s, MIME type: %s", extension, mime_type)
 
         # Generate filename and path
         filename = cls.generate_filename(content, extension)
         temp_dir = os.path.dirname(blob_path)
         new_path = os.path.join(temp_dir, filename)
 
-        print(f"DEBUG: Generated filename: {filename}")
-        print(f"DEBUG: New path: {new_path}")
+        logger.debug("Generated filename: %s", filename)
+        logger.debug("New path: %s", new_path)
 
         # Write converted file
         with open(new_path, "wb") as f:
             f.write(content)
 
-        print(f"DEBUG: Successfully converted blob to: {new_path}")
+        logger.info("Successfully converted blob to: %s", new_path)
 
         # Return updated image data
         converted_data = {
@@ -127,7 +131,7 @@ class BlobConverter:
             "meta": image_data.get("meta", {}),
         }
 
-        print(f"DEBUG: Converted data: {converted_data}")
+        logger.debug("Converted data: %s", converted_data)
         return converted_data
 
 
@@ -141,14 +145,14 @@ def decode_blob_data(image_data: Dict[str, Any]) -> Dict[str, Any]:
     Returns:
         Converted image data or original data if not a blob
     """
-    print(f"DEBUG: Original input - image: {image_data}")
+    logger.debug("Processing image data: %s", image_data)
 
     result = BlobConverter.convert_blob(image_data)
 
     if result is image_data:
-        print("DEBUG: Not a blob, skipping conversion")
+        logger.debug("Not a blob, skipping conversion")
     else:
-        print("DEBUG: Blob conversion completed")
+        logger.info("Blob conversion completed")
 
     return result
 

logging_config.py

@@ -0,0 +1,84 @@
+"""
+Logging configuration for the detection demo application.
+Provides centralized logging setup with proper formatting and levels.
+"""
+
+import logging
+import sys
+from pathlib import Path
+
+
+class LoggerManager:
+    """Singleton logger manager for the application."""
+
+    _instance = None
+    _initialized = False
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not self._initialized:
+            self._setup_default_logging()
+            self._initialized = True
+
+    def _setup_default_logging(self):
+        """Setup default logging configuration."""
+        # Create main logger
+        self.logger = logging.getLogger("detection-demo")
+        self.logger.setLevel(logging.INFO)
+
+        # Prevent duplicate handlers
+        if self.logger.handlers:
+            return
+
+        # Console handler
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setLevel(logging.INFO)
+        console_formatter = logging.Formatter(
+            fmt="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            datefmt="%H:%M:%S",
+        )
+        console_handler.setFormatter(console_formatter)
+        self.logger.addHandler(console_handler)
+
+        # File handler (logs/app.log)
+        log_file = Path("logs/app.log")
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(logging.DEBUG)
+        file_formatter = logging.Formatter(
+            fmt="%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+        file_handler.setFormatter(file_formatter)
+        self.logger.addHandler(file_handler)
+
+    def get_logger(self, name: str = None) -> logging.Logger:
+        """Get a logger instance."""
+        if name:
+            return logging.getLogger(f"detection-demo.{name}")
+        return self.logger
+
+
+# Global logger manager instance
+_logger_manager = LoggerManager()
+
+
+def get_logger(name: str = None) -> logging.Logger:
+    """
+    Get a logger instance for the application.
+
+    Args:
+        name: Optional module name (will be prefixed with app name)
+
+    Returns:
+        Logger instance
+    """
+    return _logger_manager.get_logger(name)
+
+
+# Module-level logger
+logger = get_logger(__name__)