sturctured logging

py_backend/app/crud.py

@@ -1,9 +1,12 @@
 import io, hashlib
+import logging
 from typing import Optional, List
 from sqlalchemy.orm import Session, joinedload
 from . import models, schemas
 from fastapi import HTTPException
 
+logger = logging.getLogger(__name__)
+
 def hash_bytes(data: bytes) -> str:
     """Compute SHA-256 hex digest of the data."""
     return hashlib.sha256(data).hexdigest()
@@ -88,10 +91,10 @@ def get_image(db: Session, image_id: str):
     )
 
 def create_caption(db: Session, image_id, title, prompt, model_code, raw_json, text, metadata=None, image_count=None):
-    print(f"Creating caption for image_id: {image_id}")
-    print(f"Caption data: title={title}, prompt={prompt}, model={model_code}")
-    print(f"Database session ID: {id(db)}")
-    print(f"Database session is active: {db.is_active}")
+    logger.debug(f"Creating caption for image_id: {image_id}")
+    logger.debug(f"Caption data: title={title}, prompt={prompt}, model={model_code}")
+    logger.debug(f"Database session ID: {id(db)}")
+    logger.debug(f"Database session is active: {db.is_active}")
     
     if metadata:
         raw_json["extracted_metadata"] = metadata
@@ -122,11 +125,11 @@ def create_caption(db: Session, image_id, title, prompt, model_code, raw_json, t
     # Link caption to image
     img.captions.append(caption)
     
-    print(f"About to commit caption to database...")
+    logger.debug(f"About to commit caption to database...")
     db.commit()
-    print(f"Caption commit successful!")
+    logger.debug(f"Caption commit successful!")
     db.refresh(caption)
-    print(f"Caption created successfully for image: {img.image_id}")
+    logger.info(f"Caption created successfully for image: {img.image_id}")
     return caption
 
 def get_caption(db: Session, caption_id: str):

py_backend/app/database.py

@@ -6,6 +6,8 @@ from sqlalchemy.orm import sessionmaker, declarative_base
 
 from .config import settings
 
+logger = logging.getLogger(__name__)
+
 raw_db_url = settings.DATABASE_URL
 
 if raw_db_url.startswith("psql '") and raw_db_url.endswith("'"):
@@ -18,7 +20,7 @@ if raw_db_url.startswith("postgresql://") and not raw_db_url.startswith("postgre
 if "sslmode=" not in raw_db_url and "localhost" not in raw_db_url and "127.0.0.1" not in raw_db_url:
     raw_db_url = f"{raw_db_url}{'&' if '?' in raw_db_url else '?'}sslmode=require"
 
-print(f"database url: {raw_db_url}")  
+logger.debug(f"database url: {raw_db_url}")  
 
 engine = create_engine(
     raw_db_url,            

py_backend/app/main.py

@@ -1,5 +1,6 @@
 import os
 import subprocess
+import logging
 from datetime import datetime
 from pathlib import Path
 
@@ -13,6 +14,17 @@ from dotenv import load_dotenv
 load_dotenv()
 
 from app.config import settings
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+    ]
+)
+logger = logging.getLogger(__name__)
+
 from app.routers import upload, caption, metadata, models
 from app.routers.images import router as images_router
 from app.routers.prompts import router as prompts_router
@@ -34,9 +46,9 @@ app.add_middleware(GZipMiddleware, minimum_size=500)
 # --------------------------------------------------------------------
 @app.middleware("http")
 async def log_requests(request: Request, call_next):
-    print(f"DEBUG: {request.method} {request.url.path}")
+    logger.debug(f"{request.method} {request.url.path}")
     response = await call_next(request)
-    print(f"DEBUG: {request.method} {request.url.path} -> {response.status_code}")
+    logger.debug(f"{request.method} {request.url.path} -> {response.status_code}")
     return response
 
 # --------------------------------------------------------------------
@@ -155,7 +167,7 @@ CANDIDATES = [
     Path("/app/app") / "static",      # some containers use /app/app
 ]
 STATIC_DIR = next((p for p in CANDIDATES if p.is_dir()), APP_DIR / "static")
-print(f"Serving static from: {STATIC_DIR}")
+logger.info(f"Serving static files from: {STATIC_DIR}")
 
 # --------------------------------------------------------------------
 # Explicit top-level static files
@@ -268,19 +280,19 @@ def spa_fallback(full_path: str):
 def run_migrations():
     """Run database migrations on startup"""
     try:
-        print("Running database migrations...")
+        logger.info("Running database migrations...")
         current_dir = os.getcwd()
-        print(f"Current working directory: {current_dir}")
+        logger.debug(f"Current working directory: {current_dir}")
 
         try:
             result = subprocess.run(["which", "alembic"], capture_output=True, text=True)
-            print(f"Alembic location: {result.stdout.strip() if result.stdout else 'Not found'}")
+            logger.debug(f"Alembic location: {result.stdout.strip() if result.stdout else 'Not found'}")
         except Exception as e:
-            print(f"Could not check alembic location: {e}")
+            logger.debug(f"Could not check alembic location: {e}")
 
-        print(f"Checking if /app exists: {os.path.exists('/app')}")
+        logger.debug(f"Checking if /app exists: {os.path.exists('/app')}")
         if os.path.exists('/app'):
-            print(f"Contents of /app: {os.listdir('/app')}")
+            logger.debug(f"Contents of /app: {os.listdir('/app')}")
 
         alembic_paths = [
             "alembic.ini",
@@ -292,14 +304,14 @@ def run_migrations():
         for path in alembic_paths:
             if os.path.exists(path):
                 alembic_dir = os.path.dirname(path)
-                print(f"Found alembic.ini at: {path}")
+                logger.debug(f"Found alembic.ini at: {path}")
                 break
         if not alembic_dir:
-            print("Could not find alembic.ini - using current directory")
+            logger.warning("Could not find alembic.ini - using current directory")
             alembic_dir = current_dir
 
         try:
-            print(f"Running alembic upgrade head from: {alembic_dir}")
+            logger.info(f"Running alembic upgrade head from: {alembic_dir}")
             result = subprocess.run(
                 ["alembic", "upgrade", "head"],
                 cwd=alembic_dir,
@@ -307,46 +319,46 @@ def run_migrations():
                 text=True,
                 timeout=60,
             )
-            print(f"Alembic return code: {result.returncode}")
-            print(f"Alembic stdout: {result.stdout}")
-            print(f"Alembic stderr: {result.stderr}")
+            logger.debug(f"Alembic return code: {result.returncode}")
+            logger.debug(f"Alembic stdout: {result.stdout}")
+            logger.debug(f"Alembic stderr: {result.stderr}")
 
             if result.returncode == 0:
-                print("Database migrations completed successfully")
+                logger.info("Database migrations completed successfully")
             else:
-                print("Database migrations failed")
-                print("Trying fallback: create tables directly...")
+                logger.error("Database migrations failed")
+                logger.warning("Trying fallback: create tables directly...")
                 try:
                     from app.database import engine
                     from app.models import Base
                     Base.metadata.create_all(bind=engine)
-                    print("Tables created directly via SQLAlchemy")
+                    logger.info("Tables created directly via SQLAlchemy")
                 except Exception as fallback_error:
-                    print(f"Fallback also failed: {fallback_error}")
+                    logger.error(f"Fallback also failed: {fallback_error}")
         except Exception as e:
-            print(f"Error running alembic: {e}")
+            logger.error(f"Error running alembic: {e}")
 
     except Exception as e:
-        print(f"Could not run migrations: {e}")
+        logger.error(f"Could not run migrations: {e}")
 
 def ensure_storage_ready():
     """Ensure storage is ready before starting the app"""
-    print(f"Storage provider from settings: '{settings.STORAGE_PROVIDER}'")
-    print(f"S3 endpoint from settings: '{settings.S3_ENDPOINT}'")
-    print(f"S3 bucket from settings: '{settings.S3_BUCKET}'")
+    logger.debug(f"Storage provider from settings: '{settings.STORAGE_PROVIDER}'")
+    logger.debug(f"S3 endpoint from settings: '{settings.S3_ENDPOINT}'")
+    logger.debug(f"S3 bucket from settings: '{settings.S3_BUCKET}'")
     if settings.STORAGE_PROVIDER == "s3":
         try:
-            print("Checking S3 storage connection...")
+            logger.info("Checking S3 storage connection...")
             from app.storage import _ensure_bucket
             _ensure_bucket()
-            print("S3 storage ready")
+            logger.info("S3 storage ready")
         except Exception as e:
-            print(f"Warning: S3 storage not ready: {e}")
-            print("Storage operations may fail until S3 is available")
+            logger.warning(f"S3 storage not ready: {e}")
+            logger.warning("Storage operations may fail until S3 is available")
     elif settings.STORAGE_PROVIDER == "local":
-        print("Using local storage - no external dependencies")
+        logger.info("Using local storage - no external dependencies")
     else:
-        print(f"Unknown storage provider: {settings.STORAGE_PROVIDER}")
+        logger.warning(f"Unknown storage provider: {settings.STORAGE_PROVIDER}")
 
 # --------------------------------------------------------------------
 # VLM service registration on startup
@@ -367,45 +379,45 @@ import asyncio
 @app.on_event("startup")
 async def startup_tasks() -> None:
     """Run all startup tasks including migrations, storage setup, and VLM service registration."""
-    print("Starting application initialization...")
+    logger.info("Starting application initialization...")
     
     # Run database migrations
-    print("Running database migrations...")
+    logger.info("Running database migrations...")
     run_migrations()
     
     # Ensure storage is ready
-    print("Checking storage...")
+    logger.info("Checking storage...")
     ensure_storage_ready()
     
     # Register VLM services
-    print("Registering VLM services...")
+    logger.info("Registering VLM services...")
 
     # Always have a stub as a safe fallback
     try:
         vlm_manager.register_service(StubVLMService())
-        print("✓ STUB_MODEL registered")
+        logger.info("✓ STUB_MODEL registered")
     except Exception as e:
-        print(f"✗ Failed to register STUB_MODEL: {e}")
+        logger.error(f"✗ Failed to register STUB_MODEL: {e}")
 
     # OpenAI GPT-4V (if configured)
     if settings.OPENAI_API_KEY:
         try:
             vlm_manager.register_service(GPT4VService(settings.OPENAI_API_KEY))
-            print("✓ GPT-4 Vision service registered")
+            logger.info("✓ GPT-4 Vision service registered")
         except Exception as e:
-            print(f"✗ GPT-4 Vision service failed to register: {e}")
+            logger.error(f"✗ GPT-4 Vision service failed to register: {e}")
     else:
-        print("○ GPT-4 Vision not configured (OPENAI_API_KEY missing)")
+        logger.info("○ GPT-4 Vision not configured (OPENAI_API_KEY missing)")
 
     # Google Gemini (if configured)
     if settings.GOOGLE_API_KEY:
         try:
             vlm_manager.register_service(GeminiService(settings.GOOGLE_API_KEY))
-            print("✓ Gemini service registered")
+            logger.info("✓ Gemini service registered")
         except Exception as e:
-            print(f"✗ Gemini service failed to register: {e}")
+            logger.error(f"✗ Gemini service failed to register: {e}")
     else:
-        print("○ Gemini not configured (GOOGLE_API_KEY missing)")
+        logger.info("○ Gemini not configured (GOOGLE_API_KEY missing)")
 
     # Hugging Face Inference Providers (if configured)
     if settings.HF_API_KEY:
@@ -428,35 +440,35 @@ async def startup_tasks() -> None:
                             public_name=m.m_code,  # stable name your UI/DB uses
                         )
                         vlm_manager.register_service(svc)
-                        print(f"✓ HF registered: {m.m_code} -> {m.model_id}")
+                        logger.info(f"✓ HF registered: {m.m_code} -> {m.model_id}")
                         registered += 1
                     except Exception as e:
-                        print(f"✗ HF model {m.m_code} failed to register: {e}")
+                        logger.error(f"✗ HF model {m.m_code} failed to register: {e}")
                 else:
                     skipped += 1
 
             if registered:
-                print(f"✓ Hugging Face services registered: {registered}")
+                logger.info(f"✓ Hugging Face services registered: {registered}")
             else:
-                print("○ No Hugging Face models registered (none found or all skipped)")
+                logger.info("○ No Hugging Face models registered (none found or all skipped)")
             if skipped:
-                print(f"ℹ HF skipped entries: {skipped}")
+                logger.info(f"ℹ HF skipped entries: {skipped}")
         finally:
             db.close()
     else:
-        print("○ Hugging Face not configured (HF_API_KEY missing)")
+        logger.info("○ Hugging Face not configured (HF_API_KEY missing)")
 
-    # Kick off lightweight probes in the background (don’t block startup)
+    # Kick off lightweight probes in the background (don't block startup)
     try:
         asyncio.create_task(vlm_manager.probe_all())
     except Exception as e:
-        print(f"Probe scheduling failed: {e}")
+        logger.error(f"Probe scheduling failed: {e}")
 
-    print(f"✓ Available models now: {', '.join(vlm_manager.get_available_models())}")
-    print(f"✓ Total services: {len(vlm_manager.services)}")
+    logger.info(f"✓ Available models now: {', '.join(vlm_manager.get_available_models())}")
+    logger.info(f"✓ Total services: {len(vlm_manager.services)}")
 
 
-print("PromptAid Vision API server ready")
-print("Endpoints: /api/images, /api/captions, /api/metadata, /api/models")
-print(f"Environment: {settings.ENVIRONMENT}")
-print("CORS: localhost + *.hf.space")
+logger.info("PromptAid Vision API server ready")
+logger.info("Endpoints: /api/images, /api/captions, /api/metadata, /api/models")
+logger.info(f"Environment: {settings.ENVIRONMENT}")
+logger.info("CORS: localhost + *.hf.space")

py_backend/app/routers/caption.py

@@ -2,6 +2,7 @@
 from fastapi import APIRouter, HTTPException, Depends, Form, Request
 from sqlalchemy.orm import Session
 from typing import List
+import logging
 
 from .. import crud, database, schemas, storage
 from ..services.vlm_service import vlm_manager
@@ -9,6 +10,7 @@ from ..services.schema_validator import schema_validator
 from ..config import settings
 
 router = APIRouter()
+logger = logging.getLogger(__name__)
 
 def get_db():
     db = database.SessionLocal()
@@ -28,7 +30,7 @@ async def create_caption(
     model_name: str | None = Form(None),
     db: Session = Depends(get_db),
 ):
-    print(f"DEBUG: Received request - image_id: {image_id}, title: {title}, prompt: {prompt}, model_name: {model_name}")
+    logger.debug(f"Received request - image_id: {image_id}, title: {title}, prompt: {prompt}, model_name: {model_name}")
     
     img = crud.get_image(db, image_id)
     if not img:
@@ -36,24 +38,24 @@ async def create_caption(
 
     # Get the prompt (explicit by code/label, or active for image type)
     if prompt:
-        print(f"Looking for prompt: '{prompt}' (type: {type(prompt)})")
+        logger.debug(f"Looking for prompt: '{prompt}' (type: {type(prompt)})")
         prompt_obj = crud.get_prompt(db, prompt) or crud.get_prompt_by_label(db, prompt)
     else:
-        print(f"Looking for active prompt for image type: {img.image_type}")
+        logger.debug(f"Looking for active prompt for image type: {img.image_type}")
         prompt_obj = crud.get_active_prompt_by_image_type(db, img.image_type)
 
-    print(f"Prompt lookup result: {prompt_obj}")
+    logger.debug(f"Prompt lookup result: {prompt_obj}")
     if not prompt_obj:
         raise HTTPException(400, f"No prompt found (requested: '{prompt}' or active for type '{img.image_type}')")
 
     prompt_text = prompt_obj.label
     metadata_instructions = prompt_obj.metadata_instructions or ""
-    print(f"Using prompt text: '{prompt_text}'")
-    print(f"Using metadata instructions: '{metadata_instructions[:100]}...'")
+    logger.debug(f"Using prompt text: '{prompt_text}'")
+    logger.debug(f"Using metadata instructions: '{metadata_instructions[:100]}...'")
 
     # Load image bytes (S3 or local)
     try:
-        print(f"DEBUG: About to call VLM service with model_name: {model_name}")
+        logger.debug(f"About to call VLM service with model_name: {model_name}")
         if hasattr(storage, 's3') and settings.STORAGE_PROVIDER != "local":
             response = storage.s3.get_object(
                 Bucket=settings.S3_BUCKET,
@@ -66,7 +68,7 @@ async def create_caption(
             with open(file_path, 'rb') as f:
                 img_bytes = f.read()
     except Exception as e:
-        print(f"Error reading image file: {e}")
+        logger.error(f"Error reading image file: {e}")
         # fallback: try presigned/public URL
         try:
             url = storage.get_object_url(img.file_key)
@@ -77,7 +79,7 @@ async def create_caption(
             resp.raise_for_status()
             img_bytes = resp.content
         except Exception as fallback_error:
-            print(f"Fallback also failed: {fallback_error}")
+            logger.error(f"Fallback also failed: {fallback_error}")
             raise HTTPException(500, f"Could not read image file: {e}")
 
     metadata = {}
@@ -90,24 +92,24 @@ async def create_caption(
             db_session=db,
         )
         
-        print(f"DEBUG: VLM service result: {result}")
-        print(f"DEBUG: Result model field: {result.get('model', 'NOT_FOUND')}")
+        logger.debug(f"VLM service result: {result}")
+        logger.debug(f"Result model field: {result.get('model', 'NOT_FOUND')}")
         
         raw = result.get("raw_response", {})
         
         # Validate and clean the data using schema validation
         image_type = img.image_type
-        print(f"DEBUG: Validating data for image type: {image_type}")
-        print(f"DEBUG: Raw data structure: {list(raw.keys()) if isinstance(raw, dict) else 'Not a dict'}")
+        logger.debug(f"Validating data for image type: {image_type}")
+        logger.debug(f"Raw data structure: {list(raw.keys()) if isinstance(raw, dict) else 'Not a dict'}")
         
         cleaned_data, is_valid, validation_error = schema_validator.clean_and_validate_data(raw, image_type)
         
         if is_valid:
-            print(f"✓ Schema validation passed for {image_type}")
+            logger.debug(f"✓ Schema validation passed for {image_type}")
             text = cleaned_data.get("analysis", "")
             metadata = cleaned_data.get("metadata", {})
         else:
-            print(f"⚠ Schema validation failed for {image_type}: {validation_error}")
+            logger.debug(f"⚠ Schema validation failed for {image_type}: {validation_error}")
             text = result.get("caption", "This is a fallback caption due to schema validation error.")
             metadata = result.get("metadata", {})
             raw["validation_error"] = validation_error
@@ -115,7 +117,7 @@ async def create_caption(
         
         used_model = result.get("model", model_name) or "STUB_MODEL"
         if used_model == "random":
-            print(f"WARNING: VLM service returned 'random' as model name, using STUB_MODEL fallback")
+            logger.warning(f"VLM service returned 'random' as model name, using STUB_MODEL fallback")
             used_model = "STUB_MODEL"
         
         # Fallback info (if any)
@@ -127,7 +129,7 @@ async def create_caption(
             }
         
     except Exception as e:
-        print(f"VLM error, using fallback: {e}")
+        logger.warning(f"VLM error, using fallback: {e}")
         text = "This is a fallback caption due to VLM service error."
         used_model = "STUB_MODEL"
         raw = {"error": str(e), "fallback": True}
@@ -145,8 +147,8 @@ async def create_caption(
     )
     
     db.refresh(caption)
-    print(f"DEBUG: Caption created, caption object: {caption}")
-    print(f"DEBUG: caption_id: {caption.caption_id}")
+    logger.debug(f"Caption created, caption object: {caption}")
+    logger.debug(f"caption_id: {caption.caption_id}")
     return schemas.CaptionOut.from_orm(caption)
 
 @router.get(
@@ -158,9 +160,9 @@ def get_all_captions_legacy_format(
     db: Session = Depends(get_db),
 ):
     """Get all images with captions in the old format for backward compatibility"""
-    print(f"DEBUG: Fetching all captions in legacy format...")
+    logger.debug(f"Fetching all captions in legacy format...")
     captions = crud.get_all_captions_with_images(db)
-    print(f"DEBUG: Found {len(captions)} captions")
+    logger.debug(f"Found {len(captions)} captions")
     
     result = []
     for caption in captions:
@@ -170,7 +172,7 @@ def get_all_captions_legacy_format(
                 from .upload import convert_image_to_dict
                 base_url = str(request.base_url).rstrip('/')
                 url = f"{base_url}/api/images/{image.image_id}/file"
-                print(f"DEBUG: Generated image URL: {url}")
+                logger.debug(f"Generated image URL: {url}")
                 img_dict = convert_image_to_dict(image, url)
 
                 # Overlay caption fields (legacy shape)
@@ -190,7 +192,7 @@ def get_all_captions_legacy_format(
                     "updated_at": caption.updated_at,
                 })
                 result.append(schemas.ImageOut(**img_dict))
-    print(f"DEBUG: Returning {len(result)} legacy format results")
+    logger.debug(f"Returning {len(result)} legacy format results")
     return result
 
 @router.get(
@@ -201,16 +203,16 @@ def get_all_captions_with_images(
     db: Session = Depends(get_db),
 ):
     """Get all captions"""
-    print(f"DEBUG: Fetching all captions...")
+    logger.debug(f"Fetching all captions...")
     captions = crud.get_all_captions_with_images(db)
-    print(f"DEBUG: Found {len(captions)} captions")
+    logger.debug(f"Found {len(captions)} captions")
     
     result = []
     for caption in captions:
-        print(f"DEBUG: Processing caption {caption.caption_id}, title: {caption.title}, generated: {caption.generated}, model: {caption.model}")
+        logger.debug(f"Processing caption {caption.caption_id}, title: {caption.title}, generated: {caption.generated}, model: {caption.model}")
         db.refresh(caption)
         result.append(schemas.CaptionOut.from_orm(caption))
-    print(f"DEBUG: Returning {len(result)} formatted results")
+    logger.debug(f"Returning {len(result)} formatted results")
     return result
 
 @router.get(

py_backend/app/routers/images.py

@@ -1,5 +1,6 @@
 import hashlib
 import mimetypes
+import logging
 from fastapi import APIRouter, HTTPException, Depends
 from sqlalchemy.orm import Session
 from sqlalchemy import text
@@ -13,6 +14,7 @@ from ..config import settings
 from ..services.image_preprocessor import ImagePreprocessor
 
 router = APIRouter()
+logger = logging.getLogger(__name__)
 
 def get_db():
     db = SessionLocal()
@@ -24,15 +26,15 @@ def get_db():
 @router.post("/from-url", response_model=CreateImageFromUrlOut)
 async def create_image_from_url(payload: CreateImageFromUrlIn, db: Session = Depends(get_db)):
     try:
-        print(f"DEBUG: Creating contribution from URL: {payload.url}")
-        print(f"DEBUG: Payload: {payload}")
+logger.debug(f"Creating contribution from URL: {payload.url}")
+        logger.debug(f"Payload: {payload}")
         
         # Check database connectivity
         try:
             db.execute(text("SELECT 1"))
-            print("✓ Database connection OK")
+            logger.info("Database connection OK")
         except Exception as db_error:
-            print(f"✗ Database connection failed: {db_error}")
+            logger.error(f"Database connection failed: {db_error}")
             raise HTTPException(status_code=500, detail=f"Database connection failed: {db_error}")
         
         # Check if required tables exist
@@ -41,9 +43,9 @@ async def create_image_from_url(payload: CreateImageFromUrlIn, db: Session = Dep
             db.execute(text("SELECT 1 FROM event_types LIMIT 1")) 
             db.execute(text("SELECT 1 FROM spatial_references LIMIT 1"))
             db.execute(text("SELECT 1 FROM image_types LIMIT 1"))
-            print("✓ Required tables exist")
+            logger.info("Required tables exist")
         except Exception as table_error:
-            print(f"✗ Required tables missing: {table_error}")
+            logger.error(f"Required tables missing: {table_error}")
             raise HTTPException(status_code=500, detail=f"Required tables missing: {table_error}")
         
         if '/api/images/' in payload.url and '/file' in payload.url:
@@ -55,33 +57,33 @@ async def create_image_from_url(payload: CreateImageFromUrlIn, db: Session = Dep
         else:
             raise HTTPException(status_code=400, detail="Invalid image URL format")
         
-        print(f"DEBUG: Extracted image_id: {image_id}")
+        logger.debug(f"Extracted image_id: {image_id}")
         
         existing_image = db.query(Images).filter(Images.image_id == image_id).first()
         if not existing_image:
             raise HTTPException(status_code=404, detail="Source image not found")
         
-        print(f"DEBUG: Found existing image: {existing_image.image_id}")
+        logger.debug(f"Found existing image: {existing_image.image_id}")
         
         try:
             if hasattr(storage, 's3') and settings.STORAGE_PROVIDER != "local":
-                print(f"DEBUG: Using S3 storage, bucket: {settings.S3_BUCKET}")
+                logger.debug(f"Using S3 storage, bucket: {settings.S3_BUCKET}")
                 response = storage.s3.get_object(
                     Bucket=settings.S3_BUCKET,
                     Key=existing_image.file_key,
                 )
                 data = response["Body"].read()
             else:
-                print(f"DEBUG: Using local storage: {settings.STORAGE_DIR}")
+                logger.debug(f"Using local storage: {settings.STORAGE_DIR}")
                 import os
                 file_path = os.path.join(settings.STORAGE_DIR, existing_image.file_key)
                 with open(file_path, 'rb') as f:
                     data = f.read()
             
             content_type = "image/jpeg"
-            print(f"DEBUG: Image data size: {len(data)} bytes")
+            logger.debug(f"Image data size: {len(data)} bytes")
         except Exception as e:
-            print(f"ERROR: Failed to fetch image from storage: {e}")
+            logger.error(f"Failed to fetch image from storage: {e}")
             raise HTTPException(status_code=400, detail=f"Failed to fetch image from storage: {e}")
         
         if len(data) > 25 * 1024 * 1024:
@@ -97,10 +99,10 @@ async def create_image_from_url(payload: CreateImageFromUrlIn, db: Session = Dep
             )
             
             # Log preprocessing info
-            print(f"DEBUG: Image preprocessed: {mime_type} -> {processed_filename}")
+            logger.debug(f"Image preprocessed: {mime_type} -> {processed_filename}")
             
         except Exception as e:
-            print(f"DEBUG: Image preprocessing failed: {str(e)}")
+            logger.debug(f"Image preprocessing failed: {str(e)}")
             # Fall back to original content if preprocessing fails
             processed_data = data
             processed_filename = f"contributed.jpg"
@@ -110,11 +112,11 @@ async def create_image_from_url(payload: CreateImageFromUrlIn, db: Session = Dep
         key = upload_bytes(processed_data, filename=processed_filename, content_type=mime_type)
         image_url = get_object_url(key, expires_in=86400)
         
-        print(f"DEBUG: Uploaded to key: {key}")
-        print(f"DEBUG: Generated URL: {image_url}")
+        logger.debug(f"Uploaded to key: {key}")
+        logger.debug(f"Generated URL: {image_url}")
 
         sha = hashlib.sha256(processed_data).hexdigest()
-        print(f"DEBUG: Generated SHA256: {sha}")
+        logger.debug(f"Generated SHA256: {sha}")
 
         # Set prompt and schema based on image type
         prompt_code = "DEFAULT_CRISIS_MAP"
@@ -166,28 +168,28 @@ async def create_image_from_url(payload: CreateImageFromUrlIn, db: Session = Dep
             std_v_m=payload.std_v_m
         )
         
-        print(f"DEBUG: Created Images object: {img}")
+        logger.debug(f"Created Images object: {img}")
         db.add(img)
         db.flush()
-        print(f"DEBUG: Flushed to database, image_id: {img.image_id}")
+        logger.debug(f"Flushed to database, image_id: {img.image_id}")
 
         for c in payload.countries:
-            print(f"DEBUG: Adding country: {c}")
+            logger.debug(f"Adding country: {c}")
             db.execute(image_countries.insert().values(image_id=img.image_id, c_code=c))
 
-        print(f"DEBUG: About to commit transaction")
+        logger.debug(f"About to commit transaction")
         db.commit()
-        print(f"DEBUG: Transaction committed successfully")
+        logger.debug(f"Transaction committed successfully")
 
         result = CreateImageFromUrlOut(image_id=str(img.image_id), image_url=image_url)
-        print(f"DEBUG: Returning result: {result}")
+        logger.debug(f"Returning result: {result}")
         return result
         
     except Exception as e:
-        print(f"ERROR: Exception in create_image_from_url: {e}")
-        print(f"ERROR: Exception type: {type(e)}")
+        logger.error(f"Exception in create_image_from_url: {e}")
+        logger.error(f"Exception type: {type(e)}")
         import traceback
-        traceback.print_exc()
+        traceback.logger.debug_exc()
         db.rollback()
         raise HTTPException(status_code=500, detail=f"Failed to create image: {str(e)}")
 

py_backend/app/routers/prompts.py

@@ -1,9 +1,11 @@
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 from typing import List
+import logging
 from .. import crud, database, schemas
 
 router = APIRouter()
+logger = logging.getLogger(__name__)
 
 def get_db():
     db = database.SessionLocal()
@@ -15,15 +17,15 @@ def get_db():
 @router.get("/", response_model=List[schemas.PromptOut])
 def get_prompts(db: Session = Depends(get_db)):
     """Get all available prompts"""
-    print("=== get_prompts called ===")
+    logger.debug("get_prompts called")
     try:
         prompts = crud.get_prompts(db)
-        print(f"=== Found {len(prompts)} prompts ===")
+        logger.debug(f"Found {len(prompts)} prompts")
         for prompt in prompts:
-            print(f"  - {prompt.p_code}: {prompt.label} ({prompt.image_type}, active: {prompt.is_active})")
+            logger.debug(f"  - {prompt.p_code}: {prompt.label} ({prompt.image_type}, active: {prompt.is_active})")
         return prompts
     except Exception as e:
-        print(f"=== Error in get_prompts: {e} ===")
+        logger.error(f"Error in get_prompts: {e}")
         raise
 
 @router.post("/", response_model=schemas.PromptOut)

py_backend/app/routers/upload.py

@@ -1,6 +1,7 @@
 from fastapi import APIRouter, UploadFile, Form, Depends, HTTPException, Response
 from pydantic import BaseModel
 import io
+import logging
 from sqlalchemy.orm import Session
 from .. import crud, schemas, storage, database
 from ..config import settings
@@ -13,6 +14,7 @@ import base64
 import datetime
 
 router = APIRouter()
+logger = logging.getLogger(__name__)
 
 class CopyImageRequest(BaseModel):
     source_image_id: str
@@ -49,7 +51,7 @@ def convert_image_to_dict(img, image_url):
         try:
             countries_list = [{"c_code": c.c_code, "label": c.label, "r_code": c.r_code} for c in img.countries]
         except Exception as e:
-            print(f"Warning: Error processing countries for image {img.image_id}: {e}")
+            logger.warning(f"Error processing countries for image {img.image_id}: {e}")
             countries_list = []
     
     captions_list = []
@@ -74,7 +76,7 @@ def convert_image_to_dict(img, image_url):
                 } for c in img.captions
             ]
         except Exception as e:
-            print(f"Warning: Error processing captions for image {img.image_id}: {e}")
+            logger.warning(f"Error processing captions for image {img.image_id}: {e}")
             captions_list = []
     
     # Get starred status and other caption fields from first caption for backward compatibility
@@ -116,13 +118,13 @@ def convert_image_to_dict(img, image_url):
         try:
             thumbnail_url = storage.get_object_url(img.thumbnail_key)
         except Exception as e:
-            print(f"Warning: Error generating thumbnail URL for image {img.image_id}: {e}")
+            logger.warning(f"Error generating thumbnail URL for image {img.image_id}: {e}")
     
     if hasattr(img, 'detail_key') and img.detail_key:
         try:
             detail_url = storage.get_object_url(img.detail_key)
         except Exception as e:
-            print(f"Warning: Error generating detail URL for image {img.image_id}: {e}")
+            logger.warning(f"Error generating detail URL for image {img.image_id}: {e}")
     
     img_dict = {
         "image_id": img.image_id,
@@ -585,7 +587,7 @@ async def upload_image(
         # Log preprocessing info
         preprocessing_info = None
         if processed_filename != file.filename:
-            print(f"Image preprocessed: {file.filename} -> {processed_filename} ({mime_type})")
+            logger.info(f"Image preprocessed: {file.filename} -> {processed_filename} ({mime_type})")
             preprocessing_info = {
                 "original_filename": file.filename,
                 "processed_filename": processed_filename,
@@ -603,7 +605,7 @@ async def upload_image(
             }
         
     except Exception as e:
-        print(f"Image preprocessing failed: {str(e)}")
+        logger.error(f"Image preprocessing failed: {str(e)}")
         # Fall back to original content if preprocessing fails
         processed_content = content
         processed_filename = file.filename
@@ -636,14 +638,14 @@ async def upload_image(
         
         if thumbnail_result:
             thumbnail_key, thumbnail_sha256 = thumbnail_result
-            print(f"Thumbnail generated and uploaded: key={thumbnail_key}, sha256={thumbnail_sha256}")
+            logger.info(f"Thumbnail generated and uploaded: key={thumbnail_key}, sha256={thumbnail_sha256}")
         
         if detail_result:
             detail_key, detail_sha256 = detail_result
-            print(f"Detail version generated and uploaded: key={detail_key}, sha256={detail_sha256}")
+            logger.info(f"Detail version generated and uploaded: key={detail_key}, sha256={detail_sha256}")
             
     except Exception as e:
-        print(f"Image resolution processing failed: {str(e)}")
+        logger.error(f"Image resolution processing failed: {str(e)}")
         # Continue without processed versions if generation fails
 
     try:
@@ -710,7 +712,7 @@ async def upload_image(
         )
         
     except Exception as e:
-        print(f"VLM caption generation failed: {str(e)}")
+        logger.error(f"VLM caption generation failed: {str(e)}")
         # Continue without caption if VLM fails
     
     img_dict = convert_image_to_dict(img, url)
@@ -798,7 +800,7 @@ async def upload_multiple_images(
                 quality=95
             )
         except Exception as e:
-            print(f"Image preprocessing failed: {str(e)}")
+            logger.debug(f"Image preprocessing failed: {str(e)}")
             processed_content = content
             processed_filename = file.filename
             mime_type = 'image/png'
@@ -900,7 +902,7 @@ async def upload_multiple_images(
         db.commit()
         
     except Exception as e:
-        print(f"VLM error: {e}")
+        logger.debug(f"VLM error: {e}")
         # Create fallback caption
         fallback_text = f"Analysis of {len(image_bytes_list)} images"
         caption = crud.create_caption(
@@ -988,52 +990,52 @@ async def copy_image_for_contribution(
 @router.get("/{image_id}/file")
 async def get_image_file(image_id: str, db: Session = Depends(get_db)):
     """Serve the actual image file"""
-    print(f"🔍 Serving image file for image_id: {image_id}")
+    logger.debug(f"Serving image file for image_id: {image_id}")
     
     img = crud.get_image(db, image_id)
     if not img:
-        print(f"❌ Image not found: {image_id}")
+        logger.warning(f"Image not found: {image_id}")
         raise HTTPException(404, "Image not found")
     
-    print(f"✅ Found image: {img.image_id}, file_key: {img.file_key}")
+    logger.debug(f"Found image: {img.image_id}, file_key: {img.file_key}")
     
     try:
         if hasattr(storage, 's3') and settings.STORAGE_PROVIDER != "local":
-            print(f"�� Using S3 storage - serving file content directly")
+            logger.debug(f"Using S3 storage - serving file content directly")
             try:
                 response = storage.s3.get_object(Bucket=settings.S3_BUCKET, Key=img.file_key)
                 content = response['Body'].read()
-                print(f"✅ Read {len(content)} bytes from S3")
+                logger.debug(f"Read {len(content)} bytes from S3")
             except Exception as e:
-                print(f"❌ Failed to get S3 object: {e}")
+                logger.error(f"Failed to get S3 object: {e}")
                 raise HTTPException(500, f"Failed to retrieve image from storage: {e}")
         else:
-            print(f"🔍 Using local storage")
+            logger.debug(f"Using local storage")
             import os
             file_path = os.path.join(settings.STORAGE_DIR, img.file_key)
-            print(f"📁 Reading from: {file_path}")
-            print(f"📁 File exists: {os.path.exists(file_path)}")
+            logger.debug(f"Reading from: {file_path}")
+            logger.debug(f"File exists: {os.path.exists(file_path)}")
             
             if not os.path.exists(file_path):
-                print(f"❌ File not found at: {file_path}")
+                logger.error(f"File not found at: {file_path}")
                 raise FileNotFoundError(f"Image file not found: {file_path}")
             
             with open(file_path, 'rb') as f:
                 content = f.read()
             
-            print(f"✅ Read {len(content)} bytes from file")
+            logger.debug(f"Read {len(content)} bytes from file")
         
         import mimetypes
         content_type, _ = mimetypes.guess_type(img.file_key)
         if not content_type:
             content_type = 'application/octet-stream'
         
-        print(f"✅ Serving image with content-type: {content_type}, size: {len(content)} bytes")
+        logger.debug(f"Serving image with content-type: {content_type}, size: {len(content)} bytes")
         return Response(content=content, media_type=content_type)
     except Exception as e:
-        print(f"❌ Error serving image: {e}")
+        logger.error(f"Error serving image: {e}")
         import traceback
-        print(f"🔍 Full traceback: {traceback.format_exc()}")
+        logger.debug(f"Full traceback: {traceback.format_exc()}")
         raise HTTPException(500, f"Failed to serve image file: {e}")
 
 @router.put("/{image_id}")
@@ -1043,15 +1045,15 @@ def update_image_metadata(
     db: Session = Depends(get_db)
 ):
     """Update image metadata (source, type, epsg, image_type, countries)"""
-    print(f"DEBUG: Updating metadata for image {image_id}")
-    print(f"DEBUG: Metadata received: {metadata}")
+    logger.debug(f"DEBUG: Updating metadata for image {image_id}")
+    logger.debug(f"DEBUG: Metadata received: {metadata}")
     
     img = crud.get_image(db, image_id)
     if not img:
-        print(f"DEBUG: Image {image_id} not found in database")
+        logger.debug(f"DEBUG: Image {image_id} not found in database")
         raise HTTPException(404, "Image not found")
     
-    print(f"DEBUG: Found image {image_id} in database")
+    logger.debug(f"DEBUG: Found image {image_id} in database")
     
     try:
         if metadata.source is not None:
@@ -1103,17 +1105,17 @@ def update_image_metadata(
             img.std_v_m = metadata.std_v_m
         
         if metadata.countries is not None:
-            print(f"DEBUG: Updating countries to: {metadata.countries}")
+            logger.debug(f"DEBUG: Updating countries to: {metadata.countries}")
             img.countries.clear()
             for country_code in metadata.countries:
                 country = crud.get_country(db, country_code)
                 if country:
                     img.countries.append(country)
-                    print(f"DEBUG: Added country: {country_code}")
+                    logger.debug(f"DEBUG: Added country: {country_code}")
         
         db.commit()
         db.refresh(img)
-        print(f"DEBUG: Metadata update successful for image {image_id}")
+        logger.debug(f"DEBUG: Metadata update successful for image {image_id}")
         
         try:
             url = storage.get_object_url(img.file_key)
@@ -1125,7 +1127,7 @@ def update_image_metadata(
         
     except Exception as e:
         db.rollback()
-        print(f"DEBUG: Metadata update failed for image {image_id}: {str(e)}")
+        logger.debug(f"DEBUG: Metadata update failed for image {image_id}: {str(e)}")
         raise HTTPException(500, f"Failed to update image metadata: {str(e)}")
 
 @router.delete("/{image_id}")

py_backend/app/services/gpt4v_service.py

@@ -4,29 +4,32 @@ import openai
 import base64
 import asyncio
 import json
+import logging
+
+logger = logging.getLogger(__name__)
 
 class GPT4VService(VLMService):
     """GPT-4 Vision service implementation"""
     
     def __init__(self, api_key: str):
         super().__init__("GPT4V", ModelType.GPT4V)
-        print(f"[DEBUG] GPT4V Service - Initializing with API key: {api_key[:10]}...{api_key[-4:] if api_key else 'None'}")
+        logger.debug(f"Initializing with API key: {api_key[:10]}...{api_key[-4:] if api_key else 'None'}")
         self.client = openai.OpenAI(api_key=api_key)
         self.model_name = "GPT-4O"
-        print(f"[DEBUG] GPT4V Service - Initialized successfully")
+        logger.info("Initialized successfully")
     
     async def generate_caption(self, image_bytes: bytes, prompt: str, metadata_instructions: str = "") -> Dict[str, Any]:
         """Generate caption using GPT-4 Vision"""
         try:
             # Debug logging
             api_key_preview = self.client.api_key[:10] + "..." + self.client.api_key[-4:] if self.client.api_key else "None"
-            print(f"[DEBUG] GPT4V Service - API Key preview: {api_key_preview}")
-            print(f"[DEBUG] GPT4V Service - Image size: {len(image_bytes)} bytes")
-            print(f"[DEBUG] GPT4V Service - Prompt length: {len(prompt)} chars")
+            logger.debug(f"API Key preview: {api_key_preview}")
+            logger.debug(f"Image size: {len(image_bytes)} bytes")
+            logger.debug(f"Prompt length: {len(prompt)} chars")
             
             image_base64 = base64.b64encode(image_bytes).decode('utf-8')
             
-            print(f"[DEBUG] GPT4V Service - Making API call to OpenAI...")
+            logger.debug(f"Making API call to OpenAI...")
             response = await asyncio.to_thread(
                 self.client.chat.completions.create,
                 model="gpt-4o",
@@ -46,7 +49,7 @@ class GPT4VService(VLMService):
                 ],
                 max_tokens=800
             )
-            print(f"[DEBUG] GPT4V Service - API call successful!")
+            logger.info("API call successful!")
             
             content = response.choices[0].message.content
             
@@ -69,7 +72,7 @@ class GPT4VService(VLMService):
                         try:
                             metadata = json.loads(json_str)
                         except json.JSONDecodeError as e:
-                            print(f"JSON parse error: {e}")
+                            logger.error(f"JSON parse error: {e}")
                 else:
                     import re
                     json_match = re.search(r'\{[^{}]*"metadata"[^{}]*\{[^{}]*\}', content)
@@ -101,11 +104,11 @@ class GPT4VService(VLMService):
             }
             
         except Exception as e:
-            print(f"[DEBUG] GPT4V Service - API call failed: {str(e)}")
-            print(f"[DEBUG] GPT4V Service - Error type: {type(e).__name__}")
+            logger.error(f"API call failed: {str(e)}")
+            logger.error(f"Error type: {type(e).__name__}")
             if hasattr(e, 'response'):
-                print(f"[DEBUG] GPT4V Service - Response status: {getattr(e.response, 'status_code', 'Unknown')}")
-                print(f"[DEBUG] GPT4V Service - Response body: {getattr(e.response, 'text', 'Unknown')}")
+                logger.error(f"Response status: {getattr(e.response, 'status_code', 'Unknown')}")
+                logger.error(f"Response body: {getattr(e.response, 'text', 'Unknown')}")
             raise Exception(f"GPT-4 Vision API error: {str(e)}")
     
     async def generate_multi_image_caption(self, image_bytes_list: List[bytes], prompt: str, metadata_instructions: str = "") -> Dict[str, Any]:
@@ -157,7 +160,7 @@ class GPT4VService(VLMService):
                         try:
                             metadata = json.loads(json_str)
                         except json.JSONDecodeError as e:
-                            print(f"JSON parse error: {e}")
+                            logger.error(f"JSON parse error: {e}")
                 else:
                     import re
                     json_match = re.search(r'\{[^{}]*"metadata"[^{}]*\{[^{}]*\}', content)
@@ -190,9 +193,9 @@ class GPT4VService(VLMService):
             }
             
         except Exception as e:
-            print(f"[DEBUG] GPT4V Service - API call failed: {str(e)}")
-            print(f"[DEBUG] GPT4V Service - Error type: {type(e).__name__}")
+            logger.error(f"API call failed: {str(e)}")
+            logger.error(f"Error type: {type(e).__name__}")
             if hasattr(e, 'response'):
-                print(f"[DEBUG] GPT4V Service - Response status: {getattr(e.response, 'status_code', 'Unknown')}")
-                print(f"[DEBUG] GPT4V Service - Response body: {getattr(e.response, 'text', 'Unknown')}")
+                logger.error(f"Response status: {getattr(e.response, 'status_code', 'Unknown')}")
+                logger.error(f"Response body: {getattr(e.response, 'text', 'Unknown')}")
             raise Exception(f"GPT-4 Vision API error: {str(e)}") 

py_backend/app/services/image_preprocessor.py

@@ -1,8 +1,11 @@
 import io
 import mimetypes
+import logging
 from typing import Tuple, Optional, BinaryIO
 from PIL import Image, ImageOps
 
+logger = logging.getLogger(__name__)
+
 # Import PyMuPDF for PDF processing
 try:
     import fitz  # PyMuPDF for PDF processing
@@ -146,7 +149,7 @@ class ImagePreprocessor:
             ImagePreprocessor.PDF_ZOOM_FACTOR = zoom_factor
             ImagePreprocessor.PDF_COMPRESS_LEVEL = compress_level
         
-        print(f"PDF processing configured: zoom={ImagePreprocessor.PDF_ZOOM_FACTOR}, "
+        logger.debug(f"PDF processing configured: zoom={ImagePreprocessor.PDF_ZOOM_FACTOR}, "
               f"compression={ImagePreprocessor.PDF_COMPRESS_LEVEL}, mode={quality_mode}")
     
     @staticmethod
@@ -161,7 +164,7 @@ class ImagePreprocessor:
             raise ValueError("PDF processing is not available. PyMuPDF is not installed.")
             
         try:
-            print(f"Starting PDF processing for {filename}...")
+            logger.info(f"Starting PDF processing for {filename}...")
             
             # Open PDF with PyMuPDF
             pdf_document = fitz.open(stream=file_content, filetype="pdf")
@@ -169,7 +172,7 @@ class ImagePreprocessor:
             if len(pdf_document) == 0:
                 raise ValueError("PDF has no pages")
             
-            print(f"PDF opened successfully, processing page 1 of {len(pdf_document)}...")
+            logger.debug(f"PDF opened successfully, processing page 1 of {len(pdf_document)}...")
             
             # Get first page
             page = pdf_document[0]
@@ -178,7 +181,7 @@ class ImagePreprocessor:
             zoom = ImagePreprocessor.PDF_ZOOM_FACTOR
             mat = fitz.Matrix(zoom, zoom)
             
-            print(f"Rendering page at {zoom}x zoom...")
+            logger.debug(f"Rendering page at {zoom}x zoom...")
             
             # Render page to image with optimized settings
             pix = page.get_pixmap(
@@ -187,7 +190,7 @@ class ImagePreprocessor:
                 colorspace="rgb"  # Force RGB colorspace
             )
             
-            print(f"Page rendered, size: {pix.width}x{pix.height}")
+            logger.debug(f"Page rendered, size: {pix.width}x{pix.height}")
             
             # Convert to PIL Image - use more efficient method
             img_data = pix.tobytes("png")
@@ -197,7 +200,7 @@ class ImagePreprocessor:
             if img.mode in ('RGBA', 'LA', 'P'):
                 img = img.convert('RGB')
             
-            print(f"Image converted to RGB, mode: {img.mode}")
+            logger.debug(f"Image converted to RGB, mode: {img.mode}")
             
             # Save to bytes with optimization
             output_buffer = io.BytesIO()
@@ -218,12 +221,12 @@ class ImagePreprocessor:
             base_name = os.path.splitext(filename)[0]
             new_filename = f"{base_name}{new_extension}"
             
-            print(f"PDF processing completed: {filename} -> {new_filename}")
+            logger.info(f"PDF processing completed: {filename} -> {new_filename}")
             
             return output_buffer.getvalue(), new_filename, new_mime_type
             
         except Exception as e:
-            print(f"PDF processing failed: {str(e)}")
+            logger.error(f"PDF processing failed: {str(e)}")
             raise ValueError(f"Failed to process PDF: {str(e)}")
     
     @staticmethod

py_backend/app/services/thumbnail_service.py

@@ -1,9 +1,12 @@
 import io
+import logging
 from PIL import Image, ImageOps
 from typing import Tuple, Optional
 import base64
 from ..storage import upload_fileobj, get_object_url
 
+logger = logging.getLogger(__name__)
+
 class ImageProcessingService:
     """Service for creating and managing multiple image resolutions"""
     
@@ -76,7 +79,7 @@ class ImageProcessingService:
             return resized_bytes, resized_filename
             
         except Exception as e:
-            print(f"Error creating resized image: {str(e)}")
+            logger.error(f"Error creating resized image: {str(e)}")
             # Return original content as fallback
             return image_content, filename
     
@@ -153,7 +156,7 @@ class ImageProcessingService:
             return resized_bytes, resized_filename
             
         except Exception as e:
-            print(f"Error creating resized image: {str(e)}")
+            logger.error(f"Error creating resized image: {str(e)}")
             # Return original content as fallback
             return image_content, filename
     
@@ -227,7 +230,7 @@ class ImageProcessingService:
             return resized_key, resized_sha256
             
         except Exception as e:
-            print(f"Error uploading resized image: {str(e)}")
+            logger.error(f"Error uploading resized image: {str(e)}")
             return None
     
     @staticmethod
@@ -278,7 +281,7 @@ class ImageProcessingService:
             return resized_key, resized_sha256
             
         except Exception as e:
-            print(f"Error uploading resized image: {str(e)}")
+            logger.error(f"Error uploading resized image: {str(e)}")
             return None
     
     @staticmethod
@@ -318,7 +321,7 @@ class ImageProcessingService:
             return uploaded_key, sha256
             
         except Exception as e:
-            print(f"Error uploading image bytes: {str(e)}")
+            logger.error(f"Error uploading image bytes: {str(e)}")
             return None
     
     @staticmethod
@@ -357,7 +360,7 @@ class ImageProcessingService:
                 )
                 
         except Exception as e:
-            print(f"Error processing image resolutions: {str(e)}")
+            logger.error(f"Error processing image resolutions: {str(e)}")
         
         return thumbnail_result, detail_result