core lib integration

Dockerfile

@@ -15,7 +15,9 @@ USER user
 WORKDIR /app
 
 COPY --chown=user ./requirements.txt requirements.txt
+COPY --chown=user ./app/insightfy_utils-0.1.0-py3-none-any.whl insightfy_utils-0.1.0-py3-none-any.whl
 RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir insightfy_utils-0.1.0-py3-none-any.whl && \
     pip install --no-cache-dir --upgrade -r requirements.txt
 
 COPY --chown=user . /app

app/app.py

@@ -1,16 +1,23 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
+from insightfy_utils.logging import setup_logging, get_logger
+from insightfy_utils.telemetry import check_service_health
+
 from app.routers.catalogue_router import router as catalogue_router
 from app.routers.supplier_route import router as supplier_router
 from app.routers.taxonomy_route import router as taxonomy_router
 from app.routers.promotion_router import router as promotion_router
 from app.routers.gift_card_router import router as gift_card_router
 
+# Setup logging at module level
+setup_logging(level="INFO", format_type="json", app_name="insightfy-bloom-ms-ems")
+logger = get_logger(__name__)
+
 # Initialize FastAPI application
 app = FastAPI(
-    title="Entity Managment API",
+    title="Entity Management API",
     version="1.0",
-    description="Entity Managment API for Suppliers, Products and Services",
+    description="Entity Management API for Suppliers, Products and Services",
 )
 
 # CORS configuration
@@ -62,7 +69,16 @@ async def health_check():
     """
     Health check endpoint to verify the API is running.
     """
-    return {"message": "Resource Managment API is up and running!"}
+    return {"message": "Entity Management API is up and running!", "version": "1.0"}
+
+# Health check endpoint with service status
+@app.get("/health", tags=["Health"])
+async def health():
+    """
+    Health check endpoint with service dependency status.
+    """
+    # TODO: Pass actual db connectors once migrated
+    return {"status": "healthy", "service": "insightfy-bloom-ms-ems", "version": "1.0"}
 
 # Ensure database connection is started/stopped with FastAPI lifecycle
 from app.sql import connect_to_database, disconnect_from_database
@@ -70,7 +86,9 @@ from app.sql import connect_to_database, disconnect_from_database
 @app.on_event("startup")
 async def startup():
     await connect_to_database()
+    logger.info("Application started successfully")
 
 @app.on_event("shutdown")
 async def shutdown():
-    await disconnect_from_database()
+    await disconnect_from_database()
+    logger.info("Application shutdown complete")

app/dependencies/auth.py

@@ -1,13 +1,16 @@
-import logging
 from fastapi import Depends, HTTPException, status
 from enum import Enum
-from app.utils.jwt import decode_jwt_token
+from insightfy_utils.auth import JWTHandler
+from insightfy_utils.logging import get_logger
 from settings import SECRET_KEY, ALGORITHM
 from fastapi.security import APIKeyHeader
 from app.nosql import mongo_db
 
-# Logger setup (consistent with project)
-logger = logging.getLogger(__name__)
+# Logger setup (migrated to insightfy-utils)
+logger = get_logger(__name__)
+
+# Initialize JWT handler
+jwt_handler = JWTHandler(secret=SECRET_KEY, algorithm=ALGORITHM)
 
 # AccessID Enum for permission strings
 class AccessID(str, Enum):
@@ -50,16 +53,22 @@ def get_current_user(token: str = Depends(oauth2_scheme)) -> dict:
     try:
         if token.startswith("Bearer "):
             token = token.split(" ")[1]
-        payload = decode_jwt_token(token)
-        logger.info(f"Authenticated user {payload.get('associate_id')} for merchant {payload.get('merchant_id')}")
+        payload = jwt_handler.decode_token(token)
+        logger.info(
+            "Authenticated user",
+            extra={
+                "associate_id": payload.get('associate_id'),
+                "merchant_id": payload.get('merchant_id')
+            }
+        )
         return {
             "associate_id": payload["associate_id"],
             "merchant_id": payload["merchant_id"],
-            "branch_id":payload["branch_id"],
+            "branch_id": payload["branch_id"],
             "role_id": payload.get("role_id", "user")
         }
     except Exception as e:
-        logger.warning(f"Authentication failed: {str(e)}")
+        logger.warning("Authentication failed", extra={"error": str(e)})
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail="Invalid authentication credentials",
@@ -69,49 +78,72 @@ def get_current_user(token: str = Depends(oauth2_scheme)) -> dict:
 async def user_has_permission(merchant_id: str, role_id: str, permission: str) -> bool:
     """
     Check if the user has the required permission using MongoDB filtering.
-    permission format: RESOURCE:ACTION (e.g., appointments:create)
     """
     try:
-        # Support both 'RESOURCE:ACTION' and 'ACTION_RESOURCE' formats
         if "_" in permission:
             parts = permission.split("_", 1)
             if len(parts) == 2:
                 action, resource = parts
             else:
-                logger.warning(f"Permission format invalid: {permission}")
+                logger.warning("Permission format invalid", extra={"permission": permission})
                 return False
+        else:
+            logger.warning("Permission format invalid", extra={"permission": permission})
+            return False
+            
         query = {
             "merchant_id": merchant_id,
             "role_id": role_id,
             f"permissions.{resource}": action
         }
-        print(query,"queryyy")
+        logger.debug("Permission query", extra={"query": query})
         role_doc = await mongo_db["access_roles"].find_one(query)
         has_perm = role_doc is not None
-        logger.info(f"Permission check for role {role_id}, merchant {merchant_id}, permission {permission}: {has_perm}")
+        logger.info(
+            "Permission check result",
+            extra={
+                "role_id": role_id,
+                "merchant_id": merchant_id,
+                "permission": permission,
+                "has_permission": has_perm
+            }
+        )
         return has_perm
     except Exception as e:
-        logger.error(f"Permission check error: {str(e)}")
+        logger.error("Permission check error", extra={"error": str(e)}, exc_info=e)
         return False
 
-# Reusable FastAPI dependency for permission checks
-async def require_permission(
+async def require_permission_dependency(
     access_id: str,
     current_user: dict = Depends(get_current_user)
 ) -> dict:
     """
     Dependency to check user permission for a given access_id (permission string).
-    Raises HTTPException(403) if not permitted.
-    Returns current_user if permitted.
+    Renamed to avoid conflict with insightfy_utils.auth.require_permission
     """
     merchant_id = current_user.get("merchant_id")
     user_id = current_user.get("associate_id")
     role_id = current_user.get("role_id")
+    
     if not user_id or not merchant_id or not role_id:
-        logger.warning(f"Permission denied: missing user/merchant/role info for user {user_id}")
+        logger.warning(
+            "Permission denied: missing user info",
+            extra={"user_id": user_id, "merchant_id": merchant_id, "role_id": role_id}
+        )
         raise HTTPException(status_code=403, detail="Forbidden")
+    
     if not await user_has_permission(merchant_id, role_id, access_id):
-        logger.warning(f"Permission denied for user {user_id} on {access_id}")
+        logger.warning(
+            "Permission denied",
+            extra={"user_id": user_id, "access_id": access_id}
+        )
         raise HTTPException(status_code=403, detail="Forbidden")
-    logger.info(f"Permission granted for user {user_id} on {access_id}")
-    return current_user
+    
+    logger.info(
+        "Permission granted",
+        extra={"user_id": user_id, "access_id": access_id}
+    )
+    return current_user
+
+# Backward compatibility alias
+require_permission = require_permission_dependency

app/models/catalogue_models.py

@@ -1,4 +1,3 @@
-import logging
 import re
 from typing import Any, Dict, List, Optional, Union
 import uuid
@@ -6,6 +5,7 @@ from bson import ObjectId
 from fastapi import HTTPException
 from pydantic import ValidationError
 from sqlalchemy import func, update
+from insightfy_utils.logging import get_logger
 from app.constants.collections import CATALOGUES_COLLECTION
 from app.repositories.db import db, fetch_documents, fetch_pos_documents, fetch_many_aggregate
 from app.repositories.inventory_repository import fetch_stock_by_catalogue_ids
@@ -16,8 +16,8 @@ from app.utils.info_widget_utils import build_aggregation_pipeline_for_widget
 from app.sql import async_session
 from sqlalchemy.exc import SQLAlchemyError
 from app.schemas.inventory_schema import branch_inventory
-# Configure logging for this module
-logger = logging.getLogger(__name__)
+
+logger = get_logger(__name__)
 
 # Constants for aggregation pipeline stages
 CATEGORY_FIELD = "$category"
@@ -30,31 +30,19 @@ class CatalogueModel:
     @staticmethod
     async def create_catalogue_item(data: Dict[str, Any]) -> str:
         try:
-            # Generate a UUID for associate_id
-            catalogue_id = str(uuid.uuid4())  # Generates a random UUID
-            
-            data['catalogue_id'] = catalogue_id  # 
+            catalogue_id = str(uuid.uuid4())
+            data['catalogue_id'] = catalogue_id
             data = convert_dates(data)
-
-            # Insert data into MongoDB collection
             result = await db['catalogues'].insert_one(data)
-            
-            # Extract the inserted ID and convert to string
             catalogue_inserted_id = str(result.inserted_id)
-            
-            # Log success for traceability
-            logger.info(f"Catalogue item created successfully with ID: {catalogue_inserted_id}")
-            
+            logger.info("Catalogue item created", extra={"catalogue_id": catalogue_inserted_id})
             return catalogue_inserted_id
         except Exception as e:
-            # Log the error with stack trace for debugging
-            logger.error(f"Error creating Catalogue item: {e}", exc_info=True)
-            
-            # Raise a more specific error with a custom message
+            logger.error("Error creating Catalogue item", exc_info=e)
             raise RuntimeError("Failed to create Catalogue item") from e
         
     @staticmethod
-    async def update_catalogue_data(catalogue_id: str, update_fields: dict,merchant_id:str) -> bool:
+    async def update_catalogue_data(catalogue_id: str, update_fields: dict, merchant_id: str) -> bool:
         try:
             existing_doc = await db['catalogues'].find_one(
                 {"catalogue_id": catalogue_id, "merchant_id": merchant_id}
@@ -66,29 +54,15 @@ class CatalogueModel:
                 {"catalogue_id": catalogue_id, "merchant_id": merchant_id},
                 {"$set": update_fields}
             )
-            
             return result.modified_count > 0
         except RuntimeError as e:
-            logger.error(f"Error updating catalogue data: {e}", exc_info=True)
+            logger.error("Error updating catalogue data", exc_info=e)
             raise RuntimeError("Failed to update catalogue data") from e
 
     @staticmethod
-    async def list_items(filter_criteria: Dict[str, Any], offset: int, limit: int, projection_list: Union[List[str], None] = None,branch_id=None) -> Dict[str, Any]:
-        """
-        Fetches a paginated list of catalogue items based on filter criteria.
-
-        Args:
-            filter_criteria (Dict[str, Any]): Criteria to filter the items.
-            offset (int): Number of items to skip for pagination.
-            limit (int): Maximum number of items to return.
-
-        Returns:
-            Dict[str, Any]: A dictionary containing the list of items and metadata.
-
-        Raises:
-            RuntimeError: If the operation fails.
-        """
-        logger.info(f"Fetching catalogue items with criteria={filter_criteria}, offset={offset}, limit={limit}")
+    async def list_items(filter_criteria: Dict[str, Any], offset: int, limit: int, projection_list: Union[List[str], None] = None, branch_id=None) -> Dict[str, Any]:
+        """Fetches a paginated list of catalogue items based on filter criteria."""
+        logger.info("Fetching catalogue items", extra={"criteria": filter_criteria, "offset": offset, "limit": limit})
         try:
             projection = None
             if projection_list:
@@ -99,61 +73,35 @@ class CatalogueModel:
             items_data = raw_items.get("documents", [])
 
             catalogue_ids = [item.get("catalogue_id") for item in items_data if item.get("catalogue_id")]
-            stock_map = await fetch_stock_by_catalogue_ids(filter_criteria
-                                                           ["merchant_id"],branch_id, catalogue_ids) if branch_id else {}
-
+            stock_map = await fetch_stock_by_catalogue_ids(filter_criteria["merchant_id"], branch_id, catalogue_ids) if branch_id else {}
 
             parsed_items = []
             for item in items_data:
-                # Inject current stock from Postgres if exists
                 if item.get("catalogue_id") in stock_map:
                     item.update(stock_map[item["catalogue_id"]])
                 try:
                     parsed_items.append(item)
                 except ValidationError as e:
-                    logger.warning(f"Failed to parse item: {item}, error: {e}")
+                    logger.warning("Failed to parse item", extra={"item": item, "error": str(e)})
 
-            logger.debug(f"Fetched and parsed {len(parsed_items)} items")
+            logger.debug("Fetched and parsed items", extra={"count": len(parsed_items)})
             return {
                 "total": raw_items.get("total", len(parsed_items)),
                 "items": parsed_items
             }
-
         except Exception as e:
-            logger.error(f"Error listing catalogue items: {e}", exc_info=True)
+            logger.error("Error listing catalogue items", exc_info=e)
             raise RuntimeError("Failed to list catalogue items") from e
 
     @staticmethod
-    async def pos_items(
-        filter_criteria: Dict[str, Any], fields: Optional[Dict[str, int]] = None,branch_id=None) -> List[Dict[str, Any]]:
-        """
-        Fetches POS catalogue items with optional projection fields.
-
-        Args:
-            filter_criteria (Dict[str, Any]): Criteria to filter the items.
-            fields (Optional[Dict[str, int]]): Projection fields for MongoDB query.
-
-        Returns:
-            List[Dict[str, Any]]: A list of POS-specific catalogue items.
-        """
-
+    async def pos_items(filter_criteria: Dict[str, Any], fields: Optional[Dict[str, int]] = None, branch_id=None) -> List[Dict[str, Any]]:
+        """Fetches POS catalogue items with optional projection fields."""
         try:
             items = await fetch_pos_documents("catalogues", filter_criteria, fields)
-            '''
-            Commented because we are not fetching stock information for POS items
-            
-            catalogue_ids = [item.get("catalogue_id") for item in items if item.get("catalogue_id")]
-            stock_map = await fetch_stock_by_catalogue_ids(branch_id, catalogue_ids) if branch_id else {}
-
-            for item in items:
-                if item.get("catalogue_id") in stock_map:
-                    item.update(stock_map[item["catalogue_id"]])
-            '''
-            logger.info(f"Fetched {len(items)} POS items")
+            logger.info("Fetched POS items", extra={"count": len(items)})
             return items
-
         except Exception as e:
-            logger.error(f"Error fetching POS catalogue items: {e}", exc_info=True)
+            logger.error("Error fetching POS catalogue items", exc_info=e)
             raise RuntimeError("Failed to fetch POS items") from e
 
     @staticmethod
@@ -290,97 +238,43 @@ class CatalogueModel:
         filter_criteria: Dict[str, Any],
         branch_id: Optional[str] = None
     ) -> Dict[str, Any]:
-        """
-        Optimized aggregation pipeline for POS catalogue items.
-        
-        Performance improvements:
-        - Database-level grouping and sorting
-        - Reduced memory usage
-        - Optimized field projection
-        - Single query execution
-        """
+        """Optimized aggregation pipeline for POS catalogue items."""
         try:
-            # Build and execute aggregation pipeline
             pipeline = CatalogueModel._build_pos_aggregation_pipeline(filter_criteria)
             result = await fetch_many_aggregate(CATALOGUES_COLLECTION, pipeline)
             
             if not result:
-                return {
-                    "favorites": [],
-                    "categories": [],
-                    "catalogues": {}
-                }
+                return {"favorites": [], "categories": [], "catalogues": {}}
 
-            # Process aggregation result
             response_data = CatalogueModel._process_aggregation_result(result[0])
-
-            # Integrate stock data if branch_id provided
-            # if branch_id:
-            #     await CatalogueModel._integrate_stock_data(response_data, branch_id)
-            
-            
             return response_data
-
         except Exception as e:
-            logger.error(f"Error in POS aggregation: {e}", exc_info=True)
+            logger.error("Error in POS aggregation", exc_info=e)
             raise RuntimeError("Failed to aggregate POS items") from e
 
-        
     @staticmethod
     async def delete_item(filter_criteria: dict) -> bool:
-        """
-        Deletes a catalogue item by its ID.
-
-        Args:
-            item_id (str): The ID of the item to delete.
-
-        Returns:
-            bool: True if the deletion was successful, False otherwise.
-
-        Raises:
-            ValueError: If the item_id is invalid.
-            RuntimeError: If the operation fails.
-        """
-        logger.info(f"Deleting catalogue item with ID: {filter_criteria}")
-        
-        # Validate item_id format
-        # if not re.fullmatch(r"[0-9a-fA-F]{24}", filter_criteria["catalogue_id"]):
-        #     raise HTTPException(status_code=400, detail="Invalid ObjectId format")
-        
-
+        """Deletes a catalogue item by its ID."""
+        logger.info("Deleting catalogue item", extra={"filter": filter_criteria})
         try:
-            # Perform the delete operation
             result = await db["catalogues"].delete_one(filter_criteria)
             deleted = result.deleted_count > 0
-
             if deleted:
-                logger.debug(f"Catalogue item {filter_criteria} deleted successfully.")
+                logger.debug("Catalogue item deleted", extra={"filter": filter_criteria})
             else:
-                logger.debug(f"Catalogue item {filter_criteria} not found.")
-            
+                logger.debug("Catalogue item not found", extra={"filter": filter_criteria})
             return deleted
         except Exception as e:
-            logger.error(f"Error deleting catalogue item: {e}", exc_info=True)
+            logger.error("Error deleting catalogue item", exc_info=e)
             raise RuntimeError("Failed to delete item") from e
 
     @staticmethod
     async def catalogue_list_items(filter_criteria: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Fetches a paginated list of catalogue items based on filter criteria.
-
-        Args:
-            filter_criteria (Dict[str, Any]): Criteria to filter the items.
-
-        Returns:
-            Dict[str, Any]: A dictionary containing the list of items and metadata.
-
-        Raises:
-            RuntimeError: If the operation fails.
-        """
-        logger.info(f"Fetching catalogue items with criteria={filter_criteria}")
+        """Fetches a paginated list of catalogue items based on filter criteria."""
+        logger.info("Fetching catalogue items", extra={"criteria": filter_criteria})
         try:
             raw_items = await fetch_documents("catalogues", filter_criteria, None, 0, 1000)
-            logger.info(f"Raw items: {raw_items}")
+            logger.info("Raw items fetched", extra={"raw_items": raw_items})
             items_data = raw_items.get("documents", [])
 
             parsed_items = []
@@ -388,16 +282,12 @@ class CatalogueModel:
                 try:
                     parsed_items.append(InventoryInfo(**item))
                 except ValidationError as e:
-                    logger.warning(f"Failed to parse item: {item}, error: {e}")
-
-            logger.debug(f"Fetched and parsed {len(parsed_items)} items")
-            return {
-                "items": [i.dict() for i in parsed_items],
-                "count": len(parsed_items)
-            }
+                    logger.warning("Failed to parse item", extra={"item": item, "error": str(e)})
 
+            logger.debug("Fetched and parsed items", extra={"count": len(parsed_items)})
+            return {"items": [i.dict() for i in parsed_items], "count": len(parsed_items)}
         except Exception as e:
-            logger.error(f"Error listing catalogue items: {e}", exc_info=True)
+            logger.error("Error listing catalogue items", exc_info=e)
             raise RuntimeError("Failed to list items") from e
         
     @staticmethod
@@ -412,73 +302,52 @@ class CatalogueModel:
                             branch_inventory.c.branch_id == filter_criteria.get("branch_id"),
                             branch_inventory.c.catalogue_id == filter_criteria.get("catalogue_id")
                         )
-                        .values(**update_fields, updated_at=func.now())  
+                        .values(**update_fields, updated_at=func.now())
                     )
                     result = await session.execute(stmt)
-                    return result.rowcount > 0  
-
+                    return result.rowcount > 0
         except Exception as e:
-            logging.error(f"Error updating catalogue inventory: {e}", exc_info=True)
+            logger.error("Error updating catalogue inventory", exc_info=e)
             raise RuntimeError("Failed to update catalogue inventory") from e
 
-
-        
     @staticmethod
     async def get_catalogue_data(catalogue_id: str, merchant_id: str):
         try:
-            filter_criteria = {
-                "catalogue_id": catalogue_id,
-                "merchant_id": merchant_id,
-            }
-                
-            logger.info(f"Fetching catalogue with ID: {filter_criteria}")
+            filter_criteria = {"catalogue_id": catalogue_id, "merchant_id": merchant_id}
+            logger.info("Fetching catalogue", extra={"filter": filter_criteria})
             catalogue_data = await db['catalogues'].find_one(filter_criteria)
             if catalogue_data:
-                logger.info(f"catalogue item {catalogue_id} fetched successfully.")
+                logger.info("Catalogue fetched", extra={"catalogue_id": catalogue_id})
                 return catalogue_utils.sanitize_document_for_mongo(catalogue_data)
             else:
-                logger.info(f"catalogue item {catalogue_id} not found.")
-                return None 
-        except Exception as e:      
-            logger.error(f"Error fetching catalogue data: {e}", exc_info=True)
+                logger.info("Catalogue not found", extra={"catalogue_id": catalogue_id})
+                return None
+        except Exception as e:
+            logger.error("Error fetching catalogue data", exc_info=e)
             raise RuntimeError("Failed to fetch catalogue data") from e
 
     @staticmethod
     async def bulk_insert(items: list[dict]) -> int:
-        result_items = []
-        for item in items:
-            result_items.append(convert_dates(item))
+        result_items = [convert_dates(item) for item in items]
         result = await db['catalogues'].insert_many(result_items)
         return len(result.inserted_ids)
     
     @staticmethod
     async def bulk_create(catalogues: List[dict]):
-        # Example using MongoDB
-
         serialized_docs = [sanitize_document_for_mongo(doc) for doc in catalogues]
         result = await db["catalogues"].insert_many(serialized_docs)
         return result.inserted_ids
     
     @staticmethod
-    async def get_info_widget_data(
-        merchant_id: str,
-        branch_id: str,   # <-- ADD THIS
-        user_pref: dict
-    ) -> Dict[str, Any]:
+    async def get_info_widget_data(merchant_id: str, branch_id: str, user_pref: dict) -> Dict[str, Any]:
         try:
-
-            # Safely handle user_pref being None
             widgets = user_pref.get("widgets", []) if user_pref else []
             results = {}
 
             for widget in widgets:
                 widget_type = widget.get("type")
-
-
-
                 pipeline, post_process = build_aggregation_pipeline_for_widget(widget, merchant_id, branch_id)
-
-                logger.info(f"Executing pipeline for widget {widget_type}: {pipeline}")
+                logger.info("Executing pipeline for widget", extra={"widget_type": widget_type, "pipeline": pipeline})
                 if pipeline:
                     data = await fetch_many_aggregate(CATALOGUES_COLLECTION, pipeline)
                     results[widget_type] = post_process(data) if post_process else data
@@ -486,7 +355,6 @@ class CatalogueModel:
                     results[widget_type] = post_process([]) if post_process else []
 
             return results
-
         except Exception as e:
-            logger.error(f"Error fetching catalogue data: {e}", exc_info=True)
+            logger.error("Error fetching catalogue data", exc_info=e)
             raise RuntimeError("Failed to fetch catalogue data") from e

app/models/gift_card_models.py

@@ -1,15 +1,13 @@
-import logging
 import uuid
 from typing import Any, Dict, List, Optional
 from datetime import datetime, timezone
 from bson import ObjectId
 from fastapi import HTTPException
+from insightfy_utils.logging import get_logger
 from app.repositories.db import db
 
-# Configure logging for this module
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
-# Collection name
 GIFT_CARD_TEMPLATES_COLLECTION = "gift_card_templates"
 
 class GiftCardTemplateModel:
@@ -19,7 +17,7 @@ class GiftCardTemplateModel:
     """
 
     @staticmethod
-    async def create_template(data: Dict[str, Any],merchant_id:str) -> str:
+    async def create_template(data: Dict[str, Any], merchant_id: str) -> str:
         """
         Create a new gift card template.
         
@@ -32,27 +30,20 @@ class GiftCardTemplateModel:
         Raises:
             RuntimeError: If the creation fails
         """
-       
-        # Generate unique template ID
         template_id = f"tpl_{str(uuid.uuid4())[:8]}"
         data['_id'] = template_id
-        data['issued_count'] = 0  # Initialize issued count
+        data['issued_count'] = 0
         data['created_at'] = datetime.now(timezone.utc)
         data['updated_at'] = None
         
-        #Check if name already exists for this merchant
         existing = await db.gift_card_templates.find_one(
-            { "name": data["name"], "merchant_id": merchant_id}
+            {"name": data["name"], "merchant_id": merchant_id}
         )
         if existing:
             raise HTTPException(status_code=400, detail="Gift card template with this name already exists.")
         
-        # Insert data into MongoDB collection
         await db[GIFT_CARD_TEMPLATES_COLLECTION].insert_one(data)
-        
-        # Log success for traceability
-        logger.info(f"Gift card template created successfully with ID: {template_id}")
-        
+        logger.info("Gift card template created", extra={"template_id": template_id})
         return template_id
 
     @staticmethod
@@ -73,22 +64,16 @@ class GiftCardTemplateModel:
             Dict[str, Any]: Dictionary containing templates and total count
         """
         try:
-            # Get total count
             total = await db[GIFT_CARD_TEMPLATES_COLLECTION].count_documents(filter_criteria)
-            
-            # Get paginated documents
             cursor = db[GIFT_CARD_TEMPLATES_COLLECTION].find(filter_criteria)
             cursor = cursor.skip(offset).limit(limit).sort("created_at", -1)
-            
             templates = await cursor.to_list(length=limit)
             
-            # Convert ObjectId to string for JSON serialization
             for template in templates:
                 if isinstance(template.get('_id'), ObjectId):
                     template['_id'] = str(template['_id'])
             
-            logger.info(f"Retrieved {len(templates)} gift card templates")
-            
+            logger.info("Retrieved gift card templates", extra={"count": len(templates)})
             return {
                 "templates": templates,
                 "total": total,
@@ -96,7 +81,7 @@ class GiftCardTemplateModel:
                 "limit": limit
             }
         except Exception as e:
-            logger.error(f"Error retrieving gift card templates: {e}", exc_info=True)
+            logger.error("Error retrieving gift card templates", exc_info=e)
             raise RuntimeError("Failed to retrieve gift card templates") from e
 
     @staticmethod
@@ -114,17 +99,15 @@ class GiftCardTemplateModel:
             template = await db[GIFT_CARD_TEMPLATES_COLLECTION].find_one({"_id": template_id})
             
             if template:
-                # Convert ObjectId to string for JSON serialization
                 if isinstance(template.get('_id'), ObjectId):
                     template['_id'] = str(template['_id'])
-                
-                logger.info(f"Gift card template {template_id} retrieved successfully")
+                logger.info("Gift card template retrieved", extra={"template_id": template_id})
             else:
-                logger.info(f"Gift card template {template_id} not found")
+                logger.info("Gift card template not found", extra={"template_id": template_id})
             
             return template
         except Exception as e:
-            logger.error(f"Error retrieving gift card template {template_id}: {e}", exc_info=True)
+            logger.error("Error retrieving gift card template", extra={"template_id": template_id}, exc_info=e)
             raise RuntimeError("Failed to retrieve gift card template") from e
 
     @staticmethod
@@ -140,32 +123,27 @@ class GiftCardTemplateModel:
             bool: True if the update was successful, False otherwise
         """
         try:
-            # Check if template exists
             existing_template = await db[GIFT_CARD_TEMPLATES_COLLECTION].find_one({"_id": template_id})
             if not existing_template:
                 raise HTTPException(status_code=404, detail="Gift card template not found")
             
-            # Add updated_at timestamp
             update_data['updated_at'] = datetime.now(timezone.utc)
-            
-            # Perform update
             result = await db[GIFT_CARD_TEMPLATES_COLLECTION].update_one(
                 {"_id": template_id},
                 {"$set": update_data}
             )
             
             success = result.modified_count > 0
-            
             if success:
-                logger.info(f"Gift card template {template_id} updated successfully")
+                logger.info("Gift card template updated", extra={"template_id": template_id})
             else:
-                logger.warning(f"No changes made to gift card template {template_id}")
+                logger.warning("No changes made to gift card template", extra={"template_id": template_id})
             
             return success
         except HTTPException:
             raise
         except Exception as e:
-            logger.error(f"Error updating gift card template {template_id}: {e}", exc_info=True)
+            logger.error("Error updating gift card template", extra={"template_id": template_id}, exc_info=e)
             raise RuntimeError("Failed to update gift card template") from e
 
     @staticmethod
@@ -181,17 +159,16 @@ class GiftCardTemplateModel:
         """
         try:
             result = await db[GIFT_CARD_TEMPLATES_COLLECTION].delete_one({"_id": template_id})
-            
             success = result.deleted_count > 0
             
             if success:
-                logger.info(f"Gift card template {template_id} deleted successfully")
+                logger.info("Gift card template deleted", extra={"template_id": template_id})
             else:
-                logger.warning(f"Gift card template {template_id} not found for deletion")
+                logger.warning("Gift card template not found for deletion", extra={"template_id": template_id})
             
             return success
         except Exception as e:
-            logger.error(f"Error deleting gift card template {template_id}: {e}", exc_info=True)
+            logger.error("Error deleting gift card template", extra={"template_id": template_id}, exc_info=e)
             raise RuntimeError("Failed to delete gift card template") from e
 
     @staticmethod
@@ -215,15 +192,14 @@ class GiftCardTemplateModel:
             )
             
             success = result.modified_count > 0
-            
             if success:
-                logger.info(f"Issued count incremented for template {template_id}")
+                logger.info("Issued count incremented", extra={"template_id": template_id})
             else:
-                logger.warning(f"Failed to increment issued count for template {template_id}")
+                logger.warning("Failed to increment issued count", extra={"template_id": template_id})
             
             return success
         except Exception as e:
-            logger.error(f"Error incrementing issued count for template {template_id}: {e}", exc_info=True)
+            logger.error("Error incrementing issued count", extra={"template_id": template_id}, exc_info=e)
             raise RuntimeError("Failed to increment issued count") from e
 
     @staticmethod
@@ -246,15 +222,9 @@ class GiftCardTemplateModel:
             max_issues = template.get("max_issues")
             issued_count = template.get("issued_count", 0)
             
-            # For digital cards or unlimited templates
             if max_issues is None:
-                return {
-                    "available": True,
-                    "unlimited": True,
-                    "remaining": None
-                }
+                return {"available": True, "unlimited": True, "remaining": None}
             
-            # For physical cards with limited stock
             remaining = max_issues - issued_count
             available = remaining > 0
             
@@ -268,5 +238,5 @@ class GiftCardTemplateModel:
         except HTTPException:
             raise
         except Exception as e:
-            logger.error(f"Error checking stock availability for template {template_id}: {e}", exc_info=True)
+            logger.error("Error checking stock availability", extra={"template_id": template_id}, exc_info=e)
             raise RuntimeError("Failed to check stock availability") from e

app/models/promotion_model.py

@@ -1,10 +1,10 @@
 from typing import Any, Dict, Optional, Union, List
 
-import logging
 import uuid
 
 from fastapi import HTTPException
 from pymongo import ReturnDocument
+from insightfy_utils.logging import get_logger
 
 from app.repositories.db import db, fetch_documents, serialize_mongo_document, fetch_many_aggregate
 from app.schemas.promotion_schema import PromotionMetaData
@@ -14,13 +14,12 @@ from app.utils.info_widget_utils import build_aggregation_pipeline_for_widget
 
 from app.constants.collections import PROMOTION_COLLECTION
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 class PromotionManagementModel:
 
     @staticmethod
     async def create_promotion_data(data: Dict[str, Any]) -> str:
-        
         data = sanitize_document_for_mongo(data)
         existing = await db[PROMOTION_COLLECTION].find_one(
             {"code": data["code"], "merchant_id": data["merchant_id"]}
@@ -30,9 +29,8 @@ class PromotionManagementModel:
 
         result = await db[PROMOTION_COLLECTION].insert_one(data)
         promotion_inserted_id = str(result.inserted_id)
-        logger.info(f"promotion created successfully with ID: {promotion_inserted_id}")
+        logger.info("Promotion created", extra={"promotion_id": promotion_inserted_id})
         return promotion_inserted_id
-       
 
     @staticmethod
     async def list_promotion(
@@ -66,77 +64,72 @@ class PromotionManagementModel:
                 PROMOTION_COLLECTION, filter_criteria, sort_criteria, offset, limit
             )
 
-            logger.debug(f"Fetched {len(promotion_list.get('items', []))} promotions")
+            logger.debug("Fetched promotions", extra={"count": len(promotion_list.get('items', []))})
             return promotion_list
         except Exception as e:
-            logger.error(f"Error listing promotions: {e}", exc_info=True)
+            logger.error("Error listing promotions", exc_info=e)
             raise RuntimeError("Failed to list promotions") from e
 
     @staticmethod
-    async def get_promotion_by_code(code:str)->Dict[str,Any]:
+    async def get_promotion_by_code(code: str) -> Dict[str, Any]:
         try:
-            logging.info("promotion data base on code")
-            promotion_data= await db[PROMOTION_COLLECTION].find_one({"code": code})
+            logger.info("Fetching promotion by code", extra={"code": code})
+            promotion_data = await db[PROMOTION_COLLECTION].find_one({"code": code})
             return promotion_data
         except Exception as e:
-            logger.error(f"Error while retrieving promotion by code: {e}", exc_info=True)
+            logger.error("Error retrieving promotion by code", extra={"code": code}, exc_info=e)
 
     @staticmethod
-    async def get_promotion_by_merchant_id(merchant_id:str)->Dict[str,Any]:
+    async def get_promotion_by_merchant_id(merchant_id: str) -> Dict[str, Any]:
         try:
-            logging.info("promotion data base on with out code")
-            promotion= db[PROMOTION_COLLECTION].find({"merchant_id": merchant_id, "auto_apply": True})
-            promotion_data = await promotion.to_list(length=100) 
-            return  [catalogue_utils.sanitize_document_for_mongo(doc) for doc in promotion_data]
+            logger.info("Fetching promotions by merchant", extra={"merchant_id": merchant_id})
+            promotion = db[PROMOTION_COLLECTION].find({"merchant_id": merchant_id, "auto_apply": True})
+            promotion_data = await promotion.to_list(length=100)
+            return [catalogue_utils.sanitize_document_for_mongo(doc) for doc in promotion_data]
         except Exception as e:
-            logger.error(f"Error while retrieving promotion by code: {e}", exc_info=True)
-            
+            logger.error("Error retrieving promotion by merchant", extra={"merchant_id": merchant_id}, exc_info=e)
+
     @staticmethod
-    async def update(code: str,user_id:str) -> int:
+    async def update(code: str, user_id: str) -> int:
         try:
             result = await db[PROMOTION_COLLECTION].update_one(
                 {"code": code},
                 {
-                "$inc": {'used_count': 1},
-                "$addToSet": {"used_by": user_id}
-                 }   )
-            logger.info(f"Modified {result.modified_count} document(s) for promotion code {code}")
+                    "$inc": {'used_count': 1},
+                    "$addToSet": {"used_by": user_id}
+                }
+            )
+            logger.info("Promotion updated", extra={"code": code, "modified_count": result.modified_count})
             return result.modified_count
         except Exception as e:
-            logger.error(f"Error while updating promotion: {e}", exc_info=True)
+            logger.error("Error updating promotion", extra={"code": code}, exc_info=e)
             raise RuntimeError("Failed to update in DB") from e
-        
+
     @staticmethod
     async def get_info_widget_data(
         merchant_id: str,
-        branch_id: str,   # <-- ADD THIS
+        branch_id: str,
         user_pref: dict
     ) -> Dict[str, Any]:
         try:
-
-            # Safely handle user_pref being None
             widgets = user_pref.get("widgets", []) if user_pref else []
             results = {}
             for widget in widgets:
                 widget_type = widget.get("type")
-
                 pipeline, post_process = build_aggregation_pipeline_for_widget(widget, merchant_id, branch_id)
-
-                logger.info(f"Executing pipeline for widget {widget_type}: {pipeline}")
+                logger.info("Executing pipeline for widget", extra={"widget_type": widget_type, "pipeline": pipeline})
                 if pipeline:
                     data = await fetch_many_aggregate(PROMOTION_COLLECTION, pipeline)
                     results[widget_type] = post_process(data) if post_process else data
                 else:
                     results[widget_type] = post_process([]) if post_process else []
-
             return results
-
         except Exception as e:
-            logger.error(f"Error fetching catalogue data: {e}", exc_info=True)
-            raise RuntimeError("Failed to fetch catalogue data") from e
-        
+            logger.error("Error fetching promotion widget data", exc_info=e)
+            raise RuntimeError("Failed to fetch promotion data") from e
+
     @staticmethod
-    async def get_by_promotion_id(promotion_id: str)  -> Dict[str, Any]:
+    async def get_by_promotion_id(promotion_id: str) -> Dict[str, Any]:
         result = await db.promotions.find_one({"promotion_id": promotion_id})
         return result if result else None
 
@@ -148,8 +141,8 @@ class PromotionManagementModel:
                 {"$set": update_data},
                 return_document=ReturnDocument.AFTER
             )
-            logger.info(f"promotion updated successfully")
+            logger.info("Promotion updated", extra={"promotion_id": promotion_id})
             return result if result else None
         except Exception as e:
-            logger.error(f"Error updating promotion data: {e}", exc_info=True)
+            logger.error("Error updating promotion", extra={"promotion_id": promotion_id}, exc_info=e)
             raise RuntimeError("Failed to update promotion data") from e

app/models/supplier_models.py

@@ -1,9 +1,9 @@
- 
 import logging
 from typing import Any, Dict, List
 import uuid
 from bson import ObjectId
 from fastapi import HTTPException
+from insightfy_utils.logging import get_logger
 from app.repositories.db import db, fetch_many_aggregate
 from app.schemas.supplier_schema import supply_history
 from app.utils import catalogue_utils
@@ -12,124 +12,98 @@ from app.utils.id_utils import generate_unique_id
 from app.constants.collections import SUPPLIERS_COLLECTION
 from app.utils.info_widget_utils import build_aggregation_pipeline_for_widget
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 class SupplierModel:
  
     @staticmethod
     async def create_supplier(data: Dict[str, Any]) -> str:
         try:
-                merchant_id = data.get('merchant_id')
-                supplier_id = generate_unique_id(merchant_id)
-                data['supplier_id'] = supplier_id
-                data = catalogue_utils.convert_dates(data)
-                # Insert data into MongoDB collection
-                result = await db[SUPPLIERS_COLLECTION].insert_one(data)
-                # Extract the inserted ID and convert to string
-                supplier_inserted_id = str(result.inserted_id)
-                # Log success for traceability
-                logger.info(f"supplier created successfully with ID: {supplier_inserted_id}")
-                return supplier_inserted_id
+            merchant_id = data.get('merchant_id')
+            supplier_id = generate_unique_id(merchant_id)
+            data['supplier_id'] = supplier_id
+            data = catalogue_utils.convert_dates(data)
+            result = await db[SUPPLIERS_COLLECTION].insert_one(data)
+            supplier_inserted_id = str(result.inserted_id)
+            logger.info("Supplier created", extra={"supplier_id": supplier_inserted_id})
+            return supplier_inserted_id
         except Exception as e:
-            # Log the error with stack trace for debugging
-            logger.error(f"Error creating supplier : {e}", exc_info=True)
-                
-            # Raise a more specific error with a custom message
+            logger.error("Error creating supplier", exc_info=e)
             raise RuntimeError("Failed to create supplier") from e
 
-
     @staticmethod
     async def get_supplier_data(supplier_id: str, merchant_id: str):
         try:
-        
-            filter_criteria = {
-                "supplier_id": supplier_id,
-                "merchant_id": merchant_id,
-            }
-                
-            logger.info(f"Fetching Supplier with ID: {filter_criteria}")
+            filter_criteria = {"supplier_id": supplier_id, "merchant_id": merchant_id}
+            logger.info("Fetching Supplier", extra={"filter": filter_criteria})
             Supplier_data = await db[SUPPLIERS_COLLECTION].find_one(filter_criteria)
             if Supplier_data:
-                logger.info(f"Supplier {supplier_id} fetched successfully.")
+                logger.info("Supplier fetched", extra={"supplier_id": supplier_id})
                 return catalogue_utils.sanitize_document_for_mongo(Supplier_data)
             else:
-                logger.info(f"Supplier {supplier_id} not found.")
-                return None 
-        except Exception as e:      
-            logger.error(f"Error fetching Supplier data: {e}", exc_info=True)
+                logger.info("Supplier not found", extra={"supplier_id": supplier_id})
+                return None
+        except Exception as e:
+            logger.error("Error fetching Supplier data", exc_info=e)
             raise RuntimeError("Failed to fetch Supplier data") from e
     
     @staticmethod
     async def update_supplier(supplier_id: str, update_fields: dict) -> bool:
         try:
             result = await db[SUPPLIERS_COLLECTION].update_one(
-                {"supplier_id":supplier_id},
+                {"supplier_id": supplier_id},
                 {"$set": update_fields}
             )
             return result.modified_count > 0
         except Exception as e:
-            logger.error(f"Error updating supplier data: {e}", exc_info=True)
+            logger.error("Error updating supplier data", exc_info=e)
             raise RuntimeError("Failed to update supplier data") from e
         
     @staticmethod
     async def delete_item(supplier_id: str) -> bool:
-    
-        logger.info(f"Soft deleting supplier with ID: {supplier_id}")
+        logger.info("Soft deleting supplier", extra={"supplier_id": supplier_id})
         try:
             result = await db[SUPPLIERS_COLLECTION].update_one(
-                {"supplier_id":supplier_id},
-                {"$set": {"status": "inactive"}}  # or use "deleted": True
+                {"supplier_id": supplier_id},
+                {"$set": {"status": "inactive"}}
             )
             updated = result.modified_count > 0
-
             if updated:
-                logger.debug(f"Supplier {supplier_id} soft deleted successfully.")
+                logger.debug("Supplier soft deleted", extra={"supplier_id": supplier_id})
             else:
-                logger.debug(f"Supplier {supplier_id} not found")
-            
+                logger.debug("Supplier not found", extra={"supplier_id": supplier_id})
             return updated
-        
         except Exception as e:
-            logger.error(f"Error soft deleting supplier: {e}", exc_info=True)
+            logger.error("Error soft deleting supplier", exc_info=e)
             raise RuntimeError("Failed to soft delete item") from e
 
     @staticmethod
     async def get_all_suppliers(query: Dict[str, Any]) -> List[Dict[str, Any]]:
         try:
-            logger.info(f"Fetching suppliers with query: {query}")
-
+            logger.info("Fetching suppliers", extra={"query": query})
             cursor = db[SUPPLIERS_COLLECTION].find(query)
-            suppliers = await cursor.to_list(length=100)  # Add pagination if needed
+            suppliers = await cursor.to_list(length=100)
             
-            if suppliers:                                                                                                                                           
-                logger.info(f"Found {len(suppliers)} supplier(s) matching query.")
+            if suppliers:
+                logger.info("Found suppliers", extra={"count": len(suppliers)})
                 return [catalogue_utils.sanitize_document_for_mongo(doc) for doc in suppliers]
             else:
-                logger.info("No suppliers matched the query.")
+                logger.info("No suppliers matched the query")
                 return []
-        
         except Exception as e:
-            logger.error(f"Error fetching suppliers: {e}", exc_info=True)
+            logger.error("Error fetching suppliers", exc_info=e)
             raise RuntimeError("Failed to fetch suppliers") from e
             
     @staticmethod
     async def count_suppliers(query: Dict[str, Any]) -> int:
-        """
-        Count the number of suppliers matching the given query.
-        
-        Args:
-            query: Dictionary of filter criteria
-            
-        Returns:
-            Total count of matching suppliers
-        """
+        """Count the number of suppliers matching the given query."""
         try:
-            logger.info(f"Counting suppliers with query: {query}")
+            logger.info("Counting suppliers", extra={"query": query})
             count = await db[SUPPLIERS_COLLECTION].count_documents(query)
-            logger.info(f"Found {count} supplier(s) matching query.")
+            logger.info("Counted suppliers", extra={"count": count})
             return count
         except Exception as e:
-            logger.error(f"Error counting suppliers: {e}", exc_info=True)
+            logger.error("Error counting suppliers", exc_info=e)
             raise RuntimeError("Failed to count suppliers") from e
             
     @staticmethod
@@ -139,109 +113,80 @@ class SupplierModel:
         limit: int = 10,
         projection_list: List[str] = None
     ) -> List[Dict[str, Any]]:
-        """
-        Get a paginated list of suppliers matching the given query.
-        
-        Args:
-            query: Dictionary of filter criteria
-            offset: Number of records to skip
-            limit: Maximum number of records to return
-            projection_list: Optional list of fields to include in the response
-            
-        Returns:
-            List of supplier documents
-        """
+        """Get a paginated list of suppliers matching the given query."""
         try:
-            logger.info(f"Fetching suppliers list with query: {query}, offset: {offset}, limit: {limit}")
+            logger.info("Fetching suppliers list", extra={"query": query, "offset": offset, "limit": limit})
             
-            # Create projection if needed
             projection = None
             if projection_list:
                 projection = dict.fromkeys(projection_list, 1)
-                # Always include _id for document identification
                 if '_id' not in projection:
                     projection['_id'] = 1
             
-            # Create cursor with pagination
             cursor = db[SUPPLIERS_COLLECTION].find(query, projection)
             cursor.skip(offset).limit(limit)
-            
-            # Sort by created_at descending (newest first) if available
             cursor.sort("created_at", -1)
-            
-            # Retrieve documents
             suppliers = await cursor.to_list(length=limit)
             
             if suppliers:
-                logger.info(f"Found {len(suppliers)} supplier(s) for the paginated query.")
+                logger.info("Found suppliers for paginated query", extra={"count": len(suppliers)})
                 return suppliers
             else:
-                logger.info("No suppliers found for the paginated query.")
+                logger.info("No suppliers found for paginated query")
                 return []
-                
         except Exception as e:
-            logger.error(f"Error fetching suppliers list: {e}", exc_info=True)
+            logger.error("Error fetching suppliers list", exc_info=e)
             raise RuntimeError("Failed to fetch suppliers list") from e
     
     @staticmethod
     async def append_supply_history(supplier_id: str, history_entry: any) -> Dict[str, Any]:
         try:
-            logger.info(f"appending supply history: {history_entry}")
+            logger.info("Appending supply history", extra={"history_entry": str(history_entry)})
             result = await db[SUPPLIERS_COLLECTION].update_one(
-            {"supplier_id": supplier_id},
-            {"$push": {"supply_history": history_entry.dict()}}
-        
-    )
+                {"supplier_id": supplier_id},
+                {"$push": {"supply_history": history_entry.dict()}}
+            )
             if result.modified_count == 0:
-                logger.debug(f"Supplier {supplier_id}  not found.")
-        
-            return{"message":"supplier history appended successfully"} 
-        
+                logger.debug("Supplier not found", extra={"supplier_id": supplier_id})
+            return {"message": "supplier history appended successfully"}
         except Exception as e:
-            logger.error(f"Error in appending supplier history: {e}", exc_info=True)
+            logger.error("Error appending supplier history", exc_info=e)
             raise RuntimeError("Failed to append supplier history") from e
         
     @staticmethod
     async def upload_document(data: Any, supplier_id: str) -> Dict[Any, str]:
         try:
             result = await db[SUPPLIERS_COLLECTION].update_one(
-            {"supplier_id": supplier_id},
-            {"$push": {"documents": data.dict()}}
-    )
-            return{"message":"supplier documents uploaded successfully"} 
-        
+                {"supplier_id": supplier_id},
+                {"$push": {"documents": data.dict()}}
+            )
+            return {"message": "supplier documents uploaded successfully"}
         except Exception as e:
-            logger.error(f"Error in uploading supplier documents: {e}", exc_info=True)
+            logger.error("Error uploading supplier documents", exc_info=e)
             raise RuntimeError("Failed to upload supplier documents") from e
         
     @staticmethod
     async def get_info_widget_data(
         merchant_id: str,
-        branch_id: str,   # <-- ADD THIS
+        branch_id: str,
         user_pref: dict
     ) -> Dict[str, Any]:
         try:
-
-            # Safely handle user_pref being None
             widgets = user_pref.get("widgets", []) if user_pref else []
             results = {}
             for widget in widgets:
                 widget_type = widget.get("type")
-
                 pipeline, post_process = build_aggregation_pipeline_for_widget(widget, merchant_id, branch_id)
-
-                logger.info(f"Executing pipeline for widget {widget_type}: {pipeline}")
+                logger.info("Executing pipeline for widget", extra={"widget_type": widget_type, "pipeline": pipeline})
                 if pipeline:
                     data = await fetch_many_aggregate(SUPPLIERS_COLLECTION, pipeline)
                     results[widget_type] = post_process(data) if post_process else data
                 else:
                     results[widget_type] = post_process([]) if post_process else []
-
             return results
-
         except Exception as e:
-            logger.error(f"Error fetching supplier data: {e}", exc_info=True)
+            logger.error("Error fetching supplier data", exc_info=e)
             raise RuntimeError("Failed to fetch supplier data") from e
-    
 
-    
+
+

app/models/taxonomy_model.py

@@ -1,27 +1,25 @@
 from datetime import datetime
-import logging
 from typing import Any, Dict, List
 import uuid
 
 from bson import ObjectId
+from insightfy_utils.logging import get_logger
 
 from app.repositories.db import db
 from app.schemas.taxonomy_schema import TaxonomyInfo
 
-logger = logging.getLogger(__name__) 
+logger = get_logger(__name__)
 
 class TaxonomyModel:
 
     @staticmethod
     async def create_append_delete_taxonomy(data: Any) -> Dict[str, Any]:
         try:
-           
             if isinstance(data, dict):
                 data = TaxonomyInfo(**data)
 
             merchant_id = data.merchant_id
             filter_criteria = {"merchant_id": merchant_id}
-
             existing = await db["settings_taxonomy"].find_one(filter_criteria)
             
             if data.is_delete:
@@ -81,12 +79,12 @@ class TaxonomyModel:
                 if pull_query:
                     update_query["$pull"] = pull_query
 
-                if len(update_query) > 1:  
+                if len(update_query) > 1:
                     await db["settings_taxonomy"].update_one(
                         {"merchant_id": merchant_id},
                         update_query
                     )
-                    logger.info(f"Deleted taxonomy values for merchant_id={merchant_id}")
+                    logger.info("Deleted taxonomy values", extra={"merchant_id": merchant_id})
                     return {"status": "deleted", "merchant_id": merchant_id}
 
                 return {"status": "no_changes", "merchant_id": merchant_id}
@@ -148,12 +146,12 @@ class TaxonomyModel:
                 if add_to_set:
                     update_query["$addToSet"] = add_to_set
 
-                if len(update_query) > 1: 
+                if len(update_query) > 1:
                     await db["settings_taxonomy"].update_one(
                         {"merchant_id": merchant_id},
                         update_query
                     )
-                    logger.info(f"Updated taxonomy for merchant_id={merchant_id}")
+                    logger.info("Updated taxonomy", extra={"merchant_id": merchant_id})
                     return {"status": "updated", "merchant_id": merchant_id}
 
                 return {"status": "no_changes", "merchant_id": merchant_id}
@@ -166,11 +164,11 @@ class TaxonomyModel:
                 doc["updated_at"] = datetime.utcnow()
                 await db["settings_taxonomy"].insert_one(doc)
 
-                logger.info(f"Created new taxonomy for merchant_id={merchant_id}")
+                logger.info("Created new taxonomy", extra={"merchant_id": merchant_id, "taxonomy_id": taxonomy_id})
                 return {"status": "created", "taxonomy_id": taxonomy_id, "merchant_id": merchant_id}
 
         except Exception as e:
-            logger.error(f"Error in create_taxonomy: {e}", exc_info=True)
+            logger.error("Error in create_taxonomy", exc_info=e)
             raise RuntimeError("Failed to create/append taxonomy") from e
 
     @staticmethod
@@ -178,44 +176,40 @@ class TaxonomyModel:
         try:
             obj_id = ObjectId(id)
             result = await db['settings_taxonomy'].update_one(
-                {"_id":obj_id},
+                {"_id": obj_id},
                 {"$set": update_fields}
             )
             return result.modified_count > 0
         except Exception as e:
-            logger.error(f"Error updating taxonomy data: {e}", exc_info=True)
+            logger.error("Error updating taxonomy data", exc_info=e)
             raise RuntimeError("Failed to update taxonomy data") from e
         
     @staticmethod
     async def delete_taxonomy(id: str) -> bool:
-    
-        logger.info(f"Soft deleting taxonomy with ID: {id}")
+        logger.info("Soft deleting taxonomy", extra={"id": id})
         try:
             obj_id = ObjectId(id)
             result = await db["settings_taxonomy"].update_one(
-                {"_id":obj_id},
-                {"$set": {"is_active": "false"}}  # or use "deleted": True
+                {"_id": obj_id},
+                {"$set": {"is_active": "false"}}
             )
             updated = result.modified_count > 0
 
             if updated:
-                logger.debug(f"Taxonomy {id} soft deleted successfully.")
+                logger.debug("Taxonomy soft deleted", extra={"id": id})
             else:
-                logger.debug(f"Taxonomy {id} not found")
+                logger.debug("Taxonomy not found", extra={"id": id})
             
             return updated
-        
         except Exception as e:
-            logger.error(f"Error soft deleting taxonomy: {e}", exc_info=True)
+            logger.error("Error soft deleting taxonomy", exc_info=e)
             raise RuntimeError("Failed to soft delete item") from e
 
     @staticmethod
     async def list_taxonomy(merchant_id: str, taxonomy_type=None) -> List[dict]:
-        logger.info(f"Fetching taxonomy list for merchant ID: {merchant_id}")
+        logger.info("Fetching taxonomy list", extra={"merchant_id": merchant_id})
         try:
-            filter_criteria = {
-                "merchant_id": merchant_id,
-            }
+            filter_criteria = {"merchant_id": merchant_id}
             projection = None
             if taxonomy_type in ["brands", "categories", "classes", "lines", "subcategories", "job_role", "specializations", "languages", "customer_group", "pos_tender_modes", "payment_types", "payment_methods", "asset_location", "asset_category", "stock_bin_location", "branch_types"]:
                 projection = {taxonomy_type: 1, "_id": 0}
@@ -223,13 +217,12 @@ class TaxonomyModel:
             results = (
                 await db["settings_taxonomy"]
                 .find(filter_criteria, projection)
-                .to_list(length=None)  # Retrieve all records without pagination
+                .to_list(length=None)
             )
-            logger.debug(f"Retrieved {len(results)} taxonomy records.")
+            logger.debug("Retrieved taxonomy records", extra={"count": len(results)})
             return results
 
         except Exception as e:
-            logger.error(f"Error fetching taxonomy list: {e}", exc_info=True)
+            logger.error("Error fetching taxonomy list", exc_info=e)
             raise RuntimeError("Failed to fetch taxonomy list") from e
 
-  

app/nosql.py

@@ -1,12 +1,13 @@
 # data_stores.py (or your current filename)
 from __future__ import annotations
 
-import logging
 from urllib.parse import urlparse
 
 import motor.motor_asyncio
 import redis.asyncio as redis
 from redis.exceptions import RedisError
+from insightfy_utils.db import MongoConnector, RedisConnector
+from insightfy_utils.logging import setup_logging, get_logger
 
 # Single source of truth
 from settings import (
@@ -19,13 +20,10 @@ from settings import (
 )
 
 # -----------------------------------------------------------------------------
-# Logging
+# Logging (migrated to insightfy-utils)
 # -----------------------------------------------------------------------------
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-)
-logger = logging.getLogger(__name__)
+setup_logging(level="INFO", format_type="json", app_name="insightfy-bloom-ms-ems-nosql")
+logger = get_logger(__name__)
 
 # -----------------------------------------------------------------------------
 # Validate configuration
@@ -51,9 +49,9 @@ try:
         connectTimeoutMS=60_000,
     )
     mongo_db = mongo_client[MONGO_DB_NAME]
-    logger.info("MongoDB client initialized (db=%s).", MONGO_DB_NAME)
+    logger.info("MongoDB client initialized", extra={"database": MONGO_DB_NAME})
 except Exception as e:
-    logger.exception("Failed to initialize MongoDB client.")
+    logger.exception("Failed to initialize MongoDB client", exc_info=e)
     raise
 
 # -----------------------------------------------------------------------------
@@ -92,7 +90,7 @@ try:
     redis_client = _redis_from_settings()
     logger.info("Redis client initialized.")
 except Exception as e:
-    logger.exception("Failed to initialize Redis client.")
+    logger.exception("Failed to initialize Redis client", exc_info=e)
     raise
 
 # -----------------------------------------------------------------------------

app/repositories/cache.py

@@ -1,9 +1,9 @@
 from typing import Any
 from app.nosql import redis_client
+from insightfy_utils.logging import get_logger
 import json
-import logging
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 CACHE_EXPIRY_SECONDS = 3600
 
@@ -14,10 +14,10 @@ async def get_or_set_cache(key: str, fetch_func, expiry: int = CACHE_EXPIRY_SECO
     """
     cached_data = await redis_client.get(key)
     if cached_data:
-        logger.info(f"Cache hit for key: {key}")
+        logger.info("Cache hit", extra={"key": key})
         return json.loads(cached_data)
 
-    logger.info(f"Cache miss for key: {key}")
+    logger.info("Cache miss", extra={"key": key})
     data = await fetch_func()
     await redis_client.set(key, json.dumps(data), ex=expiry)
     return data

app/repositories/db.py

@@ -3,32 +3,32 @@ from typing import Any, Dict, List, Optional
 
 from sqlalchemy import text
 from app.nosql import db
-from pymongo.errors import PyMongoError  # ✅ Unified error handling
+from pymongo.errors import PyMongoError
 from bson import ObjectId
 from bson.decimal128 import Decimal128
-import logging
+from insightfy_utils.logging import get_logger
 from app.sql import async_session
 from sqlalchemy.exc import SQLAlchemyError
-logger = logging.getLogger(__name__)
+
+logger = get_logger(__name__)
 
 async def count_documents(collection: str, filter_criteria: Dict) -> int:
     """
     Count documents in a MongoDB collection that match the filter criteria.
     """
     try:
-        
-        logger.info(f"Counting documents in collection: {collection} with filter: {filter_criteria}")
+        logger.info("Counting documents", extra={"collection": collection, "filter": filter_criteria})
 
         if filter_criteria is None:
-            logger.debug(f"Filter criteria: {filter_criteria}")
+            logger.debug("Filter criteria is None", extra={"filter": filter_criteria})
         else:
-            logger.debug("No filter criteria provided, counting all documents in the collection.")
+            logger.debug("No filter criteria provided, counting all documents")
         
         count = await db[collection].count_documents(filter_criteria)
-        logger.info(f"Counted {count} documents in collection: {collection}")
+        logger.info("Counted documents", extra={"collection": collection, "count": count})
         return count
     except PyMongoError as e:
-        logger.error(f"MongoDB count error in collection '{collection}': {e}")
+        logger.error("MongoDB count error", extra={"collection": collection}, exc_info=e)
         raise RuntimeError("Database count operation failed") from e
 
 def serialize_mongo_document(doc: Any) -> Any:
@@ -41,11 +41,11 @@ def serialize_mongo_document(doc: Any) -> Any:
     if isinstance(doc, dict):
         return {key: serialize_mongo_document(value) for key, value in doc.items()}
     if isinstance(doc, ObjectId):
-        return str(doc)  # ✅ Convert ObjectId to string
+        return str(doc)
     if isinstance(doc, Decimal128):
-        return float(doc.to_decimal())  # ✅ Convert Decimal128 to float
+        return float(doc.to_decimal())
     if isinstance(doc, datetime):
-        return doc.isoformat()  # ✅ Convert datetime to ISO 8601 string
+        return doc.isoformat()
     return doc
 
 async def execute_query(collection: str, pipeline: List[Dict]) -> Any:
@@ -53,13 +53,13 @@ async def execute_query(collection: str, pipeline: List[Dict]) -> Any:
     Execute MongoDB aggregation pipeline with error handling and serialization.
     """
     try:
-        logger.info(f"Executing aggregation pipeline on collection: {collection} with pipeline: {pipeline}")
+        logger.info("Executing aggregation pipeline", extra={"collection": collection, "pipeline": pipeline})
         results = await db[collection].aggregate(pipeline).to_list(length=None)
         serialized_results = serialize_mongo_document(results)
-        logger.info(f"Aggregation query returned {len(serialized_results)} documents from {collection}")
+        logger.info("Aggregation completed", extra={"collection": collection, "result_count": len(serialized_results)})
         return serialized_results
     except PyMongoError as e:
-        logger.error(f"MongoDB query error in collection '{collection}': {e}")
+        logger.error("MongoDB query error", extra={"collection": collection}, exc_info=e)
         raise RuntimeError("Database query failed") from e
 
 async def fetch_documents(
@@ -82,7 +82,15 @@ async def fetch_documents(
             .to_list(length=limit)
         )
         has_more = (offset + limit) < total
-        logger.info(f"Fetched {len(results)} documents from {collection}. Total: {total}, Has More: {has_more}")
+        logger.info(
+            "Fetched documents",
+            extra={
+                "collection": collection,
+                "count": len(results),
+                "total": total,
+                "has_more": has_more
+            }
+        )
 
         return {
             "documents": serialize_mongo_document(results),
@@ -90,7 +98,7 @@ async def fetch_documents(
             "has_more": has_more,
         }
     except PyMongoError as e:
-        logger.error(f"MongoDB fetch error in collection '{collection}': {e}")
+        logger.error("MongoDB fetch error", extra={"collection": collection}, exc_info=e)
         raise RuntimeError("Database fetch operation failed") from e
 
 async def fetch_pos_documents(
@@ -102,19 +110,12 @@ async def fetch_pos_documents(
 ) -> List[Dict[str, Any]]:
     """
     Fetch POS-specific documents from MongoDB with filtering, pagination, and projection.
-
-    Args:
-        collection (str): The name of the MongoDB collection.
-        filter_criteria (Dict[str, Any]): Criteria to filter the items.
-        projection (Optional[Dict[str, int]]): Fields to include or exclude.
-        offset (int): Number of documents to skip for pagination.
-        limit (int): Maximum number of documents to fetch.
-
-    Returns:
-        List[Dict[str, Any]]: A list of documents matching the filter criteria.
     """
     try:
-        logger.info(f"Fetching POS documents from {collection} with filter: {filter_criteria} and projection: {projection}")
+        logger.info(
+            "Fetching POS documents",
+            extra={"collection": collection, "filter": filter_criteria, "projection": projection}
+        )
 
         results = (
             await db[collection]
@@ -124,12 +125,11 @@ async def fetch_pos_documents(
             .to_list(length=limit)
         )
 
-        logger.info(f"Fetched {len(results)} POS documents from collection: {collection}")
+        logger.info("Fetched POS documents", extra={"collection": collection, "count": len(results)})
         return serialize_mongo_document(results)
     except PyMongoError as e:
-        logger.error(f"MongoDB fetch error for POS documents in collection '{collection}': {e}")
+        logger.error("MongoDB fetch error for POS documents", extra={"collection": collection}, exc_info=e)
         raise RuntimeError("Failed to fetch POS documents") from e
-    
 
 async def fetch_one_document(
     collection_name: str,
@@ -137,54 +137,33 @@ async def fetch_one_document(
 ) -> Optional[Dict[str, Any]]:
     """
     Fetches a single document from the given MongoDB collection.
-    
-    Args:
-        collection_name (str): Name of the collection.
-        query (Dict[str, Any]): Filter query to find the document.
-    
-    Returns:
-        Optional[Dict[str, Any]]: The found document or None.
-    
-    Raises:
-        RuntimeError: If a DB operation fails.
     """
     try:
-        logger.debug(f"Fetching one document from {collection_name} with query: {query}")
+        logger.debug("Fetching one document", extra={"collection": collection_name, "query": query})
         result = await db[collection_name].find_one(query)
-        logger.debug(f"Found document: {result}")
+        logger.debug("Found document", extra={"collection": collection_name, "found": result is not None})
         return result
     except PyMongoError as e:
-        logger.error(f"MongoDB error fetching from {collection_name}: {e}", exc_info=True)
+        logger.error("MongoDB error fetching document", extra={"collection": collection_name}, exc_info=e)
         raise RuntimeError(f"Database read failed for {collection_name}") from e
-    
+
 async def fetch_many_aggregate(
     collection: str,
     pipeline: List[Dict[str, Any]]
 ) -> List[Dict[str, Any]]:
     """
     Execute a MongoDB aggregation pipeline and return serialized results.
-
-    Args:
-        collection (str): The name of the MongoDB collection.
-        pipeline (List[Dict[str, Any]]): The aggregation pipeline stages.
-
-    Returns:
-        List[Dict[str, Any]]: Aggregated documents.
-
-    Raises:
-        RuntimeError: If the aggregation query fails.
     """
     try:
-        logger.info(f"Running aggregation on collection '{collection}' with pipeline: {pipeline}")
+        logger.info("Running aggregation", extra={"collection": collection, "pipeline": pipeline})
         cursor = db[collection].aggregate(pipeline)
         results = await cursor.to_list(length=None)
         serialized = serialize_mongo_document(results)
-        logger.info(f"Aggregation returned {len(serialized)} results from collection '{collection}'")
+        logger.info("Aggregation completed", extra={"collection": collection, "result_count": len(serialized)})
         return serialized
     except PyMongoError as e:
-        logger.error(f"Aggregation failed on collection '{collection}': {e}", exc_info=True)
+        logger.error("Aggregation failed", extra={"collection": collection}, exc_info=e)
         raise RuntimeError("Aggregation query failed") from e
-    
 
 async def fetch_many_pg(
     sql_query: str,
@@ -192,23 +171,13 @@ async def fetch_many_pg(
 ) -> List[Dict[str, Any]]:
     """
     Execute a raw SQL query in Postgres and return serialized results.
-
-    Args:
-        sql_query (str): SQL query string.
-        params (Dict[str, Any]): Query parameters for safe binding.
-
-    Returns:
-        List[Dict[str, Any]]: List of row dicts.
-
-    Raises:
-        RuntimeError: If the query fails.
     """
     try:
-        async with async_session() as session:  # type: AsyncSession
-            logger.info(f"Running Postgres query: {sql_query} with params: {params}")
+        async with async_session() as session:
+            logger.info("Running Postgres query", extra={"query": sql_query, "params": params})
             result = await session.execute(text(sql_query), params or {})
-            rows = result.mappings().all()  # returns list of dict-like row objects
+            rows = result.mappings().all()
             return [dict(row) for row in rows]
     except SQLAlchemyError as e:
-        logger.error(f"Postgres query failed: {e}", exc_info=True)
+        logger.error("Postgres query failed", exc_info=e)
         raise RuntimeError("Postgres query failed") from e

app/repositories/gift_card_repository.py

@@ -1,34 +1,22 @@
-import logging
 from typing import Any, Dict, List, Optional
+from insightfy_utils.logging import get_logger
 from app.models.gift_card_models import GiftCardTemplateModel
 from app.schemas.gift_card_schema import GiftCardTemplateFilter
 
-# Configure logging for this module
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 class GiftCardRepository:
-    """
-    Repository layer for Gift Card operations.
-    Provides a clean interface between services and the data model.
-    """
+    """Repository layer for Gift Card operations."""
 
     @staticmethod
-    async def create_template(template_data: Dict[str, Any],merchant_id:str) -> str:
-        """
-        Create a new gift card template.
-        
-        Args:
-            template_data (Dict[str, Any]): Template data to create
-            
-        Returns:
-            str: Created template ID
-        """
+    async def create_template(template_data: Dict[str, Any], merchant_id: str) -> str:
+        """Create a new gift card template."""
         try:
-            template_id = await GiftCardTemplateModel.create_template(template_data,merchant_id)
-            logger.info(f"Template created with ID: {template_id}")
+            template_id = await GiftCardTemplateModel.create_template(template_data, merchant_id)
+            logger.info("Template created", extra={"template_id": template_id})
             return template_id
         except Exception as e:
-            logger.error(f"Repository error creating template: {e}")
+            logger.error("Repository error creating template", exc_info=e)
             raise
         
     @staticmethod
@@ -37,147 +25,88 @@ class GiftCardRepository:
         offset: int = 0,
         limit: int = 100
     ) -> Dict[str, Any]:
-        """
-        Get gift card templates with pagination and filtering.
-        
-        Args:
-            filter_criteria (Dict[str, Any]): MongoDB filter criteria
-            offset (int): Number of documents to skip
-            limit (int): Maximum number of documents to return
-            
-        Returns:
-            Dict[str, Any]: Templates with pagination info
-        """
+        """Get gift card templates with pagination and filtering."""
         try:
             result = await GiftCardTemplateModel.list_gift_card(filter_criteria, offset, limit)
-            logger.info(f"Retrieved {len(result['templates'])} templates")
+            logger.info("Retrieved templates", extra={"count": len(result['templates'])})
             return result
         except Exception as e:
-            logger.error(f"Repository error getting templates: {e}")
+            logger.error("Repository error getting templates", exc_info=e)
             raise
 
     @staticmethod
     async def get_template_by_id(template_id: str) -> Optional[Dict[str, Any]]:
-        """
-        Get a specific gift card template by ID.
-        
-        Args:
-            template_id (str): Template ID to retrieve
-            
-        Returns:
-            Optional[Dict[str, Any]]: Template data or None if not found
-        """
+        """Get a specific gift card template by ID."""
         try:
             template = await GiftCardTemplateModel.get_template_by_id(template_id)
             if template:
-                logger.info(f"Retrieved template: {template_id}")
+                logger.info("Retrieved template", extra={"template_id": template_id})
             else:
-                logger.info(f"Template not found: {template_id}")
+                logger.info("Template not found", extra={"template_id": template_id})
             return template
         except Exception as e:
-            logger.error(f"Repository error getting template {template_id}: {e}")
+            logger.error("Repository error getting template", extra={"template_id": template_id}, exc_info=e)
             raise
 
     @staticmethod
     async def update_template(template_id: str, update_data: Dict[str, Any]) -> bool:
-        """
-        Update a gift card template.
-        
-        Args:
-            template_id (str): Template ID to update
-            update_data (Dict[str, Any]): Fields to update
-            
-        Returns:
-            bool: True if update was successful
-        """
+        """Update a gift card template."""
         try:
             success = await GiftCardTemplateModel.update_template(template_id, update_data)
             if success:
-                logger.info(f"Template updated: {template_id}")
+                logger.info("Template updated", extra={"template_id": template_id})
             else:
-                logger.warning(f"No changes made to template: {template_id}")
+                logger.warning("No changes made to template", extra={"template_id": template_id})
             return success
         except Exception as e:
-            logger.error(f"Repository error updating template {template_id}: {e}")
+            logger.error("Repository error updating template", extra={"template_id": template_id}, exc_info=e)
             raise
 
     @staticmethod
     async def delete_template(template_id: str) -> bool:
-        """
-        Delete a gift card template.
-        
-        Args:
-            template_id (str): Template ID to delete
-            
-        Returns:
-            bool: True if deletion was successful
-        """
+        """Delete a gift card template."""
         try:
             success = await GiftCardTemplateModel.delete_template(template_id)
             if success:
-                logger.info(f"Template deleted: {template_id}")
+                logger.info("Template deleted", extra={"template_id": template_id})
             else:
-                logger.warning(f"Template not found for deletion: {template_id}")
+                logger.warning("Template not found for deletion", extra={"template_id": template_id})
             return success
         except Exception as e:
-            logger.error(f"Repository error deleting template {template_id}: {e}")
+            logger.error("Repository error deleting template", extra={"template_id": template_id}, exc_info=e)
             raise
 
     @staticmethod
     async def check_template_exists(template_id: str) -> bool:
-        """
-        Check if a template exists.
-        
-        Args:
-            template_id (str): Template ID to check
-            
-        Returns:
-            bool: True if template exists
-        """
+        """Check if a template exists."""
         try:
             template = await GiftCardTemplateModel.get_template_by_id(template_id)
             return template is not None
         except Exception as e:
-            logger.error(f"Repository error checking template existence {template_id}: {e}")
+            logger.error("Repository error checking template existence", extra={"template_id": template_id}, exc_info=e)
             raise
 
     @staticmethod
     async def increment_issued_count(template_id: str) -> bool:
-        """
-        Increment the issued count for a template.
-        
-        Args:
-            template_id (str): Template ID to increment count for
-            
-        Returns:
-            bool: True if increment was successful
-        """
+        """Increment the issued count for a template."""
         try:
             success = await GiftCardTemplateModel.increment_issued_count(template_id)
             if success:
-                logger.info(f"Issued count incremented for template: {template_id}")
+                logger.info("Issued count incremented", extra={"template_id": template_id})
             return success
         except Exception as e:
-            logger.error(f"Repository error incrementing issued count {template_id}: {e}")
+            logger.error("Repository error incrementing issued count", extra={"template_id": template_id}, exc_info=e)
             raise
 
     @staticmethod
     async def check_stock_availability(template_id: str) -> Dict[str, Any]:
-        """
-        Check stock availability for a template.
-        
-        Args:
-            template_id (str): Template ID to check
-            
-        Returns:
-            Dict[str, Any]: Stock availability information
-        """
+        """Check stock availability for a template."""
         try:
             stock_info = await GiftCardTemplateModel.check_stock_availability(template_id)
-            logger.info(f"Stock check for template {template_id}: available={stock_info['available']}")
+            logger.info("Stock check completed", extra={"template_id": template_id, "available": stock_info['available']})
             return stock_info
         except Exception as e:
-            logger.error(f"Repository error checking stock for template {template_id}: {e}")
+            logger.error("Repository error checking stock", extra={"template_id": template_id}, exc_info=e)
             raise
 
     @staticmethod
@@ -185,16 +114,7 @@ class GiftCardRepository:
         merchant_id: str,
         filters: Optional[GiftCardTemplateFilter] = None
     ) -> Dict[str, Any]:
-        """
-        Build MongoDB filter criteria from filter parameters.
-        
-        Args:
-            merchant_id (str): Merchant ID to filter by
-            filters (Optional[GiftCardTemplateFilter]): Filter parameters
-            
-        Returns:
-            Dict[str, Any]: MongoDB filter criteria
-        """
+        """Build MongoDB filter criteria from filter parameters."""
         if filters:
             return filters.to_mongo_filter(merchant_id)
         else:
@@ -206,38 +126,19 @@ class GiftCardRepository:
         status: str,
         limit: int = 100
     ) -> List[Dict[str, Any]]:
-        """
-        Get templates by status for a specific merchant.
-        
-        Args:
-            merchant_id (str): Merchant ID
-            status (str): Template status
-            limit (int): Maximum number of templates to return
-            
-        Returns:
-            List[Dict[str, Any]]: List of templates
-        """
+        """Get templates by status for a specific merchant."""
         try:
             filter_criteria = {"merchant_id": merchant_id, "status": status}
             result = await GiftCardTemplateModel.get_templates(filter_criteria, 0, limit)
-            logger.info(f"Retrieved {len(result['templates'])} templates with status {status}")
+            logger.info("Retrieved templates by status", extra={"count": len(result['templates']), "status": status})
             return result["templates"]
         except Exception as e:
-            logger.error(f"Repository error getting templates by status {status}: {e}")
+            logger.error("Repository error getting templates by status", extra={"status": status}, exc_info=e)
             raise
 
     @staticmethod
     async def xxget_active_templates(merchant_id: str, limit: int = 100) -> List[Dict[str, Any]]:
-        """
-        Get active templates for a specific merchant.
-        
-        Args:
-            merchant_id (str): Merchant ID
-            limit (int): Maximum number of templates to return
-            
-        Returns:
-            List[Dict[str, Any]]: List of active templates
-        """
+        """Get active templates for a specific merchant."""
         return await GiftCardRepository.get_templates_by_status(merchant_id, "active", limit)
 
     @staticmethod
@@ -246,24 +147,13 @@ class GiftCardRepository:
         delivery_type: str,
         limit: int = 100
     ) -> List[Dict[str, Any]]:
-        """
-        Get templates by delivery type for a specific merchant.
-        
-        Args:
-            merchant_id (str): Merchant ID
-            delivery_type (str): Delivery type (digital/physical)
-            limit (int): Maximum number of templates to return
-            
-        Returns:
-            List[Dict[str, Any]]: List of templates
-        """
+        """Get templates by delivery type for a specific merchant."""
         try:
             filter_criteria = {"merchant_id": merchant_id, "delivery_type": delivery_type}
             result = await GiftCardTemplateModel.get_templates(filter_criteria, 0, limit)
-            logger.info(f"Retrieved {len(result['templates'])} {delivery_type} templates")
+            logger.info("Retrieved templates by delivery type", extra={"count": len(result['templates']), "delivery_type": delivery_type})
             return result["templates"]
         except Exception as e:
-            logger.error(f"Repository error getting templates by delivery type {delivery_type}: {e}")
+            logger.error("Repository error getting templates by delivery type", extra={"delivery_type": delivery_type}, exc_info=e)
             raise
-        
-   
+

app/repositories/inventory_repository.py

@@ -1,25 +1,22 @@
-
 import uuid
 from typing import List, Dict
 from datetime import datetime
+from insightfy_utils.logging import get_logger
 from app.sql import database
 from app.schemas.inventory_schema import branch_inventory, inventory_audit_log
-import logging
 import sqlalchemy
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
-async def fetch_stock_by_catalogue_ids(merchant_id:str,branch_id: str, catalogue_ids: List[str]) -> Dict[str, int]:
-    """
-    Returns a dictionary of catalogue_id -> stock_on_hand
-    """
+async def fetch_stock_by_catalogue_ids(merchant_id: str, branch_id: str, catalogue_ids: List[str]) -> Dict[str, int]:
+    """Returns a dictionary of catalogue_id -> stock_on_hand"""
     if not merchant_id or not branch_id or not catalogue_ids:
         return {}
 
     try:
         query = branch_inventory.select().where(
-            branch_inventory.c.merchant_id==merchant_id,
+            branch_inventory.c.merchant_id == merchant_id,
             branch_inventory.c.branch_id == branch_id,
             branch_inventory.c.catalogue_id.in_(catalogue_ids)
         )
@@ -27,15 +24,12 @@ async def fetch_stock_by_catalogue_ids(merchant_id:str,branch_id: str, catalogue
         rows = await database.fetch_all(query)
         return {row["catalogue_id"]: row["stock_on_hand"] for row in rows}
     except Exception as e:
-        logger.error(f"Error fetching stock for branch_id={branch_id}: {e}")
+        logger.error("Error fetching stock", extra={"branch_id": branch_id, "error": str(e)}, exc_info=e)
         raise
 
 
 async def fetch_stock_by_catalogue_id(branch_id: str, catalogue_id: str) -> int:
-    """
-    Returns stock_on_hand for a single catalogue_id in a branch.
-    Returns 0 if not found.
-    """
+    """Returns stock_on_hand for a single catalogue_id in a branch. Returns 0 if not found."""
     stock_map = await fetch_stock_by_catalogue_ids(branch_id, [catalogue_id])
     return stock_map.get(catalogue_id, 0)
 
@@ -71,19 +65,12 @@ async def update_inventory(
     reason: str = "",
     allow_negative_stock: bool = False
 ) -> None:
-    """
-    Updates stock and logs the audit with merchant_id and associate_id included.
-    Now includes transaction management, input validation, and stock validation.
-    
-    Args:
-        allow_negative_stock: If True, allows stock to go negative. If False, raises error on negative stock.
-    """
+    """Updates stock and logs the audit with merchant_id and associate_id included."""
     _validate_inventory_params(merchant_id, branch_id, catalogue_id, associate_id, change)
-    now = datetime.now()  # Using datetime.now() instead of utcnow()
+    now = datetime.now()
 
     try:
         async with database.transaction():
-            # Fetch current stock
             select_query = branch_inventory.select().where(
                 branch_inventory.c.branch_id == branch_id,
                 branch_inventory.c.catalogue_id == catalogue_id
@@ -94,7 +81,15 @@ async def update_inventory(
                 current_stock = current_record["stock_on_hand"]
                 new_stock = current_stock + change
                 if new_stock < 0 and not allow_negative_stock:
-                    logger.warning(f"Negative stock detected: {new_stock} for catalogue_id={catalogue_id}")
+                    logger.warning(
+                        "Negative stock detected",
+                        extra={
+                            "new_stock": new_stock,
+                            "catalogue_id": catalogue_id,
+                            "current_stock": current_stock,
+                            "change": change
+                        }
+                    )
                     raise ValueError(f"Stock cannot be negative. Current: {current_stock}, Change: {change}")
 
                 update_query = (
@@ -117,7 +112,6 @@ async def update_inventory(
                 await database.execute(insert_query)
                 current_stock = 0
 
-            # Insert audit log
             audit_query = inventory_audit_log.insert().values(
                 id=str(uuid.uuid4()),
                 merchant_id=merchant_id,
@@ -132,19 +126,24 @@ async def update_inventory(
             )
             await database.execute(audit_query)
             logger.info(
-                f"Inventory updated for catalogue_id={catalogue_id}, branch_id={branch_id}, "
-                f"merchant_id={merchant_id}. Change: {change}, By: {associate_id}"
+                "Inventory updated",
+                extra={
+                    "catalogue_id": catalogue_id,
+                    "branch_id": branch_id,
+                    "merchant_id": merchant_id,
+                    "change": change,
+                    "associate_id": associate_id
+                }
             )
     except sqlalchemy.exc.IntegrityError as e:
-        logger.error(f"Database constraint violation during inventory update: {e}")
+        logger.error("Database constraint violation during inventory update", exc_info=e)
         raise ValueError("Invalid inventory update - constraint violation") from e
     except sqlalchemy.exc.DatabaseError as e:
-        logger.error(f"Database error during inventory update: {e}")
+        logger.error("Database error during inventory update", exc_info=e)
         raise RuntimeError("Database operation failed") from e
     except ValueError as e:
-        # Re-raise validation errors as-is
-        logger.error(f"Validation error during inventory update: {e}")
+        logger.error("Validation error during inventory update", exc_info=e)
         raise
     except Exception as e:
-        logger.error(f"Unexpected error updating inventory: {e}")
+        logger.error("Unexpected error updating inventory", exc_info=e)
         raise RuntimeError("Inventory update failed") from e

app/routers/catalogue_router.py

@@ -1,7 +1,4 @@
-
-
 # Standard library imports
-import logging
 import re
 import time
 from io import BytesIO, StringIO
@@ -10,6 +7,7 @@ from io import BytesIO, StringIO
 import pandas as pd
 from fastapi import APIRouter, Body, Depends, File, HTTPException, Query, Path, UploadFile
 from typing import Optional, Union, Dict, Any
+from insightfy_utils.logging import get_logger
 
 # Local imports
 from app.nosql import redis_client
@@ -23,7 +21,7 @@ from app.schemas.catalogue_schema import BulkUploadResponse, CatalogueBulkImport
 
 # Router Initialization
 router = APIRouter()
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 # Constants
@@ -62,10 +60,10 @@ async def create_item(
             data.merchant_id = current_user["merchant_id"]
         data.created_by = current_user["associate_id"]
         catelogue_id = await CatalogueService.create_catalogue_item(data)
-        logger.info(f"/catalogue/ create completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        logger.info("Catalogue create completed", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
         return {"catelogue_id": catelogue_id, "correlation_id": correlation_id}
     except RuntimeError as re:
-        logger.error(f"RuntimeError while creating catalogue item: {re}  | correlation_id={correlation_id}", exc_info=True)
+        logger.error("RuntimeError while creating catalogue item", extra={"correlation_id": correlation_id}, exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
 
 
@@ -81,23 +79,17 @@ async def update_item(
         merchant_id = current_user["merchant_id"]
         data["updated_by"] = current_user["associate_id"]
         
-        result=await catalogue_service.CatalogueService.update_catalogue_item(catalogue_id, data,merchant_id)    
+        result=await catalogue_service.CatalogueService.update_catalogue_item(catalogue_id, data, merchant_id)    
      
-        logger.info(f"/catalogue/{{id}} update completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        logger.info("Catalogue update completed", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
         result_data = catalogue_utils.sanitize_document_for_mongo(result)
         return {**result_data, "correlation_id": correlation_id}
     
     except HTTPException as he:
-        # Pass through 400 or any raised HTTPException
-        logger.warning(
-            f"HTTPException while updating catalogue: {he.detail} | correlation_id={correlation_id}"
-        )
+        logger.warning("HTTPException while updating catalogue", extra={"detail": he.detail, "correlation_id": correlation_id})
         raise he
     except RuntimeError as re:
-        logger.error(
-            f"RuntimeError while updating catalogue: {re} | correlation_id={correlation_id}",
-            exc_info=True,
-        )
+        logger.error("RuntimeError while updating catalogue", extra={"correlation_id": correlation_id}, exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
 @router.post("/list", status_code=200)
 async def list_catalogue_items(
@@ -105,30 +97,9 @@ async def list_catalogue_items(
     current_user: dict = Depends(require_view_catalogue_permission),
     correlation_id: str = Depends(get_request_id)
 ) -> Dict[str, Any]:
-    """
-    List catalogue items with optional filters, pagination, and field projection.
-
-    Args:
-        payload: CatalogueListFilter containing:
-            - filters: Optional dictionary of filter criteria
-            - offset: Pagination offset (default: 0)
-            - limit: Pagination limit (default: 10, max: 1000)
-            - catalogue_type: Optional catalogue type filter (product/service)
-            - projection_list: Optional list of fields to include in response
-        current_user: Current authenticated user information
-        correlation_id: Request correlation ID for tracking
-
-    Raises:
-        HTTPException: 
-            - 500 if RuntimeError occurs during processing
-            - 500 if any unexpected error occurs
-
-    Returns:
-        dict: Paginated catalogue items with optional field projection applied
-    """
+    """List catalogue items with optional filters, pagination, and field projection."""
     start_time = time.time()
     try:
-        # Call the service layer to list items with pagination
         merchant_id = current_user.get("merchant_id")
         branch_id = current_user.get("branch_id")
         associate_id = current_user["associate_id"]
@@ -147,268 +118,86 @@ async def list_catalogue_items(
             branch_id=branch_id,
             projection_list=payload.projection_list
         )
-        logger.info(
-            f"/catalogue/list completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        logger.info("Catalogue list completed", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
         return {**result, "correlation_id": correlation_id}
 
     except RuntimeError as re:
-        logger.error(
-            f"RuntimeError while listing items: {re} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("RuntimeError while listing items", extra={"correlation_id": correlation_id}, exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
     except Exception as e:
-        logger.error(
-            f"Error in list_catalogues: {e} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("Error in list_catalogues", extra={"correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
 
 @router.get("/POS/", status_code=200)
 async def list_pos_catalogue_items(
-    catalogue_type: Optional[str] = Query(
-        None, description="Catalogue Type (product or service)"),
-    search_query: Optional[str] = Query(
-        None, description="Free search across name, alias_code, ean_code, and sku_code"),
+    catalogue_type: Optional[str] = Query(None, description="Catalogue Type (product or service)"),
+    search_query: Optional[str] = Query(None, description="Free search across name, alias_code, ean_code, and sku_code"),
     current_user: dict = Depends(require_view_catalogue_permission),
     correlation_id: str = Depends(get_request_id)
 ) -> Dict[str, Any]:
-    """
-    Optimized POS catalogue items endpoint with improved performance:
-    - Consolidated filter building
-    - Database-level aggregation for grouping
-    - Proper input validation and sanitization
-    - Reduced memory usage
-    - Redis caching for improved response times
-    """
+    """Optimized POS catalogue items endpoint with Redis caching."""
     start_time = time.time()
 
     try:
         merchant_id = current_user.get("merchant_id")
         branch_id = current_user.get("branch_id")
 
-        # Generate cache key for this specific query
-        cache_key = _generate_pos_cache_key(
-            merchant_id, branch_id, catalogue_type, search_query)
+        cache_key = _generate_pos_cache_key(merchant_id, branch_id, catalogue_type, search_query)
+        filter_criteria = _build_pos_filter_criteria(merchant_id, catalogue_type, search_query)
 
-        # Build optimized filter criteria
-        filter_criteria = _build_pos_filter_criteria(
-            merchant_id, catalogue_type, search_query
-        )
-
-        # Define async function to fetch data from database
         async def fetch_pos_catalogue_data():
-            """Fetch POS catalogue data from database"""
-            return await CatalogueService.get_pos_catalogue_aggregated(
-                filter_criteria, branch_id
-            )
+            return await CatalogueService.get_pos_catalogue_aggregated(filter_criteria, branch_id)
 
-        # Initialize cache_exists as False for logging
         cache_exists = False
-        
         try:
-            # Check if data exists in cache for logging purposes
             cache_exists = await redis_client.exists(cache_key)
         except Exception as redis_error:
-            logger.warning(
-                f"Redis connection error during cache check, proceeding without cache: {redis_error} | correlation_id={correlation_id}"
-            )
-            # If Redis is down, fetch directly from database
+            logger.warning("Redis connection error, proceeding without cache", extra={"error": str(redis_error), "correlation_id": correlation_id})
             result = await fetch_pos_catalogue_data()
-            response = {
-                "status": "success",
-                "data": result,
-                "correlation_id": correlation_id,
-                "cached": False
-            }
-            logger.info(
-                f"/catalogue/POS completed in {time.time() - start_time:.2f}s | cached: False (Redis error) | correlation_id={correlation_id}")
+            response = {"status": "success", "data": result, "correlation_id": correlation_id, "cached": False}
+            logger.info("POS catalogue completed", extra={"duration": time.time() - start_time, "cached": False, "correlation_id": correlation_id})
             return response
 
-        # Use cache with 1 hour expiry for POS data (3600 seconds)
-        result = await get_or_set_cache(
-            key=cache_key,
-            fetch_func=fetch_pos_catalogue_data,
-            expiry=3600  # 1 hour cache
-        )
-
-        response = {
-            "status": "success",
-            "data": result,
-            "correlation_id": correlation_id,
-            "cached": bool(cache_exists)
-        }
+        result = await get_or_set_cache(key=cache_key, fetch_func=fetch_pos_catalogue_data, expiry=3600)
 
-        logger.info(
-            f"/catalogue/POS completed in {time.time() - start_time:.2f}s | cached: {response.get('cached', False)} | correlation_id={correlation_id}")
+        response = {"status": "success", "data": result, "correlation_id": correlation_id, "cached": bool(cache_exists)}
+        logger.info("POS catalogue completed", extra={"duration": time.time() - start_time, "cached": bool(cache_exists), "correlation_id": correlation_id})
         return response
 
     except ValueError as ve:
-        logger.error(
-            f"Validation error: {ve} | correlation_id={correlation_id}")
+        logger.error("Validation error", extra={"error": str(ve), "correlation_id": correlation_id})
         raise HTTPException(status_code=400, detail=str(ve))
     except RuntimeError as re:
-        logger.error(
-            f"RuntimeError while listing items: {re} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("RuntimeError while listing items", extra={"correlation_id": correlation_id}, exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
     except Exception as e:
-        logger.error(
-            f"Unexpected error while listing items: {e} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("Unexpected error while listing items", extra={"correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
 
-def _build_pos_filter_criteria(
-    merchant_id: str,
-    catalogue_type: Optional[str],
-    search_query: Optional[str]
-) -> Dict[str, Any]:
-    """
-    Build optimized filter criteria for POS catalogue queries.
-
-    Performance improvements:
-    - Consolidated filter building logic
-    - Input validation and sanitization
-    - Optimized query patterns
-    """
-    # Input validation
-    if search_query and len(search_query.strip()) < 2:
-        raise ValueError("Search query must be at least 2 characters long")
-
-    # Base filter with compound index support
-    filter_criteria = {
-        "merchant_id": merchant_id,
-        "catalogue_type": {"$nin": ["BackBar"]}  # Exclude BackBar by default
-    }
-
-    # Optimize catalogue type filtering - exact match instead of regex
-    if catalogue_type:
-        if catalogue_type.lower() not in ["product", "service"]:
-            raise ValueError(
-                "Invalid catalogue_type. Must be 'product' or 'service'")
-        filter_criteria["catalogue_type"] = catalogue_type.lower()
-
-    # Optimize search query with text index if available, fallback to regex
-    if search_query:
-        search_query = search_query.strip()
-        escaped_query = re.escape(search_query)
-
-        # Use compound OR condition for better index utilization
-        filter_criteria["$or"] = [
-            # Prefix match is faster
-            {"name": {"$regex": f"^{escaped_query}", "$options": "i"}},
-            {"alias_code": {"$regex": f"^{escaped_query}", "$options": "i"}},
-            {"ean_code": escaped_query},  # Exact match for codes
-            {"sku_code": escaped_query},
-        ]
-
-    if catalogue_type == "product":
-        # Only add valid objects to $and
-        stock_condition = {
-            "$or": [
-                {"allow_negative_stock": True},
-                {
-                    "$and": [
-                        {"allow_negative_stock": False},
-                        {"stock_on_hand": {"$gt": 0}}
-                    ]
-                }
-            ]
-        }
-        if "$and" in filter_criteria:
-            filter_criteria["$and"].append(stock_condition)
-        else:
-            filter_criteria["$and"] = [stock_condition]
-    '''   # Add optimized stock conditions for products only
-    if catalogue_type == "product":
-        # Simplified stock condition logic
-        filter_criteria["$and"] = [
-            filter_criteria.get("$and", []),
-            {
-                "$or": [
-                    {"allow_negative_stock": True},
-                    {
-                        "$and": [
-                            {"allow_negative_stock": False},
-                            {"stock_on_hand": {"$gt": 0}}
-                        ]
-                    }
-                ]
-            }
-        ]'''
-
-    return filter_criteria
-
-
-def _generate_pos_cache_key(
-    merchant_id: str,
-    branch_id: Optional[str],
-    catalogue_type: Optional[str],
-    search_query: Optional[str]
-) -> str:
-    """
-    Generate a unique cache key for POS catalogue queries.
-
-    Args:
-        merchant_id: Merchant identifier
-        branch_id: Branch identifier (optional)
-        catalogue_type: Type of catalogue (product/service)
-        search_query: Search query string
-
-    Returns:
-        str: Unique cache key for the query
-    """
-    # Normalize search query for consistent caching
-    normalized_search = search_query.strip().lower() if search_query else ""
-    normalized_type = catalogue_type.lower() if catalogue_type else "all"
-    branch_suffix = f":{branch_id}" if branch_id else ":all_branches"
-
-    # Create cache key with all relevant parameters
-    cache_key = f"pos_catalogue:{merchant_id}{branch_suffix}:{normalized_type}:{normalized_search}"
-
-    return cache_key
-
-
 @router.delete("/", status_code=200)
 async def delete_catalogue_item(
-    catalogue_id: str = Query(...,
-                              description="Catalogue ID as the primary identifier"),
+    catalogue_id: str = Query(..., description="Catalogue ID as the primary identifier"),
     current_user: dict = Depends(require_delete_catalogue_permission),
     correlation_id: str = Depends(get_request_id)
 ) -> Dict[str, Any]:
-    """
-    Delete a catalogue item based on merchant_id, location_id, and catalogue_id.
-
-    Args:
-        catalogue_id (str): The catalogue ID of the item to delete.
-
-    Returns:
-        dict: Success message or error message if the item was not found.
-
-    Raises:
-        HTTPException:
-            - 400 if any of the IDs are invalid.
-            - 404 if the item is not found.
-            - 500 if an error occurs during the deletion.
-    """
+    """Delete a catalogue item."""
     start_time = time.time()
     try:
         merchant_id = current_user.get("merchant_id")
-        filter_criteria = {
-            "merchant_id": merchant_id,
-            "catalogue_id": catalogue_id,
-        }
+        filter_criteria = {"merchant_id": merchant_id, "catalogue_id": catalogue_id}
         response = await CatalogueService.delete_item(filter_criteria)
         if response["message"] == "Catalogue item deleted":
-            logger.info(
-                f"/catalogue {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+            logger.info("Catalogue deleted", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
             return {**response, "correlation_id": correlation_id}
         else:
-            raise HTTPException(
-                status_code=404, detail="Catalogue item not found")
+            raise HTTPException(status_code=404, detail="Catalogue item not found")
     except ValueError as ve:
-        logger.error(
-            f"ValueError while deleting item: {ve} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("ValueError while deleting item", extra={"correlation_id": correlation_id}, exc_info=ve)
         raise HTTPException(status_code=400, detail=str(ve))
     except RuntimeError as re:
-        logger.error(
-            f"RuntimeError while deleting item: {re} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("RuntimeError while deleting item", extra={"correlation_id": correlation_id}, exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
 
 
@@ -419,15 +208,12 @@ async def get_catalogue_inventory(
     current_user: dict = Depends(require_view_catalogue_permission),
     correlation_id: str = Depends(get_request_id)
 ) -> Dict[str, Any]:
-    """
-    Get inventory details for a specific catalogue item.
-    """
+    """Get inventory details for a specific catalogue item."""
     start_time = time.time()
     try:
         merchant_id = current_user.get("merchant_id")
         result = await CatalogueService.get_inventory_by_id(merchant_id, catalogue_id)
-        logger.info(
-            f"/catalogue/inventory completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        logger.info("Catalogue inventory retrieved", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
         return {**result, "correlation_id": correlation_id}
     except ValueError as ve:
         raise HTTPException(status_code=400, detail=str(ve))
@@ -447,14 +233,11 @@ async def update_catalogue_inventory(
     try:
         merchant_id = current_user.get("merchant_id")
         data["updated_by"] = current_user["associate_id"]
-        # update branch_inventory in postgressql
         result = await catalogue_service.CatalogueService.update_catalogue_inventory(catalogue_id, branch_id, merchant_id, data)
-        logger.info(
-            f"/catalogue/inventory/{catalogue_id} completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        logger.info("Catalogue inventory updated", extra={"catalogue_id": catalogue_id, "duration": time.time() - start_time, "correlation_id": correlation_id})
         return {**result, "correlation_id": correlation_id}
     except RuntimeError as re:
-        logger.error(
-            f"RuntimeError while updating catalogue: {re} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("RuntimeError while updating catalogue", extra={"correlation_id": correlation_id}, exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
 
 
@@ -464,9 +247,7 @@ async def get_catalogue(
     current_user: dict = Depends(require_view_catalogue_permission),
     correlation_id: str = Depends(get_request_id)
 ) -> Dict[str, Any]:
-    """
-    Fetches information for a single catalogue item by their ID.
-    """
+    """Fetches information for a single catalogue item by their ID."""
     start_time = time.time()
     try:
         merchant_id = current_user.get("merchant_id")
@@ -474,19 +255,15 @@ async def get_catalogue(
         if not catalogue_data:
             raise HTTPException(status_code=404, detail="catalogue not found")
         result = catalogue_utils.sanitize_document_for_mongo(catalogue_data)
-        logger.info(
-            f"/catalogue/ /items/{id} completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        logger.info("Catalogue retrieved", extra={"catalogue_id": catalogue_id, "duration": time.time() - start_time, "correlation_id": correlation_id})
         return {**result, "correlation_id": correlation_id}
 
     except HTTPException as http_err:
-        # Log specific HTTP exceptions without re-wrapping them
-        logger.warning(
-            f"catalogue retrieval failed: {http_err.detail} | id={id}, merchant_id={merchant_id} | correlation_id={correlation_id}")
+        logger.warning("Catalogue retrieval failed", extra={"detail": http_err.detail, "catalogue_id": catalogue_id, "merchant_id": merchant_id, "correlation_id": correlation_id})
         raise
 
     except Exception as e:
-        logger.error(
-            f"Unexpected error while fetching catalogue | id={id}, merchant_id={merchant_id}: {e} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("Unexpected error while fetching catalogue", extra={"catalogue_id": catalogue_id, "merchant_id": merchant_id, "correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
 
@@ -500,7 +277,6 @@ async def bulk_import_catalogue_items(
     try:
         merchant_id = current_user["merchant_id"]
         created_by = current_user["associate_id"]
-        # Add merchant_id and created_by to each item
         items = []
         for item in payload.root:
             item_dict = item.model_dump()
@@ -509,14 +285,11 @@ async def bulk_import_catalogue_items(
             item_dict["created_by"] = created_by
             items.append(item_dict)
         result = await CatalogueService.bulk_import(items)
-        logger.info(
-            f"/catalogue/items/bulk-import completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        logger.info("Bulk import completed", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
         return {"message": "Catalogue items imported successfully", "inserted_count": result, "correlation_id": correlation_id}
     except Exception as e:
-        logger.error(
-            f"Error during file upload: {e} | correlation_id={correlation_id}", exc_info=True)
-        raise HTTPException(
-            status_code=500, detail="Failed to process the file.")
+        logger.error("Error during bulk import", extra={"correlation_id": correlation_id}, exc_info=e)
+        raise HTTPException(status_code=500, detail="Failed to process the file.")
 
 
 @router.post("/items/bulk-upload-file", response_model=BulkUploadResponse)
@@ -528,47 +301,39 @@ async def bulk_upload_catalogues_file(
     start_time = time.time()
     try:
         file_ext = file.filename.split('.')[-1].lower()
-        logger.info(f"Received file: {file.filename} with type: {file_ext}")
+        logger.info("Received file", extra={"filename": file.filename, "type": file_ext})
 
         content = await file.read()
-        records = []
 
         if file_ext == "csv":
             try:
                 df = pd.read_csv(StringIO(content.decode("utf-8")))
             except Exception as e:
-                logger.error(f"Failed to parse CSV file: {e}")
-                raise HTTPException(
-                    status_code=400, detail="Invalid CSV format.")
+                logger.error("Failed to parse CSV file", exc_info=e)
+                raise HTTPException(status_code=400, detail="Invalid CSV format.")
         elif file_ext in ("xlsx", "xls"):
             try:
                 df = pd.read_excel(BytesIO(content))
             except Exception as e:
-                logger.error(f"Failed to parse Excel file: {e}")
-                raise HTTPException(
-                    status_code=400, detail="Invalid Excel format.")
+                logger.error("Failed to parse Excel file", exc_info=e)
+                raise HTTPException(status_code=400, detail="Invalid Excel format.")
         else:
-            raise HTTPException(
-                status_code=400, detail="Unsupported file type. Use CSV or Excel.")
+            raise HTTPException(status_code=400, detail="Unsupported file type. Use CSV or Excel.")
 
         records = df.fillna("").to_dict(orient="records")
 
         if not records:
-            raise HTTPException(
-                status_code=400, detail="Uploaded file is empty or invalid.")
+            raise HTTPException(status_code=400, detail="Uploaded file is empty or invalid.")
 
-        logger.info(f"Parsed {len(records)} records from file.")
+        logger.info("Parsed records from file", extra={"count": len(records)})
 
         result = await CatalogueService.bulk_upload_catalogues(records, current_user)
-        logger.info(
-            f"/catalogue/items/bulk-upload-file completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        logger.info("Bulk upload completed", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
         return {**result, "correlation_id": correlation_id}
 
     except Exception as e:
-        logger.error(
-            f"Error during file upload: {e} | correlation_id={correlation_id}", exc_info=True)
-        raise HTTPException(
-            status_code=500, detail="Failed to process the file.")
+        logger.error("Error during file upload", extra={"correlation_id": correlation_id}, exc_info=e)
+        raise HTTPException(status_code=500, detail="Failed to process the file.")
 
 
 @router.get("/info/widgets", status_code=200)
@@ -582,28 +347,21 @@ async def get_info_widgets(
         associate_id = current_user["associate_id"]
         branch_id = current_user.get("branch_id")
 
-        logger.info(
-            f"Fetching info widgets for merchant_id={merchant_id}, associate_id={associate_id}, branch_id={branch_id} | correlation_id={correlation_id}")
+        logger.info("Fetching info widgets", extra={"merchant_id": merchant_id, "associate_id": associate_id, "branch_id": branch_id, "correlation_id": correlation_id})
 
         result = await CatalogueService.get_info_widget_data(merchant_id, associate_id, branch_id)
 
-        # Handle case where result is None
         if result is None:
-            logger.warning(
-                f"No widget data found for merchant_id={merchant_id}, associate_id={associate_id} | correlation_id={correlation_id}")
+            logger.warning("No widget data found", extra={"merchant_id": merchant_id, "associate_id": associate_id, "correlation_id": correlation_id})
             return {"data": {}, "correlation_id": correlation_id}
 
-        # Handle case where result is not a dictionary
         if not isinstance(result, dict):
-            logger.warning(
-                f"Widget data is not a dictionary: {type(result)} | correlation_id={correlation_id}")
+            logger.warning("Widget data is not a dictionary", extra={"type": type(result).__name__, "correlation_id": correlation_id})
             return {"data": result, "correlation_id": correlation_id}
-        logger.info(
-            f"/catalogue/info/widgets completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+            
+        logger.info("Info widgets completed", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
         return {**result, "correlation_id": correlation_id}
 
     except Exception as e:
-        logger.error(
-            f"Error while fetching info widgets: {e} | correlation_id={correlation_id}", exc_info=True)
-        raise HTTPException(
-            status_code=500, detail="Unable to fetch dashboard widgets")
+        logger.error("Error while fetching info widgets", extra={"correlation_id": correlation_id}, exc_info=e)
+        raise HTTPException(status_code=500, detail="Unable to fetch dashboard widgets")

app/routers/gift_card_router.py

@@ -1,9 +1,8 @@
-
 from datetime import datetime, timezone
-import logging
 import time
 from typing import Any, Dict, Optional
 from fastapi import APIRouter, Body, Depends, HTTPException, Query, Path
+from insightfy_utils.logging import get_logger
 
 from app.repositories.gift_card_repository import GiftCardRepository
 from app.services.gift_card_service import GiftCardService
@@ -24,7 +23,7 @@ from app.utils.request_id_utils import get_request_id
 
 # Router Initialization
 router = APIRouter()
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 # Constants
 INTERNAL_SERVER_ERROR = "Internal server error"
@@ -48,71 +47,37 @@ async def require_delete_giftcard_permission(current_user: dict = Depends(get_cu
 
 # Route Handlers
 
-@router.post("/", status_code=201,response_model=GiftCardTemplateCreateResponse)
+@router.post("/", status_code=201, response_model=GiftCardTemplateCreateResponse)
 async def create_gift_card_template(
     template_data: GiftCardTemplateCreate,
     current_user: dict = Depends(require_create_giftcard_permission),
     correlation_id: str = Depends(get_request_id)
 ) -> GiftCardTemplateCreateResponse:
-    """
-    Create a new gift card template (blueprint).
-    
-    This endpoint allows merchants to create gift card templates that define
-    the characteristics and rules for gift cards that can be issued later.
-    
-    **Business Rules:**
-    - Physical cards must have max_issues specified
-    - Physical cards cannot be reloadable
-    - Either allow_custom_amount must be True or predefined_amounts must be provided
-    - Template names must be unique within a merchant
-    
-    **Example Request:**
-    ```json
-    {
-        "name": "Birthday Card",
-        "description": "Special card for birthdays",
-        "delivery_type": "digital",
-        "currency": "INR",
-        "validity_days": 365,
-        "allow_custom_amount": true,
-        "predefined_amounts": [500, 1000, 2000],
-        "reloadable": false,
-        "allow_partial_redemption": true,
-        "requires_pin": true,
-        "requires_otp": false,
-        "status": "active",
-        "design_template": {
-            "theme": "blue",
-            "image_url": "https://..."
-        }
-    }
-    ```
-    """
+    """Create a new gift card template (blueprint)."""
     start_time = time.time()
     try:
         merchant_id = current_user.get("merchant_id")
         user_id = current_user.get("associate_id")
-        branch_id=current_user.get("branch_id")
+        branch_id = current_user.get("branch_id")
         
         if not merchant_id:
             raise HTTPException(status_code=400, detail=MERCHANT_ID_REQUIRED)
         if not user_id:
             raise HTTPException(status_code=400, detail=USER_ID_REQUIRED)
         
-        logger.info(f"Creating gift card template for merchant {merchant_id} by user {user_id}")
+        logger.info("Creating gift card template", extra={"merchant_id": merchant_id, "user_id": user_id})
         
-        result = await GiftCardService.create_template(template_data, merchant_id, user_id,branch_id)
+        result = await GiftCardService.create_template(template_data, merchant_id, user_id, branch_id)
     
-        logger.info(f"/customer/ Gift card template created successfully: {result} in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
-        return {"template_id": result,"message":"Gift card template created successfully" , "correlation_id": correlation_id}
+        logger.info("Gift card template created", extra={"template_id": result, "duration": time.time() - start_time, "correlation_id": correlation_id})
+        return {"template_id": result, "message": "Gift card template created successfully", "correlation_id": correlation_id}
 
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Unexpected error creating gift card template: {e} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("Unexpected error creating gift card template", extra={"correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
-
 @router.post("/list", response_model=GiftCardTemplateListResponse)
 async def list_gift_card_templates(
     status: Optional[TemplateStatus] = Query(None, description="Filter by template status"),
@@ -125,28 +90,7 @@ async def list_gift_card_templates(
     current_user: dict = Depends(require_view_giftcard_permission),
     correlation_id: str = Depends(get_request_id)
 ) -> GiftCardTemplateListResponse:
-    """
-    
-    List all gift card templates with optional filtering.
-    
-    This endpoint returns a paginated list of gift card templates for the merchant
-    with optional filtering by various criteria.
-    
-    **Query Parameters:**
-    - **status**: Filter by template status (active, inactive, archived)
-    - **delivery_type**: Filter by delivery type (digital, physical)
-    - **currency**: Filter by currency (INR, USD, EUR, GBP)
-    - **branch_id**: Filter templates available for specific branch
-    - **campaign_id**: Filter templates linked to specific campaign
-    - **created_by**: Filter by creator user ID
-    - **offset**: Number of items to skip (for pagination)
-    - **limit**: Maximum items to return (1-1000)
-    
-    **Response includes:**
-    - List of templates matching the criteria
-    - Total count of matching templates
-    - Pagination information
-    """
+    """List all gift card templates with optional filtering."""
     start_time = time.time()
     try:
         merchant_id = current_user.get("merchant_id")
@@ -154,7 +98,6 @@ async def list_gift_card_templates(
         if not merchant_id:
             raise HTTPException(status_code=400, detail=MERCHANT_ID_REQUIRED)
         
-        # Build filter object
         filters = GiftCardTemplateFilter(
             status=status,
             delivery_type=delivery_type,
@@ -162,16 +105,16 @@ async def list_gift_card_templates(
             branch_id=branch_id,
             filter=filter
         )
-        logger.info(f"Fetching gift card templates for merchant {merchant_id}")
+        logger.info("Fetching gift card templates", extra={"merchant_id": merchant_id})
         
         result = await GiftCardService.list_gift_card(merchant_id, filters, offset, limit)
-        logger.info(f"/customer/list Retrieved {len(result.templates)} gift card templates in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        logger.info("Gift card templates retrieved", extra={"count": len(result.templates), "duration": time.time() - start_time, "correlation_id": correlation_id})
         return result
         
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Unexpected error fetching gift card templates: {e} correlation_id={correlation_id}", exc_info=True)
+        logger.error("Unexpected error fetching gift card templates", extra={"correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
     
 @router.put("/{template_id}")
@@ -181,34 +124,7 @@ async def update_gift_card_template(
     current_user: dict = Depends(require_update_giftcard_permission),
     correlation_id: str = Depends(get_request_id)
 ) -> Dict[str, Any]:
-    """
-    Update an existing gift card template.
-    
-    This endpoint allows updating specific fields of a gift card template.
-    Some fields have restrictions based on business rules.
-    
-    **Path Parameters:**
-    - **template_id**: The unique identifier of the gift card template
-    
-    **Business Rules:**
-    - Cannot change delivery_type of existing template
-    - Physical cards cannot be made reloadable
-    - Cannot reduce max_issues below current issued_count
-    - Physical cards must always have max_issues specified
-    
-    **Common Use Cases:**
-    - Deactivate template: `{"status": "inactive"}`
-    - Update predefined amounts: `{"predefined_amounts": [1000, 2000]}`
-    - Change design: `{"design_template": {"theme": "gold", "image_url": "..."}}`
-    
-    **Example Request:**
-    ```json
-    {
-        "status": "inactive",
-        "predefined_amounts": [1000, 2000]
-    }
-    ```
-    """
+    """Update an existing gift card template."""
     start_time = time.time()
     try:
         merchant_id = current_user.get("merchant_id")
@@ -216,48 +132,29 @@ async def update_gift_card_template(
         if not merchant_id:
             raise HTTPException(status_code=400, detail=MERCHANT_ID_REQUIRED)
         
-        logger.info(f"Updating gift card template {template_id} for merchant {merchant_id}")
+        logger.info("Updating gift card template", extra={"template_id": template_id, "merchant_id": merchant_id})
         
         result = await GiftCardService.update_template(template_id, update_data, merchant_id)
         
-        logger.info(f"Gift card template updated successfully: {template_id}")
-        logger.info(f"/customer/{template_id} Gift card template updated successfully: {template_id} in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
-        return {"status": "success","id": result.id,"data":result, "correlation_id": correlation_id}
+        logger.info("Gift card template updated", extra={"template_id": template_id, "duration": time.time() - start_time, "correlation_id": correlation_id})
+        return {"status": "success", "id": result.id, "data": result, "correlation_id": correlation_id}
         
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Unexpected error updating gift card template {template_id}: {e}", exc_info=True)
+        logger.error("Unexpected error updating gift card template", extra={"template_id": template_id}, exc_info=e)
         raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
-
 @router.delete("/{template_id}")
 async def delete_gift_card_template(
     template_id: str = Path(..., description=TEMPLATE_ID_DESCRIPTION),
     current_user: dict = Depends(require_delete_giftcard_permission),
     correlation_id: str = Depends(get_request_id)
 ) -> dict:
-    """
-    Delete a gift card template.
-    
-    This endpoint deletes a gift card template. Templates can only be deleted
-    if no gift cards have been issued from them.
-    
-    **Path Parameters:**
-    - **template_id**: The unique identifier of the gift card template
-    
-    **Business Rules:**
-    - Cannot delete templates that have issued_count > 0
-    - Consider deactivating instead of deleting for templates with issued cards
-    
-    **Security:**
-    - Only allows deletion of templates that belong to the authenticated merchant
-    """
+    """Delete a gift card template."""
     start_time = time.time()
     try:
         merchant_id = current_user.get("merchant_id")
-      
-        
         
         if not merchant_id:
             raise HTTPException(status_code=400, detail=MERCHANT_ID_REQUIRED)
@@ -265,16 +162,10 @@ async def delete_gift_card_template(
         template = await GiftCardService.get_template_by_id(template_id, merchant_id)
         
         if template["merchant_id"] != merchant_id:
-            raise HTTPException(
-                status_code=403,
-                detail="You are not authorized to delete this template."
-            )
+            raise HTTPException(status_code=403, detail="You are not authorized to delete this template.")
 
         if template.get("issued_count", 0) > 0:
-            data={
-                "status":"inactive",
-                "updated_at": datetime.now(timezone.utc)
-            }
+            data = {"status": "inactive", "updated_at": datetime.now(timezone.utc)}
             success = await GiftCardRepository.update_template(template_id, data)
             return {
                 "status": "success",
@@ -282,130 +173,87 @@ async def delete_gift_card_template(
                 "message": "Template has issued cards and was deactivated instead of deleted."
             }
                    
-        logger.info(f"Deleting gift card template {template_id} for merchant {merchant_id}")
+        logger.info("Deleting gift card template", extra={"template_id": template_id, "merchant_id": merchant_id})
         
         result = await GiftCardService.delete_template(template_id, merchant_id)
         
-        logger.info(f"Gift card template deleted successfully: {template_id} in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
-        return {"status": "success","message": f"Template {template_id} deleted successfully", "correlation_id": correlation_id}
+        logger.info("Gift card template deleted", extra={"template_id": template_id, "duration": time.time() - start_time, "correlation_id": correlation_id})
+        return {"status": "success", "message": f"Template {template_id} deleted successfully", "correlation_id": correlation_id}
         
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Unexpected error deleting gift card template {template_id}: {e}", exc_info=True)
+        logger.error("Unexpected error deleting gift card template", extra={"template_id": template_id}, exc_info=e)
         raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
-
 @router.get("/{template_id}", response_model=GiftCardTemplateResponse)
 async def get_gift_card_template(
     template_id: str = Path(..., description=TEMPLATE_ID_DESCRIPTION),
     current_user: dict = Depends(require_view_giftcard_permission)
 ) -> GiftCardTemplateResponse:
-    """
-    Get a specific gift card template by ID.
-    
-    This endpoint returns detailed information about a specific gift card template.
-    
-    **Path Parameters:**
-    - **template_id**: The unique identifier of the gift card template
-    
-    **Security:**
-    - Only returns templates that belong to the authenticated merchant
-    - Returns 404 if template doesn't exist or doesn't belong to merchant
-    """
+    """Get a specific gift card template by ID."""
     try:
         merchant_id = current_user.get("merchant_id")
         
         if not merchant_id:
             raise HTTPException(status_code=400, detail=MERCHANT_ID_REQUIRED)
         
-        logger.info(f"Fetching gift card template {template_id} for merchant {merchant_id}")
+        logger.info("Fetching gift card template", extra={"template_id": template_id, "merchant_id": merchant_id})
         
         result = await GiftCardService.get_template_by_id(template_id, merchant_id)
         
-        logger.info(f"Retrieved gift card template: {template_id}")
+        logger.info("Gift card template retrieved", extra={"template_id": template_id})
         return result
         
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Unexpected error fetching gift card template {template_id}: {e}", exc_info=True)
+        logger.error("Unexpected error fetching gift card template", extra={"template_id": template_id}, exc_info=e)
         raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
-
-
-
-# Additional utility endpoints
-
 @router.get("/{template_id}/stock", response_model=GiftCardStockResponse)
 async def check_gift_card_template_stock(
     template_id: str = Path(..., description=TEMPLATE_ID_DESCRIPTION),
     current_user: dict = Depends(require_view_giftcard_permission)
 ) -> GiftCardStockResponse:
-    """
-    Check stock availability for a gift card template.
-    
-    This endpoint returns information about whether a template has available
-    stock for issuing new gift cards.
-    
-    **Path Parameters:**
-    - **template_id**: The unique identifier of the gift card template
-    
-    **Response:**
-    - **available**: Whether cards can be issued from this template
-    - **unlimited**: Whether the template has unlimited stock (digital cards)
-    - **remaining**: Number of cards remaining (null for unlimited)
-    - **max_issues**: Maximum number of cards that can be issued
-    - **issued_count**: Number of cards already issued
-    """
+    """Check stock availability for a gift card template."""
     try:
         merchant_id = current_user.get("merchant_id")
         
         if not merchant_id:
             raise HTTPException(status_code=400, detail=MERCHANT_ID_REQUIRED)
         
-        logger.info(f"Checking stock for gift card template {template_id}")
+        logger.info("Checking stock for gift card template", extra={"template_id": template_id})
         
         result = await GiftCardService.check_stock_availability(template_id, merchant_id)
-        
         return result
         
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Unexpected error checking stock for template {template_id}: {e}", exc_info=True)
+        logger.error("Unexpected error checking stock", extra={"template_id": template_id}, exc_info=e)
         raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
-
 @router.get("/active/list", response_model=list[GiftCardTemplateResponse])
 async def get_active_gift_card_templates(
     current_user: dict = Depends(require_view_giftcard_permission)
 ) -> list[GiftCardTemplateResponse]:
-    """
-    Get all active gift card templates for the merchant.
-    
-    This is a convenience endpoint that returns only active templates,
-    commonly used for displaying available templates to customers.
-    
-    **Returns:**
-    - List of all active gift card templates for the merchant
-    - Templates are sorted by creation date (newest first)
-    """
+    """Get all active gift card templates for the merchant."""
     try:
         merchant_id = current_user.get("merchant_id")
         
         if not merchant_id:
             raise HTTPException(status_code=400, detail=MERCHANT_ID_REQUIRED)
         
-        logger.info(f"Fetching active gift card templates for merchant {merchant_id}")
+        logger.info("Fetching active gift card templates", extra={"merchant_id": merchant_id})
         
         result = await GiftCardService.get_active_templates(merchant_id)
         
-        logger.info(f"Retrieved {len(result)} active gift card templates")
+        logger.info("Active gift card templates retrieved", extra={"count": len(result)})
         return result
         
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Unexpected error fetching active gift card templates: {e}", exc_info=True)
+        logger.error("Unexpected error fetching active gift card templates", exc_info=e)
         raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)

app/routers/promotion_router.py

@@ -1,13 +1,22 @@
 from datetime import datetime
-import logging
 import time
 from typing import Any, Dict, Optional
 import uuid
-from fastapi import APIRouter, Body, Depends, HTTPException, Query, logger, UploadFile, File
-from fastapi.responses import FileResponse 
+from fastapi import APIRouter, Body, Depends, HTTPException, Query, UploadFile, File
+from fastapi.responses import FileResponse
+from insightfy_utils.logging import get_logger
 
 from app.schemas.promotion_schema import PromotionMetaData, PromotionUpdate, PromotionValidateRequest
 from app.dependencies.auth import get_current_user, require_permission, AccessID
+from app.utils.request_id_utils import get_request_id
+from app.utils.user_role_enum import UserRole
+from app.services import promotion_service
+
+from io import StringIO, BytesIO
+import pandas as pd
+
+logger = get_logger(__name__)
+router = APIRouter()
 
 # Async wrappers for permission dependencies
 async def require_create_promotion_permission(current_user: dict = Depends(get_current_user)):
@@ -19,17 +28,6 @@ async def require_view_promotion_permission(current_user: dict = Depends(get_cur
 async def require_update_promotion_permission(current_user: dict = Depends(get_current_user)):
     return await require_permission(AccessID.UPDATE_PROMOTION.value, current_user)
 
-from app.utils.request_id_utils import get_request_id
-from app.utils.user_role_enum import UserRole
-from app.services import promotion_service
-
-from io import StringIO, BytesIO
-import pandas as pd
-
-
-logger = logging.getLogger(__name__)
-router=APIRouter()
-
 @router.post("/", status_code=201)
 async def create_promotion(
     promotion_meta: PromotionMetaData = Body(..., description="promotion details"),
@@ -38,12 +36,11 @@ async def create_promotion(
 ):
     start_time = time.time()
     promotion_meta.merchant_id = current_user["merchant_id"]
-    promotion_meta.promotion_id=str(uuid.uuid4())
+    promotion_meta.promotion_id = str(uuid.uuid4())
     promotion_id = await promotion_service.PromotionManagementServices.create_promotion_data(promotion_meta)
-    logger.info(f"/promotion/ create completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+    logger.info("Promotion created", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
     return {"promotion_id": promotion_id, "correlation_id": correlation_id}
 
-    
 @router.get("/", status_code=200)
 async def list_promotions(
     status: Optional[str] = Query(None, description="Promotion status filter"),
@@ -60,18 +57,17 @@ async def list_promotions(
             merchant_id, status, is_active, q, sort, offset, limit
         )
     except RuntimeError as re:
-        logger.error(f"RuntimeError while listing Promotion: {re}", exc_info=True)
+        logger.error("RuntimeError while listing Promotion", exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
 
-
-@router.post('/apply',status_code=201)
-async def validate_promotion(            
-       data: PromotionValidateRequest = Body(..., description="promotion data to apply"),
-    ):
+@router.post('/apply', status_code=201)
+async def validate_promotion(
+    data: PromotionValidateRequest = Body(..., description="promotion data to apply"),
+):
     try:
         return await promotion_service.PromotionManagementServices.validate_promotion(data)
     except RuntimeError as re:
-        logger.error(f"RuntimeError while applying Promotion: {re}", exc_info=True)
+        logger.error("RuntimeError while applying Promotion", exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
 
 @router.get("/info/widgets", status_code=200)
@@ -85,31 +81,25 @@ async def get_info_widgets(
         associate_id = current_user["associate_id"]
         branch_id = current_user.get("branch_id")
 
-        logger.info(
-            f"Fetching info widgets for merchant_id={merchant_id}, associate_id={associate_id}, branch_id={branch_id} | correlation_id={correlation_id}")
+        logger.info("Fetching info widgets", extra={"merchant_id": merchant_id, "associate_id": associate_id, "branch_id": branch_id, "correlation_id": correlation_id})
 
         result = await promotion_service.PromotionManagementServices.get_info_widget_data(merchant_id, associate_id, branch_id)
 
         if result is None:
-            logger.warning(
-                f"No widget data found for merchant_id={merchant_id}, associate_id={associate_id} | correlation_id={correlation_id}")
+            logger.warning("No widget data found", extra={"merchant_id": merchant_id, "associate_id": associate_id, "correlation_id": correlation_id})
             return {"data": {}, "correlation_id": correlation_id}
 
         if not isinstance(result, dict):
-            logger.warning(
-                f"Widget data is not a dictionary: {type(result)} | correlation_id={correlation_id}")
+            logger.warning("Widget data is not a dictionary", extra={"type": type(result).__name__, "correlation_id": correlation_id})
             return {"data": result, "correlation_id": correlation_id}
-        logger.info(
-            f"/promotion/info/widgets completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+            
+        logger.info("Info widgets completed", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
         return {**result, "correlation_id": correlation_id}
 
     except Exception as e:
-        logger.error(
-            f"Error while fetching info widgets: {e} | correlation_id={correlation_id}", exc_info=True)
-        raise HTTPException(
-            status_code=500, detail="Unable to fetch dashboard widgets")
-        
-# --- ROUTER LAYER ---
+        logger.error("Error while fetching info widgets", extra={"correlation_id": correlation_id}, exc_info=e)
+        raise HTTPException(status_code=500, detail="Unable to fetch dashboard widgets")
+
 @router.put("/{promotion_id}")
 async def update_promotion(
     promotion_id: str,
@@ -127,26 +117,23 @@ async def update_promotion(
         if not promotion:
             raise HTTPException(status_code=404, detail=f"Promotion {promotion_id} not found")
         
-        logger.info(f"/promotion/{promotion_id} update completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
-        return {
-            "status": "success",
-            "data": promotion,
-            "correlation_id": correlation_id
-        }
+        logger.info("Promotion updated", extra={"promotion_id": promotion_id, "duration": time.time() - start_time, "correlation_id": correlation_id})
+        return {"status": "success", "data": promotion, "correlation_id": correlation_id}
+        
     except HTTPException:
         raise
     except ValueError as ve:
-        logger.error(f"Validation error while updating promotion {promotion_id}: {ve} | correlation_id={correlation_id}")
+        logger.error("Validation error while updating promotion", extra={"promotion_id": promotion_id, "correlation_id": correlation_id}, exc_info=ve)
         raise HTTPException(status_code=400, detail=str(ve))
     except Exception as e:
-        logger.error(f"Error while updating promotion {promotion_id}: {e} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("Error while updating promotion", extra={"promotion_id": promotion_id, "correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=500, detail="Unable to update promotion")
-    
+
 @router.get("/{promotion_id}")
 async def get_by_promotion_id(
-    promotion_id: str, 
+    promotion_id: str,
     current_user: dict = Depends(require_view_promotion_permission),
-    correlation_id: str = Depends(get_request_id) 
+    correlation_id: str = Depends(get_request_id)
 ):
     start_time = time.time()
     try:
@@ -154,18 +141,14 @@ async def get_by_promotion_id(
         if not promotion_data:
             raise HTTPException(status_code=404, detail="promotion id not found")
         
-        logger.info(f"/promotion/{promotion_id} fetch completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
-        return {
-            "status": "success",
-            "data": promotion_data,
-            "correlation_id": correlation_id
-        }
+        logger.info("Promotion fetched", extra={"promotion_id": promotion_id, "duration": time.time() - start_time, "correlation_id": correlation_id})
+        return {"status": "success", "data": promotion_data, "correlation_id": correlation_id}
+        
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Error while fetching promotion {promotion_id}: {e} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("Error while fetching promotion", extra={"promotion_id": promotion_id, "correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=500, detail="Unable to fetch promotion")
 
-        
-    
-        
+
+

app/routers/supplier_route.py

@@ -1,9 +1,8 @@
-
 from datetime import date
-import logging
 import time
 from typing import Any, Dict, List, Optional
 from fastapi import APIRouter, Body, Depends, File, HTTPException, Path, Query, UploadFile
+from insightfy_utils.logging import get_logger
 
 from app.dependencies.auth import get_current_user, require_permission, AccessID
 
@@ -25,12 +24,13 @@ from app.services.supplier_service import SupplierService
 from app.utils import catalogue_utils
 from app.utils.request_id_utils import get_request_id
 
-router=APIRouter()
-logger = logging.getLogger(__name__)
+router = APIRouter()
+logger = get_logger(__name__)
 
 
 @router.post("/", status_code=201)
-async def create_supplier(data: Supplier,
+async def create_supplier(
+    data: Supplier,
     current_user: dict = Depends(require_create_supplier_permission),
     correlation_id: str = Depends(get_request_id)
 ):
@@ -39,16 +39,16 @@ async def create_supplier(data: Supplier,
         # Call the service layer to create the item
         data.merchant_id = current_user["merchant_id"]
         supplier_id = await SupplierService.create_supplier(data)
-        logger.info(f"/supplier/ create completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        logger.info("Supplier created", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
         return {"supplier_id": supplier_id, "correlation_id": correlation_id}
     except RuntimeError as re:
-        logger.error(f"RuntimeError while creating supplier: {re}  | correlation_id={correlation_id}", exc_info=True)
+        logger.error("RuntimeError while creating supplier", extra={"correlation_id": correlation_id}, exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
     except Exception as e:
-        logger.error(f"Unexpected error while creating item: {e} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("Unexpected error while creating supplier", extra={"correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=500, detail="Internal server error")
 
-@router.get("/{supplier_id}",status_code=200)
+@router.get("/{supplier_id}", status_code=200)
 async def get_supplier(
     supplier_id: str = Path(..., description="ID"),
     current_user: dict = Depends(require_view_supplier_permission),
@@ -56,21 +56,20 @@ async def get_supplier(
 ):
     start_time = time.time()
     try:
-        merchant_id = current_user.get("merchant_id")  
+        merchant_id = current_user.get("merchant_id")
         supplier_data = await SupplierService.get_supplier_data(supplier_id, merchant_id)
         if not supplier_data:
             raise HTTPException(status_code=404, detail="Supplier not found")
-        result=  catalogue_utils.sanitize_document_for_mongo(supplier_data)
-        logger.info(f"/suppliers/{{supplier_id}} completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        result = catalogue_utils.sanitize_document_for_mongo(supplier_data)
+        logger.info("Supplier retrieved", extra={"supplier_id": supplier_id, "duration": time.time() - start_time, "correlation_id": correlation_id})
         return {**result, "correlation_id": correlation_id}
     
     except HTTPException as http_err:
-        # Log specific HTTP exceptions without re-wrapping them
-        logger.warning(f"Supplier retrieval failed: {http_err.detail} | supplier_id={supplier_id}, merchant_id={merchant_id} | correlation_id={correlation_id}")
+        logger.warning("Supplier retrieval failed", extra={"detail": http_err.detail, "supplier_id": supplier_id, "merchant_id": merchant_id, "correlation_id": correlation_id})
         raise
 
     except Exception as e:
-        logger.error(f"Unexpected error while fetching Supplier | supplier_id={supplier_id}, merchant_id={merchant_id}: {e} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("Unexpected error while fetching supplier", extra={"supplier_id": supplier_id, "merchant_id": merchant_id, "correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=500, detail="Internal server error")
     
 @router.put("/{supplier_id}", status_code=200)
@@ -83,15 +82,14 @@ async def update_supplier(
     start_time = time.time()
     try:
         data["merchant_id"] = current_user["merchant_id"]
-        result=await SupplierService.update_supplier(supplier_id, data)    
-        logger.info(f"/supplier/{{supplier_id}} update completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        result = await SupplierService.update_supplier(supplier_id, data)
+        logger.info("Supplier updated", extra={"supplier_id": supplier_id, "duration": time.time() - start_time, "correlation_id": correlation_id})
         result_data = catalogue_utils.sanitize_document_for_mongo(result)
         return {**result_data, "correlation_id": correlation_id}
     
     except RuntimeError as re:
-        logger.error(f"RuntimeError while updating supplier: {re} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("RuntimeError while updating supplier", extra={"correlation_id": correlation_id}, exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
-    
 
 @router.delete("/{supplier_id}", status_code=200)
 async def delete_supplier(
@@ -101,34 +99,26 @@ async def delete_supplier(
 ):
     start_time = time.time()
     try:
-        # Composite filter for identifying the catalogue item
-        
-        merchant_id = current_user.get("merchant_id")  
- 
-        filter_criteria = {
-            "merchant_id": merchant_id,
-            "supplier_id": supplier_id,
-        }
+        merchant_id = current_user.get("merchant_id")
+        filter_criteria = {"merchant_id": merchant_id, "supplier_id": supplier_id}
 
         response = await SupplierService.delete_item(filter_criteria["supplier_id"])
         if response["message"] == "Supplier soft deleted":
-            logger.info(f"/Supplier/{supplier_id} {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
-            return {**response,"correlation_id": correlation_id}
+            logger.info("Supplier deleted", extra={"supplier_id": supplier_id, "duration": time.time() - start_time, "correlation_id": correlation_id})
+            return {**response, "correlation_id": correlation_id}
         else:
             raise HTTPException(status_code=404, detail="Supplier not found")
         
     except ValueError as ve:
-        logger.error(f"ValueError while deleting Supplier: {ve} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("ValueError while deleting supplier", extra={"correlation_id": correlation_id}, exc_info=ve)
         raise HTTPException(status_code=400, detail=str(ve))
     except RuntimeError as re:
-        logger.error(f"RuntimeError while deleting Supplier: {re} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("RuntimeError while deleting supplier", extra={"correlation_id": correlation_id}, exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
     except Exception as e:
-        logger.error(f"Unexpected error while deleting Supplier: {e} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("Unexpected error while deleting supplier", extra={"correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=500, detail="Internal server error")
 
-
-
 @router.post("/list", status_code=200)
 async def list_suppliers(
     payload: SupplierListFilter = Body(...),
@@ -141,12 +131,9 @@ async def list_suppliers(
         filters = payload.filters or {}
         offset = payload.offset or 0
         limit = payload.limit or 10
-
         projection_list = payload.projection_list or None
  
-        logger.info(
-            f"Listing suppliers for merchant_id={merchant_id} with filters={filters}, offset={offset}, limit={limit} | correlation_id={correlation_id}, projection_list={projection_list}"
-        )
+        logger.info("Listing suppliers", extra={"merchant_id": merchant_id, "filters": filters, "offset": offset, "limit": limit, "projection_list": projection_list, "correlation_id": correlation_id})
 
         result = await SupplierService.list_supplier_data(
             merchant_id=merchant_id,
@@ -155,49 +142,45 @@ async def list_suppliers(
             limit=limit,
             projection_list=projection_list
         )
-        logger.info(
-            f"/supplier/list completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}"
-        )
+        logger.info("Supplier list completed", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
         return {**result, "correlation_id": correlation_id}
     except Exception as e:
-        logger.error(
-            f"Error in list_suppliers: {e} | correlation_id={correlation_id}", exc_info=True
-        )
-    # Removed erroneous duplicate and unclosed method call from exception block
-    
+        logger.error("Error in list_suppliers", extra={"correlation_id": correlation_id}, exc_info=e)
+        raise HTTPException(status_code=500, detail="Internal server error")
 
 @router.post("/{supplier_id}/history", status_code=201)
 async def append_supply_history(
     supplier_id: str = Path(..., description="Supplier ID"),
-    history_entry: supply_history=None,
+    history_entry: supply_history = None,
     current_user: dict = Depends(require_update_supplier_permission),
     correlation_id: str = Depends(get_request_id)
 ):
     start_time = time.time()
     try:
-        merchant_id = current_user.get("merchant_id")  
-        result=await SupplierService.append_supply_history(supplier_id,history_entry)
-        logger.info(f"/{supplier_id}/history completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        merchant_id = current_user.get("merchant_id")
+        result = await SupplierService.append_supply_history(supplier_id, history_entry)
+        logger.info("Supply history appended", extra={"supplier_id": supplier_id, "duration": time.time() - start_time, "correlation_id": correlation_id})
         return {**result, "correlation_id": correlation_id}
     
     except Exception as e:
-        logger.error(f"RuntimeError while appending supply history: {e}  | correlation_id={correlation_id}", exc_info=True)
+        logger.error("Error while appending supply history", extra={"correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=404, detail="Supplier not found or not updated")
 
 @router.post("/{supplier_id}/documents", status_code=201)
-async def upload_document( data:Document,
+async def upload_document(
+    data: Document,
     supplier_id: str = Path(..., description="Supplier ID"),
     current_user: dict = Depends(require_update_supplier_permission),
     correlation_id: str = Depends(get_request_id)
 ):
     start_time = time.time()
     try:
-        result=await SupplierService.upload_document(data,supplier_id,)
-        logger.info(f"/{supplier_id}/upload document completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        result = await SupplierService.upload_document(data, supplier_id)
+        logger.info("Document uploaded", extra={"supplier_id": supplier_id, "duration": time.time() - start_time, "correlation_id": correlation_id})
         return {**result, "correlation_id": correlation_id}
     
     except Exception as e:
-        logger.error(f"RuntimeError while uploading document: {e}  | correlation_id={correlation_id}", exc_info=True)
+        logger.error("Error while uploading document", extra={"correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=500, detail="document not uploaded")
     
 @router.get("/info/widgets", status_code=200)
@@ -210,26 +193,21 @@ async def get_info_widgets(
         merchant_id = current_user["merchant_id"]
         branch_id = current_user.get("branch_id")
 
-        logger.info(
-            f"Fetching info widgets for merchant_id={merchant_id},  branch_id={branch_id} | correlation_id={correlation_id}")
+        logger.info("Fetching info widgets", extra={"merchant_id": merchant_id, "branch_id": branch_id, "correlation_id": correlation_id})
 
-        result = await SupplierService.get_info_widget_data(merchant_id,  branch_id)
+        result = await SupplierService.get_info_widget_data(merchant_id, branch_id)
 
         if result is None:
-            logger.warning(
-                f"No widget data found for merchant_id={merchant_id} | correlation_id={correlation_id}")
+            logger.warning("No widget data found", extra={"merchant_id": merchant_id, "correlation_id": correlation_id})
             return {"data": {}, "correlation_id": correlation_id}
 
         if not isinstance(result, dict):
-            logger.warning(
-                f"Widget data is not a dictionary: {type(result)} | correlation_id={correlation_id}")
+            logger.warning("Widget data is not a dictionary", extra={"type": type(result).__name__, "correlation_id": correlation_id})
             return {"data": result, "correlation_id": correlation_id}
-        logger.info(
-            f"/supplier/info/widgets completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+            
+        logger.info("Info widgets completed", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
         return {**result, "correlation_id": correlation_id}
 
     except Exception as e:
-        logger.error(
-            f"Error while fetching info widgets: {e} | correlation_id={correlation_id}", exc_info=True)
-        raise HTTPException(
-            status_code=500, detail="Unable to fetch dashboard widgets")
+        logger.error("Error while fetching info widgets", extra={"correlation_id": correlation_id}, exc_info=e)
+        raise HTTPException(status_code=500, detail="Unable to fetch dashboard widgets")

app/routers/taxonomy_route.py

@@ -1,7 +1,7 @@
-import logging
 import time
 from typing import Optional
 from fastapi import APIRouter, Body, Depends, HTTPException, Path, Query
+from insightfy_utils.logging import get_logger
 from app.dependencies.auth import get_current_user, require_permission, AccessID
 
 # Async wrappers for permission dependencies
@@ -21,12 +21,12 @@ from app.schemas.taxonomy_schema import TaxonomyInfo
 from app.services.taxonomy_service import TaxonomyService
 from app.utils.request_id_utils import get_request_id
 
-router=APIRouter()
-logger = logging.getLogger(__name__)
+router = APIRouter()
+logger = get_logger(__name__)
 
-@router.post("/",status_code=201)
+@router.post("/", status_code=201)
 async def create_taxonomy(
-    data:TaxonomyInfo,
+    data: TaxonomyInfo,
     current_user: dict = Depends(require_create_taxonomy_permission),
     correlation_id: str = Depends(get_request_id)
 ):
@@ -35,11 +35,11 @@ async def create_taxonomy(
         data.merchant_id = current_user["merchant_id"]
         data.created_by = current_user["associate_id"]
         taxonomy_id = await TaxonomyService.create_taxonomy(data)
-        logger.info(f"/taxxonomy/ create completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        logger.info("Taxonomy created", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
         return {"taxonomy_id": taxonomy_id, "correlation_id": correlation_id}
 
     except RuntimeError as re:
-        logger.error(f"RuntimeError while creating taxonomy item: {re}  | correlation_id={correlation_id}", exc_info=True)
+        logger.error("RuntimeError while creating taxonomy", extra={"correlation_id": correlation_id}, exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
     
 @router.put("/{id}", status_code=200)
@@ -53,12 +53,12 @@ async def update_taxonomy(
     try:
         data["merchant_id"] = current_user["merchant_id"]
         data["updated_by"] = current_user["associate_id"]
-        result=await TaxonomyService.update_taxonomy(id, data)    
-        logger.info(f"/taxonomy/{{id}} update completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        result = await TaxonomyService.update_taxonomy(id, data)
+        logger.info("Taxonomy updated", extra={"id": id, "duration": time.time() - start_time, "correlation_id": correlation_id})
         result_data = serialize_mongo_document(result)
         return {**result_data, "correlation_id": correlation_id}
     except RuntimeError as re:
-        logger.error(f"RuntimeError while updating taxonomy: {re} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("RuntimeError while updating taxonomy", extra={"correlation_id": correlation_id}, exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
   
 @router.delete("/", status_code=200)
@@ -67,25 +67,23 @@ async def delete_taxonomy(
     current_user: dict = Depends(require_delete_taxonomy_permission),
     correlation_id: str = Depends(get_request_id)
 ):
-
     start_time = time.time()
     try:
-    
         response = await TaxonomyService.delete_taxonomy(id)
         if response["message"] == "taxonomy deleted":
-            logger.info(f"/taxonomy {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
-            return {**response,"correlation_id": correlation_id}
+            logger.info("Taxonomy deleted", extra={"id": id, "duration": time.time() - start_time, "correlation_id": correlation_id})
+            return {**response, "correlation_id": correlation_id}
         else:
             raise HTTPException(status_code=404, detail="Taxonomy not found")
         
     except ValueError as ve:
-        logger.error(f"ValueError while deleting item: {ve} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("ValueError while deleting taxonomy", extra={"correlation_id": correlation_id}, exc_info=ve)
         raise HTTPException(status_code=400, detail=str(ve))
     except RuntimeError as re:
-        logger.error(f"RuntimeError while deleting item: {re} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("RuntimeError while deleting taxonomy", extra={"correlation_id": correlation_id}, exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
     except Exception as e:
-        logger.error(f"Unexpected error while deleting item: {e} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("Unexpected error while deleting taxonomy", extra={"correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=500, detail="Internal server error")
     
 @router.get("/list", status_code=200)
@@ -96,30 +94,22 @@ async def list_taxonomy(
 ):
     start_time = time.time()
     try:
-        # Call the service layer to list items (no pagination for LOV data)
         merchant_id = current_user.get("merchant_id")
         
-        result = await TaxonomyService.list_taxonomy(
-            merchant_id=merchant_id,
-            type=type
-        )
-        logger.info(f"/taxonomy/list completed in {time.time() - start_time:.2f}s | correlation_id={correlation_id}")
+        result = await TaxonomyService.list_taxonomy(merchant_id=merchant_id, type=type)
+        logger.info("Taxonomy list completed", extra={"duration": time.time() - start_time, "correlation_id": correlation_id})
         
-        # Check if result is a dictionary with error message
         if isinstance(result, dict) and "message" in result and "Item not found" in result["message"]:
             return {"message": result["message"], "correlation_id": correlation_id}
         
-        # If result is a list (which seems to be the case), wrap it properly
         if isinstance(result, list):
             return {"items": result, "count": len(result), "correlation_id": correlation_id}
         
-        # Otherwise return the taxonomy structure with correlation_id (if it's a dict)
         return {**result, "correlation_id": correlation_id}
     except RuntimeError as re:
-        logger.error(f"RuntimeError while list_taxonomy: {re} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("RuntimeError while listing taxonomy", extra={"correlation_id": correlation_id}, exc_info=re)
         raise HTTPException(status_code=500, detail=str(re))
     except Exception as e:
-        logger.error(f"Error in list_taxonomy: {e} | correlation_id={correlation_id}", exc_info=True)
+        logger.error("Error in list_taxonomy", extra={"correlation_id": correlation_id}, exc_info=e)
         raise HTTPException(status_code=500, detail="Internal server error")
 
-        

app/schemas/gift_card_schema.py

@@ -226,5 +226,4 @@ class GiftCardTemplateFilter(BaseModel):
 
                 # Attach $or to main filter
                 mongo_filter["$or"] = or_conditions
-        print(mongo_filter)
         return mongo_filter

app/services/catalogue_service.py

@@ -3,16 +3,15 @@ from typing import Dict, Any, List, Optional
 from bson import ObjectId
 from fastapi import HTTPException
 from pydantic import ValidationError, TypeAdapter
+from insightfy_utils.logging import get_logger
 from app.models.catalogue_models import CatalogueModel
 from app.repositories.db import fetch_one_document
 
 
-import logging
-
 from app.schemas.catalogue_schema import CatalogueBulkImport, CatalogueItemBase, CatalogueListFilter, CatalogueUnion
 from app.utils import catalogue_utils
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 # Constants for error messages
 INTERNAL_SERVER_ERROR = "Internal server error"
@@ -30,7 +29,7 @@ class CatalogueService:
         """
         try:
             data = item.dict(by_alias=True, exclude_none=True)
-            logger.info(f"Creating catalogue item with data: {data}")
+            logger.info("Creating catalogue item", extra={"data": data})
 
             catalogue_inserted_id = await CatalogueModel.create_catalogue_item(data)
 
@@ -40,22 +39,21 @@ class CatalogueService:
             }
 
         except RuntimeError as re:
-            logger.error(f"RuntimeError while creating catalogue item: {re}", exc_info=True)
+            logger.error("RuntimeError while creating catalogue item", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
 
         except Exception as e:
-            logger.error(f"Unexpected error while creating catalogue item: {e}", exc_info=True)
+            logger.error("Unexpected error while creating catalogue item", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
         
     @staticmethod
     async def update_catalogue_item(
             catalogue_id: str,
             update_data: dict,
-            merchant_id:str
+            merchant_id: str
         ) -> dict:
 
-            result = await CatalogueModel.update_catalogue_data(catalogue_id, update_data,merchant_id)
-        
+            result = await CatalogueModel.update_catalogue_data(catalogue_id, update_data, merchant_id)
             return {"message": "Catalogue updated successfully"} if result else {"message": "No changes made"}
         
     
@@ -79,10 +77,10 @@ class CatalogueService:
                 "list_details_pref",
                 {"merchant_id": merchant_id, "associate_id": associate_id, "list_type": "catalogues"}
             )
-            logger.info(f"User preferences for {associate_id}: {user_pref}")
+            logger.info("User preferences fetched", extra={"associate_id": associate_id, "preferences": user_pref})
             return user_pref
         except Exception as e:
-            logger.warning(f"Failed to fetch user preferences: {e}")
+            logger.warning("Failed to fetch user preferences", extra={"associate_id": associate_id, "error": str(e)})
             return None
 
     @staticmethod
@@ -209,7 +207,7 @@ class CatalogueService:
         """
         List catalogue items with optional user preference filtering.
         """
-        logger.info(f"Fetching catalogues for {merchant_id=} with incoming filters={filters}")
+        logger.info("Fetching catalogues", extra={"merchant_id": merchant_id, "filters": filters})
         
         try:
             # Initialize base filter criteria
@@ -232,7 +230,13 @@ class CatalogueService:
             CatalogueService._apply_api_filters(filter_criteria, filters)
 
             logger.debug(
-                f"Final filter criteria: {filter_criteria}, offset={offset}, limit={limit}, projection={final_projection_list}"
+                "Final filter criteria",
+                extra={
+                    "filter": filter_criteria,
+                    "offset": offset,
+                    "limit": limit,
+                    "projection": final_projection_list
+                }
             )
 
             return await CatalogueModel.list_items(
@@ -244,10 +248,10 @@ class CatalogueService:
             )
 
         except RuntimeError as re:
-            logger.error(f"RuntimeError while listing items: {re}", exc_info=True)
+            logger.error("RuntimeError while listing items", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
         except Exception as e:
-            logger.error(f"Unexpected error while listing items: {e}", exc_info=True)
+            logger.error("Unexpected error while listing items", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
         
     @staticmethod
@@ -264,7 +268,7 @@ class CatalogueService:
                 raise RuntimeError("Invalid data format returned from model layer")
             return items
         except Exception as e:
-            logger.error(f"Error fetching POS catalogue items: {e}", exc_info=True)
+            logger.error("Error fetching POS catalogue items", exc_info=e)
             raise RuntimeError("Failed to fetch catalogue items") from e
 
     @staticmethod
@@ -288,7 +292,7 @@ class CatalogueService:
             )
             return result
         except Exception as e:
-            logger.error(f"Error fetching aggregated POS catalogue items: {e}", exc_info=True)
+            logger.error("Error fetching aggregated POS catalogue items", exc_info=e)
             raise RuntimeError("Failed to fetch catalogue items") from e
 
     @staticmethod
@@ -309,19 +313,18 @@ class CatalogueService:
         return items
 
     @staticmethod
-    async def update_catalogue_inventory(catalogue_id: str, branch_id: str,merchant_id: str, update_data: dict):
-       
+    async def update_catalogue_inventory(catalogue_id: str, branch_id: str, merchant_id: str, update_data: dict):
         filter_criteria = {
             "merchant_id": merchant_id,
             "branch_id": branch_id,
             "catalogue_id": catalogue_id
         }
-        result= await CatalogueModel.update_catalogue_inventory(filter_criteria, update_data)
+        result = await CatalogueModel.update_catalogue_inventory(filter_criteria, update_data)
         return {"message": "Catalogue updated successfully"} if result else {"message": "No changes made"}
 
     @staticmethod
     async def get_catalogue_data(catalogue_id: str, merchant_id: str):
-        logger.info(f"Fetching catalogue with ID: {id}")  
+        logger.info("Fetching catalogue", extra={"catalogue_id": catalogue_id})  
         try:
             catalogue_data = await CatalogueModel.get_catalogue_data(catalogue_id, merchant_id)
             if catalogue_data is None:
@@ -331,10 +334,10 @@ class CatalogueService:
             # Re-raise HTTP exceptions without modification
             raise
         except RuntimeError as re:
-            logger.error(f"RuntimeError while fetching item: {re}", exc_info=True)
+            logger.error("RuntimeError while fetching item", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
         except Exception as e:
-            logger.error(f"Unexpected error while fetching item: {e}", exc_info=True)
+            logger.error("Unexpected error while fetching item", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
     @staticmethod
@@ -342,7 +345,7 @@ class CatalogueService:
         return await CatalogueModel.bulk_insert(items)
     
     @staticmethod
-    async def bulk_upload_catalogues(data: List[dict], current_user: dict,merchant_id:str):
+    async def bulk_upload_catalogues(data: List[dict], current_user: dict, merchant_id: str):
         valid_records = []
         errors = []
 
@@ -355,13 +358,13 @@ class CatalogueService:
                 catalogue_dict["created_by"] = current_user["associate_id"]
                 valid_records.append(catalogue_dict)
             except ValidationError as ve:
-                logger.warning(f"Row {i + 1} validation error: {ve}")
+                logger.warning("Row validation error", extra={"row": i + 1, "error": str(ve)})
                 errors.append({"row": i + 1, "errors": ve.errors()})
 
         if not valid_records:
             raise RuntimeError("No valid records to insert")
 
-        inserted_ids = await CatalogueModel.bulk_create(valid_records,merchant_id)
+        inserted_ids = await CatalogueModel.bulk_create(valid_records, merchant_id)
         return {
             "inserted_count": len(inserted_ids),
             "failed_count": len(errors),
@@ -377,8 +380,7 @@ class CatalogueService:
         """
         Fetches detailed information about an catalogue, including metadata and preferences.
         """
-        logger.info(
-            f"Fetching info widget data for catalogue ID: {associate_id}")
+        logger.info("Fetching info widget data", extra={"associate_id": associate_id})
         try:
 
             # Fetch user preferences if available
@@ -393,14 +395,13 @@ class CatalogueService:
                     (view for view in user_pref["views"] if view.get("name") == "catalogues"),
                     None
                 )
-            logger.info(f"User preferences for {associate_id}: {catalogues_view}")
+            logger.info("User preferences fetched", extra={"associate_id": associate_id, "view": catalogues_view})
             catalogue_data = None
             if catalogues_view:
                 catalogue_data = await CatalogueModel.get_info_widget_data(merchant_id, branch_id, catalogues_view)
 
                 if catalogue_data is None:
-                    raise HTTPException(
-                        status_code=404, detail="Catalogue not found")
+                    raise HTTPException(status_code=404, detail="Catalogue not found")
 
                 return catalogue_data
 

app/services/gift_card_service.py

@@ -1,7 +1,7 @@
-import logging
 from typing import Any, Dict, List, Optional
 from fastapi import HTTPException
 from pydantic import ValidationError
+from insightfy_utils.logging import get_logger
 
 from app.repositories.gift_card_repository import GiftCardRepository
 from app.schemas.gift_card_schema import (
@@ -14,8 +14,7 @@ from app.schemas.gift_card_schema import (
     GiftCardStockResponse
 )
 
-# Configure logging for this module
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 # Constants for error messages
 INTERNAL_SERVER_ERROR = "Internal server error"
@@ -25,46 +24,25 @@ TEMPLATE_UPDATE_FAILED = "Failed to update gift card template"
 TEMPLATE_DELETE_FAILED = "Failed to delete gift card template"
 
 class GiftCardService:
-    """
-    Service layer for Gift Card operations.
-    Contains business logic and validation for gift card templates.
-    """
+    """Service layer for Gift Card operations."""
 
     @staticmethod
     async def create_template(
         template_data: GiftCardTemplateCreate,
         merchant_id: str,
         created_by: str,
-        branch_id:str
+        branch_id: str
     ) -> GiftCardTemplateCreateResponse:
-        """
-        Create a new gift card template.
-        
-        Args:
-            template_data (GiftCardTemplateCreate): Template data to create
-            merchant_id (str): Merchant ID
-            created_by (str): User ID who is creating the template
-            
-        Returns:
-            GiftCardTemplateCreateResponse: Created template info
-            
-        Raises:
-            HTTPException: If creation fails
-        """
+        """Create a new gift card template."""
         try:
-            # Convert Pydantic model to dict and add merchant info
             data = template_data.model_dump(by_alias=True, exclude_none=True)
             data['merchant_id'] = merchant_id
             data['created_by'] = created_by
-            data['branch_id']=branch_id
-            
-            logger.info(f"Creating gift card template for merchant {merchant_id}")
-            # check name & merchant id already exisiting or not
+            data['branch_id'] = branch_id
             
-            # Create template via repository
-            template_id = await GiftCardRepository.create_template(data,merchant_id)
+            logger.info("Creating gift card template", extra={"merchant_id": merchant_id})
             
-            # Get the created template to return full info
+            template_id = await GiftCardRepository.create_template(data, merchant_id)
             created_template = await GiftCardRepository.get_template_by_id(template_id)
             if not created_template:
                 raise HTTPException(status_code=500, detail="Template created but could not be retrieved")
@@ -72,12 +50,12 @@ class GiftCardService:
             return template_id
             
         except ValidationError as ve:
-            logger.error(f"Validation error creating template: {ve}")
+            logger.error("Validation error creating template", exc_info=ve)
             raise HTTPException(status_code=400, detail=f"Validation error: {ve}")
         except HTTPException:
             raise
         except Exception as e:
-            logger.error(f"Service error creating template: {e}", exc_info=True)
+            logger.error("Service error creating template", exc_info=e)
             raise HTTPException(status_code=500, detail=TEMPLATE_CREATION_FAILED)
 
     @staticmethod
@@ -87,37 +65,19 @@ class GiftCardService:
         offset: int = 0,
         limit: int = 100
     ) -> GiftCardTemplateListResponse:
-        """
-        Get gift card templates with pagination and filtering.
-        
-        Args:
-            merchant_id (str): Merchant ID
-            filters (Optional[GiftCardTemplateFilter]): Filter criteria
-            offset (int): Number of items to skip
-            limit (int): Maximum number of items to return
-            
-        Returns:
-            GiftCardTemplateListResponse: Paginated list of templates
-            
-        Raises:
-            HTTPException: If retrieval fails
-        """
+        """Get gift card templates with pagination and filtering."""
         try:
-            # Build filter criteria
             filter_criteria = GiftCardRepository.build_filter_criteria(merchant_id, filters)
+            logger.info("Fetching templates", extra={"merchant_id": merchant_id, "filters": filter_criteria})
             
-            logger.info(f"Fetching templates for merchant {merchant_id} with filters: {filter_criteria}")
-            
-            # Get templates from repository
             result = await GiftCardRepository.list_gift_card(filter_criteria, offset, limit)
             
-            # Convert to response models
             templates = []
             for template_data in result['templates']:
                 try:
                     templates.append(GiftCardTemplateResponse(**template_data))
                 except ValidationError as ve:
-                    logger.warning(f"Failed to parse template: {template_data}, error: {ve}")
+                    logger.warning("Failed to parse template", extra={"template": template_data, "error": str(ve)})
                     continue
             return GiftCardTemplateListResponse(
                 templates=templates,
@@ -129,36 +89,20 @@ class GiftCardService:
         except HTTPException:
             raise
         except Exception as e:
-            logger.error(f"Service error getting templates: {e}", exc_info=True)
+            logger.error("Service error getting templates", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
     @staticmethod
-    async def get_template_by_id(
-        template_id: str,
-        merchant_id: str
-    ) -> dict:
-        """
-        Get a specific gift card template by ID.
-        
-        Args:
-            template_id (str): Template ID to retrieve
-            merchant_id (str): Merchant ID for security
-            
-        Returns:
-            GiftCardTemplateResponse: Template data
-            
-        Raises:
-            HTTPException: If template not found or access denied
-        """
+    async def get_template_by_id(template_id: str, merchant_id: str) -> dict:
+        """Get a specific gift card template by ID."""
         try:
-            logger.info(f"Fetching template {template_id} for merchant {merchant_id}")
+            logger.info("Fetching template", extra={"template_id": template_id, "merchant_id": merchant_id})
             
             template = await GiftCardRepository.get_template_by_id(template_id)
             
             if not template:
                 raise HTTPException(status_code=404, detail=TEMPLATE_NOT_FOUND)
             
-            # Check if template belongs to the merchant
             if template.get('merchant_id') != merchant_id:
                 raise HTTPException(status_code=404, detail=TEMPLATE_NOT_FOUND)
             
@@ -167,10 +111,10 @@ class GiftCardService:
         except HTTPException:
             raise
         except ValidationError as ve:
-            logger.error(f"Validation error parsing template {template_id}: {ve}")
+            logger.error("Validation error parsing template", extra={"template_id": template_id}, exc_info=ve)
             raise HTTPException(status_code=500, detail="Template data validation failed")
         except Exception as e:
-            logger.error(f"Service error getting template {template_id}: {e}", exc_info=True)
+            logger.error("Service error getting template", extra={"template_id": template_id}, exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
     @staticmethod
@@ -179,24 +123,10 @@ class GiftCardService:
         update_data: GiftCardTemplateUpdate,
         merchant_id: str
     ) -> GiftCardTemplateResponse:
-        """
-        Update a gift card template.
-        
-        Args:
-            template_id (str): Template ID to update
-            update_data (GiftCardTemplateUpdate): Update data
-            merchant_id (str): Merchant ID for security
-            
-        Returns:
-            GiftCardTemplateResponse: Updated template data
-            
-        Raises:
-            HTTPException: If update fails or template not found
-        """
+        """Update a gift card template."""
         try:
-            logger.info(f"Updating template {template_id} for merchant {merchant_id}")
+            logger.info("Updating template", extra={"template_id": template_id, "merchant_id": merchant_id})
             
-            # First verify the template exists and belongs to the merchant
             existing_template = await GiftCardRepository.get_template_by_id(template_id)
             if not existing_template:
                 raise HTTPException(status_code=404, detail=TEMPLATE_NOT_FOUND)
@@ -204,56 +134,36 @@ class GiftCardService:
             if existing_template.get('merchant_id') != merchant_id:
                 raise HTTPException(status_code=404, detail=TEMPLATE_NOT_FOUND)
             
-            # Convert update data to dict, excluding None values
             update_dict = update_data.model_dump(by_alias=True, exclude_none=True)
             
             if not update_dict:
                 raise HTTPException(status_code=400, detail="No update data provided")
             
-            # Validate business rules for updates
             await GiftCardService._validate_template_update(existing_template, update_dict)
             
-            # Perform update
             success = await GiftCardRepository.update_template(template_id, update_dict)
             
             if not success:
                 raise HTTPException(status_code=500, detail=TEMPLATE_UPDATE_FAILED)
             
-            # Return updated template
             updated_template = await GiftCardRepository.get_template_by_id(template_id)
             return GiftCardTemplateResponse(**updated_template)
             
         except HTTPException:
             raise
         except ValidationError as ve:
-            logger.error(f"Validation error updating template {template_id}: {ve}")
+            logger.error("Validation error updating template", extra={"template_id": template_id}, exc_info=ve)
             raise HTTPException(status_code=400, detail=f"Validation error: {ve}")
         except Exception as e:
-            logger.error(f"Service error updating template {template_id}: {e}", exc_info=True)
+            logger.error("Service error updating template", extra={"template_id": template_id}, exc_info=e)
             raise HTTPException(status_code=500, detail=TEMPLATE_UPDATE_FAILED)
 
     @staticmethod
-    async def delete_template(
-        template_id: str,
-        merchant_id: str
-    ) -> Dict[str, str]:
-        """
-        Delete a gift card template.
-        
-        Args:
-            template_id (str): Template ID to delete
-            merchant_id (str): Merchant ID for security
-            
-        Returns:
-            Dict[str, str]: Success message
-            
-        Raises:
-            HTTPException: If deletion fails or template not found
-        """
+    async def delete_template(template_id: str, merchant_id: str) -> Dict[str, str]:
+        """Delete a gift card template."""
         try:
-            logger.info(f"Deleting template {template_id} for merchant {merchant_id}")
+            logger.info("Deleting template", extra={"template_id": template_id, "merchant_id": merchant_id})
             
-            # First verify the template exists and belongs to the merchant
             existing_template = await GiftCardRepository.get_template_by_id(template_id)
             if not existing_template:
                 raise HTTPException(status_code=404, detail=TEMPLATE_NOT_FOUND)
@@ -261,16 +171,13 @@ class GiftCardService:
             if existing_template.get('merchant_id') != merchant_id:
                 raise HTTPException(status_code=404, detail=TEMPLATE_NOT_FOUND)
             
-            # Check if template can be deleted (business rule: no issued cards)
             issued_count = existing_template.get('issued_count', 0)
             if issued_count > 0:
-                
                 raise HTTPException(
                     status_code=400,
                     detail=f"Cannot delete template with {issued_count} issued cards. Consider deactivating instead."
                 )
             
-            # Perform deletion
             success = await GiftCardRepository.delete_template(template_id)
             
             if not success:
@@ -281,31 +188,15 @@ class GiftCardService:
         except HTTPException:
             raise
         except Exception as e:
-            logger.error(f"Service error deleting template {template_id}: {e}", exc_info=True)
+            logger.error("Service error deleting template", extra={"template_id": template_id}, exc_info=e)
             raise HTTPException(status_code=500, detail=TEMPLATE_DELETE_FAILED)
 
     @staticmethod
-    async def check_stock_availability(
-        template_id: str,
-        merchant_id: str
-    ) -> GiftCardStockResponse:
-        """
-        Check stock availability for a template.
-        
-        Args:
-            template_id (str): Template ID to check
-            merchant_id (str): Merchant ID for security
-            
-        Returns:
-            GiftCardStockResponse: Stock availability info
-            
-        Raises:
-            HTTPException: If template not found or access denied
-        """
+    async def check_stock_availability(template_id: str, merchant_id: str) -> GiftCardStockResponse:
+        """Check stock availability for a template."""
         try:
-            logger.info(f"Checking stock for template {template_id}")
+            logger.info("Checking stock for template", extra={"template_id": template_id})
             
-            # First verify the template exists and belongs to the merchant
             existing_template = await GiftCardRepository.get_template_by_id(template_id)
             if not existing_template:
                 raise HTTPException(status_code=404, detail=TEMPLATE_NOT_FOUND)
@@ -313,28 +204,18 @@ class GiftCardService:
             if existing_template.get('merchant_id') != merchant_id:
                 raise HTTPException(status_code=404, detail=TEMPLATE_NOT_FOUND)
             
-            # Get stock information
             stock_info = await GiftCardRepository.check_stock_availability(template_id)
-            
             return GiftCardStockResponse(**stock_info)
             
         except HTTPException:
             raise
         except Exception as e:
-            logger.error(f"Service error checking stock for template {template_id}: {e}", exc_info=True)
+            logger.error("Service error checking stock", extra={"template_id": template_id}, exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
     @staticmethod
     async def get_active_templates(merchant_id: str) -> List[GiftCardTemplateResponse]:
-        """
-        Get active templates for a merchant.
-        
-        Args:
-            merchant_id (str): Merchant ID
-            
-        Returns:
-            List[GiftCardTemplateResponse]: List of active templates
-        """
+        """Get active templates for a merchant."""
         try:
             templates_data = await GiftCardRepository.get_active_templates(merchant_id)
             
@@ -343,13 +224,13 @@ class GiftCardService:
                 try:
                     templates.append(GiftCardTemplateResponse(**template_data))
                 except ValidationError as ve:
-                    logger.warning(f"Failed to parse active template: {template_data}, error: {ve}")
+                    logger.warning("Failed to parse active template", extra={"template": template_data, "error": str(ve)})
                     continue
             
             return templates
             
         except Exception as e:
-            logger.error(f"Service error getting active templates: {e}", exc_info=True)
+            logger.error("Service error getting active templates", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
     @staticmethod
@@ -357,16 +238,7 @@ class GiftCardService:
         existing_template: Dict[str, Any],
         update_data: Dict[str, Any]
     ) -> None:
-        """
-        Validate business rules for template updates.
-        
-        Args:
-            existing_template (Dict[str, Any]): Current template data
-            update_data (Dict[str, Any]): Proposed updates
-            
-        Raises:
-            HTTPException: If validation fails
-        """
+        """Validate business rules for template updates."""
         # Check if trying to change delivery_type
         if 'delivery_type' in update_data:
             current_delivery_type = existing_template.get('delivery_type')

app/services/promotion_service.py

@@ -1,4 +1,3 @@
-import logging
 import json
 from datetime import date, datetime
 from zoneinfo import ZoneInfo
@@ -8,22 +7,20 @@ from typing import Any, Dict, Optional, Union, List
 from bson import ObjectId
 from fastapi import HTTPException
 from pydantic import ValidationError
+from insightfy_utils.logging import get_logger
 
 from app.repositories.db import fetch_one_document
 from app.schemas.promotion_schema import PromotionMetaData, PromotionUpdate, PromotionValidateRequest
 from app.models.promotion_model import PromotionManagementModel
 
-
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 class PromotionManagementServices:
 
     @staticmethod
-    async def create_promotion_data(item: PromotionMetaData ):
-
+    async def create_promotion_data(item: PromotionMetaData):
         data = item.dict(by_alias=True, exclude_none=True)
-        
-        logger.info(f"Creating promotion with data: {data}")
+        logger.info("Creating promotion", extra={"data": data})
         promotion_inserted_id = await PromotionManagementModel.create_promotion_data(data)
         
         return {
@@ -42,19 +39,28 @@ class PromotionManagementServices:
         limit: int
     ) -> Dict[str, Any]:
         logger.info(
-            f"Listing promotions for merchant_id={merchant_id}, status={status}, "
-            f"is_active={is_active}, q={q}, sort={sort}, offset={offset}, limit={limit}"
+            "Listing promotions",
+            extra={
+                "merchant_id": merchant_id,
+                "status": status,
+                "is_active": is_active,
+                "q": q,
+                "sort": sort,
+                "offset": offset,
+                "limit": limit
+            }
         )
         try:
             return await PromotionManagementModel.list_promotion(
                 merchant_id, status, is_active, q, sort, offset, limit
             )
         except RuntimeError as re:
-            logger.error(f"RuntimeError while listing items: {re}", exc_info=True)
+            logger.error("RuntimeError while listing items", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
         except Exception as e:
-            logger.error(f"Unexpected error while listing items: {e}", exc_info=True)
+            logger.error("Unexpected error while listing items", exc_info=e)
             raise HTTPException(status_code=500, detail="Internal server error")
+
     @staticmethod
     async def compute_discount(promo: dict, data: PromotionValidateRequest) -> Dict[str, Any]:
         discount = 0.0
@@ -99,28 +105,25 @@ class PromotionManagementServices:
         return True,"valid"
 
     @staticmethod
-    async def validate_promotion(data:PromotionValidateRequest):
-        logging.info("Promotion code validation")
+    async def validate_promotion(data: PromotionValidateRequest):
+        logger.info("Promotion code validation")
         try:
             promotion_data = None
             
             if data.code:
-                # 1. Specific Promotion Code Provided
-                logging.info(f"Fetching promotion data for Promotion code: {data.code}")
+                logger.info("Fetching promotion data for code", extra={"code": data.code})
                 promotion_data = await PromotionManagementModel.get_promotion_by_code(data.code)
                 
                 if not promotion_data:
                     return {"valid": False, "reason": "invalid code"}
                     
-                # Validate the single specific Promotion
                 is_valid, reason = PromotionManagementServices.validate_coupon(promotion_data, data)
                 
                 if not is_valid:
                     return {"valid": False, "reason": reason}
 
             else:
-                # 2. Auto-Apply  (No Promotion code)
-                logging.info(f"Fetching auto-apply promotion code for merchant: {data.merchant_id}")
+                logger.info("Fetching auto-apply promotion", extra={"merchant_id": data.merchant_id})
                 promotions = await PromotionManagementModel.get_promotion_by_merchant_id(data.merchant_id)
                 
                 best_promotion = None
@@ -130,11 +133,9 @@ class PromotionManagementServices:
                     is_valid, reason = PromotionManagementServices.validate_coupon(promo, data)
                     
                     if is_valid:
-                        # Compute discount to find the best one
                         discount_info = await PromotionManagementServices.compute_discount(promo, data)
                         current_discount = discount_info["discount_amount"]
                         
-                        # Precedence Rule: Select the one with the highest discount amount
                         if current_discount > max_discount_amount:
                             max_discount_amount = current_discount
                             best_promotion = promo
@@ -144,8 +145,6 @@ class PromotionManagementServices:
                     is_valid = True
                 else:
                     return {"valid": False, "reason": "No applicable auto-apply promotions found"}
-
-
     
             if promotion_data:
                 if promotion_data.get('code'):
@@ -164,10 +163,9 @@ class PromotionManagementServices:
                 return response
                 
             return {"valid": False, "reason": "No valid promotion could be applied"}
-                    
         
         except Exception as e:
-            logger.error(f"Error while validating Promotion: {e}", exc_info=True)
+            logger.error("Error while validating Promotion", exc_info=e)
             raise RuntimeError("Failed to validate Promotion") from e
 
     @staticmethod
@@ -176,15 +174,9 @@ class PromotionManagementServices:
         associate_id: str,
         branch_id: str = None
     ) -> Dict[str, Any]:
-        """
-        Fetches detailed information about an promotion, including metadata and preferences.
-        """
-        logger.info(
-            f"Fetching info widget data for ID: {associate_id}")
+        """Fetches detailed information about a promotion, including metadata and preferences."""
+        logger.info("Fetching info widget data", extra={"associate_id": associate_id})
         try:
-
-            # Fetch user preferences if available
-
             user_pref = await fetch_one_document(
                 "list_key_score_cards",
                 {"merchant_id": merchant_id}
@@ -195,15 +187,14 @@ class PromotionManagementServices:
                     (view for view in user_pref["views"] if view.get("name") == "promotions"),
                     None
                 )
-            logger.info(f"User preferences for {associate_id}: {promotion_view}")
+            logger.info("User preferences fetched", extra={"associate_id": associate_id, "view": promotion_view})
             promotion_data = None
             
             if promotion_view:
                 promotion_data = await PromotionManagementModel.get_info_widget_data(merchant_id, branch_id, promotion_view)
 
                 if promotion_data is None:
-                    raise HTTPException(
-                        status_code=404, detail="promotion not found")
+                    raise HTTPException(status_code=404, detail="promotion not found")
 
                 return promotion_data
 
@@ -217,14 +208,13 @@ class PromotionManagementServices:
             return None
 
         if existing.get("used_count", 0) > 0:
-            if ( "discount_type" in update_data and update_data["discount_type"] != existing.get("discount_type")):
+            if ("discount_type" in update_data and update_data["discount_type"] != existing.get("discount_type")):
                 raise ValueError("Cannot change discount_type after promotion has been used")
 
             if ("value" in update_data and update_data["value"] != existing.get("value")):
                 raise ValueError("Cannot change discount value after promotion has been used")
 
         updated = await PromotionManagementModel.update_promotion(promotion_id, update_data)
-        print(updated)
         if updated:
             for k, v in updated.items():
                 if isinstance(v, ObjectId):
@@ -232,18 +222,16 @@ class PromotionManagementServices:
 
         return updated
 
-    
     async def get_by_promotion_id(promotion_id: str):
         try:
-            logger.info(f"fetching promotion with Id: {promotion_id}")
-            result= await PromotionManagementModel.get_by_promotion_id(promotion_id)
+            logger.info("Fetching promotion", extra={"promotion_id": promotion_id})
+            result = await PromotionManagementModel.get_by_promotion_id(promotion_id)
             if result:
-            # Convert all ObjectIds → str
                 for k, v in result.items():
                     if isinstance(v, ObjectId):
                         result[k] = str(v)
             return result
     
         except RuntimeError as re:
-            logger.error(f"RuntimeError while fetching promotion: {re}", exc_info=True)
+            logger.error("RuntimeError while fetching promotion", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))

app/services/supplier_service.py

@@ -1,10 +1,10 @@
-
 import logging
 import json
 from typing import Any, Dict, List, Union
 
 from fastapi import HTTPException
 from pydantic import ValidationError
+from insightfy_utils.logging import get_logger
 
 from app.models.supplier_models import SupplierModel
 from app.schemas.supplier_schema import Supplier
@@ -20,7 +20,7 @@ except ImportError:
 # Constants
 INTERNAL_SERVER_ERROR = "Internal server error"
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 class SupplierService:
     
@@ -28,22 +28,21 @@ class SupplierService:
     async def create_supplier(item_data: Supplier) -> Dict[str, Any]:
         try:
             data = item_data.dict(by_alias=True, exclude_none=True)
-            logger.info(f"Creating supplier with data: {data}")   
+            logger.info("Creating supplier", extra={"data": data})   
             data_id = await SupplierModel.create_supplier(data)
             return {"message": "Supplier created successfully", "id": data_id}
         
         except RuntimeError as re:
-            logger.error(f"RuntimeError while creating supplier: {re}", exc_info=True)
+            logger.error("RuntimeError while creating supplier", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
 
         except Exception as e:
-            logger.error(f"Unexpected error while creating supplier: {e}", exc_info=True)
+            logger.error("Unexpected error while creating supplier", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
-    
     @staticmethod
     async def get_supplier_data(supplier_id: str, merchant_id: str, branch_id: str = None):
-        logger.info(f"Fetching supplier with ID: {supplier_id}")  
+        logger.info("Fetching supplier", extra={"supplier_id": supplier_id})  
         try:
             supplier_data = await SupplierModel.get_supplier_data(supplier_id, merchant_id)
             if supplier_data is None:
@@ -52,10 +51,10 @@ class SupplierService:
         except HTTPException as he:
             raise he
         except RuntimeError as re:
-            logger.error(f"RuntimeError while fetching supplier: {re}", exc_info=True)
+            logger.error("RuntimeError while fetching supplier", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
         except Exception as e:
-            logger.error(f"Unexpected error while fetching supplier: {e}", exc_info=True)
+            logger.error("Unexpected error while fetching supplier", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
             
     @staticmethod
@@ -67,62 +66,49 @@ class SupplierService:
         limit: int = 10,
         projection_list: List[str] = None
     ) -> dict:
-        """
-        Retrieves a list of suppliers with pagination, filtering and user preferences support.
-        
-        Args:
-            merchant_id: The ID of the merchant
-            associate_id: The ID of the user requesting the data (for preferences)
-            filters: Optional dictionary of filter criteria
-            offset: Number of records to skip (for pagination)
-            limit: Maximum number of records to return
-            projection_list: Optional list of fields to include in the response
-            
-        Returns:
-            Dictionary containing suppliers list, total count, and pagination info
-        """
-        logger.info(f"Listing suppliers for {merchant_id=} with incoming filters={filters}")
+        """Retrieves a list of suppliers with pagination, filtering and user preferences support."""
+        logger.info("Listing suppliers", extra={"merchant_id": merchant_id, "filters": filters})
         try:
-            # Build base query with merchant_id
             filter_criteria = {"merchant_id": merchant_id}
-            
-            # Fetch and apply user preferences if cache is available
             final_projection_list = projection_list
             
             if CACHE_AVAILABLE and associate_id:
                 try:
                     cache_key = f"user_pref:{merchant_id}:{associate_id}"
-                    logger.info(f"Fetching user preferences from cache with key: {cache_key}")
+                    logger.info("Fetching user preferences from cache", extra={"cache_key": cache_key})
                     
                     user_pref = await get_or_set_cache(
                         cache_key,
                         fetch_func=lambda: fetch_user_preferences(merchant_id, associate_id)
                     )
                     
-                    logger.info(f"User preferences for {associate_id}: {user_pref}")
+                    logger.info("User preferences fetched", extra={"associate_id": associate_id, "user_pref": user_pref})
                     
-                    # Merge filters using utility
                     merged_filters = merge_filters_with_preferences(filters or {}, user_pref)
                     filter_criteria.update(merged_filters)
                     
-                    # Apply projection from user preferences if no explicit projection provided
                     if not projection_list and user_pref and isinstance(user_pref.get("visible_columns"), list):
                         final_projection_list = user_pref.get("visible_columns")
                         
                 except Exception as cache_exc:
-                    logger.warning(f"Error fetching user preferences: {cache_exc}")
-                    # Fall back to standard filters
+                    logger.warning("Error fetching user preferences", extra={"error": str(cache_exc)})
                     if filters:
                         filter_criteria.update(filters)
             elif filters:
                 filter_criteria.update(filters)
             
-            logger.debug(f"Final filter criteria: {filter_criteria}, offset={offset}, limit={limit}, projection={final_projection_list}")
+            logger.debug(
+                "Final filter criteria",
+                extra={
+                    "filter": filter_criteria,
+                    "offset": offset,
+                    "limit": limit,
+                    "projection": final_projection_list
+                }
+            )
             
-            # Get total count for pagination
             total_count = await SupplierModel.count_suppliers(filter_criteria)
             
-            # Get paginated suppliers list
             suppliers = await SupplierModel.get_suppliers_list(
                 query=filter_criteria, 
                 offset=offset, 
@@ -130,10 +116,8 @@ class SupplierService:
                 projection_list=final_projection_list
             )
             
-            # Sanitize results and remove _id field
             sanitized_suppliers = [catalogue_utils.sanitize_document_for_mongo(doc) for doc in suppliers]
             
-            # Explicitly remove _id field from each supplier document
             for supplier in sanitized_suppliers:
                 if "_id" in supplier:
                     del supplier["_id"]
@@ -147,10 +131,10 @@ class SupplierService:
             }
             
         except RuntimeError as re:
-            logger.error(f"RuntimeError while listing suppliers: {re}", exc_info=True)
+            logger.error("RuntimeError while listing suppliers", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
         except Exception as e:
-            logger.error(f"Unexpected error while listing suppliers: {e}", exc_info=True)
+            logger.error("Unexpected error while listing suppliers", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
 
     @staticmethod
@@ -159,18 +143,8 @@ class SupplierService:
         update_data: dict,
         current_user: dict = None
     ) -> dict:
-        """
-        Update supplier data with change tracking.
-        
-        Args:
-            supplier_id: The ID of the supplier to update
-            update_data: The data to update
-            current_user: Optional user info for tracking who made the change
-            
-        Returns:
-            Message indicating success or no changes
-        """
-        logger.info(f"Updating supplier with ID: {supplier_id}")
+        """Update supplier data with change tracking."""
+        logger.info("Updating supplier", extra={"supplier_id": supplier_id})
         try:
             if current_user:
                 update_data["updated_by"] = current_user.get("associate_id")
@@ -179,66 +153,51 @@ class SupplierService:
             
             return {"message": "Supplier updated successfully"} if result else {"message": "No changes made"}
         except RuntimeError as re:
-            logger.error(f"RuntimeError while updating supplier: {re}", exc_info=True)
+            logger.error("RuntimeError while updating supplier", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
         except Exception as e:
-            logger.error(f"Unexpected error while updating supplier: {e}", exc_info=True)
+            logger.error("Unexpected error while updating supplier", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
     
-    
     @staticmethod
-    async def delete_supplier(
-        supplier_id: str,
-        merchant_id: str
-    ) -> dict:
-        """
-        Deletes a supplier by ID.
-        """
-        logger.info(f"Deleting supplier with ID: {supplier_id}, merchant_id: {merchant_id}")
+    async def delete_supplier(supplier_id: str, merchant_id: str) -> dict:
+        """Deletes a supplier by ID."""
+        logger.info("Deleting supplier", extra={"supplier_id": supplier_id, "merchant_id": merchant_id})
         try:
             result = await SupplierModel.delete_supplier(supplier_id, merchant_id)
             if not result:
                 raise HTTPException(status_code=404, detail="Supplier not found")
             
-            logger.info(f"Supplier with ID {supplier_id} deleted successfully.")
-            
+            logger.info("Supplier deleted successfully", extra={"supplier_id": supplier_id})
             return {"message": "Supplier deleted successfully"}
         except HTTPException as he:
             raise he
         except RuntimeError as re:
-            logger.error(f"RuntimeError while deleting supplier: {re}", exc_info=True)
+            logger.error("RuntimeError while deleting supplier", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
         except Exception as e:
-            logger.error(f"Unexpected error while deleting supplier: {e}", exc_info=True)
+            logger.error("Unexpected error while deleting supplier", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
     
     @staticmethod
     async def get_filtered_suppliers(query: Dict[str, Any]) -> List[Dict[str, Any]]:
-        """
-        Get suppliers matching specific filter criteria.
-        
-        Args:
-            query: Dictionary of filter criteria
-            
-        Returns:
-            List of suppliers matching the criteria
-        """
-        logger.info(f"Fetching suppliers with filters: {query}")
+        """Get suppliers matching specific filter criteria."""
+        logger.info("Fetching suppliers with filters", extra={"query": query})
         try:
             supplier_list = await SupplierModel.get_filtered_suppliers(query)
             if not supplier_list:
-                logger.info("No suppliers found for given filters.")
+                logger.info("No suppliers found for given filters")
                 return []
 
             sanitized = [catalogue_utils.sanitize_document_for_mongo(doc) for doc in supplier_list]
-            logger.info(f"Fetched {len(sanitized)} supplier(s).")
+            logger.info("Fetched suppliers", extra={"count": len(sanitized)})
             return sanitized
 
         except RuntimeError as re:
-            logger.error(f"RuntimeError while fetching suppliers: {re}", exc_info=True)
+            logger.error("RuntimeError while fetching suppliers", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
         except Exception as e:
-            logger.error(f"Unexpected error while filtering suppliers: {e}", exc_info=True)
+            logger.error("Unexpected error while filtering suppliers", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
         
     @staticmethod
@@ -247,18 +206,8 @@ class SupplierService:
         history_entry: dict,
         current_user: dict = None
     ) -> Dict[str, Any]:
-        """
-        Append a new entry to the supplier's supply history.
-        
-        Args:
-            supplier_id: The ID of the supplier
-            history_entry: The history entry to append
-            current_user: Optional user info for tracking who made the change
-            
-        Returns:
-            Message indicating success or no changes
-        """
-        logger.info(f"Appending supply history for supplier ID: {supplier_id}")
+        """Append a new entry to the supplier's supply history."""
+        logger.info("Appending supply history", extra={"supplier_id": supplier_id})
         try:
             if current_user:
                 history_entry["added_by"] = current_user.get("associate_id")
@@ -266,16 +215,16 @@ class SupplierService:
             result = await SupplierModel.append_supply_history(supplier_id, history_entry)
             
             if not result:
-                logger.warning(f"No changes made when appending history for supplier ID: {supplier_id}")
+                logger.warning("No changes made when appending history", extra={"supplier_id": supplier_id})
                 return {"message": "No changes made"}
                 
-            logger.info(f"Successfully appended supply history for supplier ID: {supplier_id}")
+            logger.info("Supply history appended successfully", extra={"supplier_id": supplier_id})
             return {"message": "Supply history appended successfully"}
         except RuntimeError as re:
-            logger.error(f"RuntimeError while appending supply history: {re}", exc_info=True)
+            logger.error("RuntimeError while appending supply history", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
         except Exception as e:
-            logger.error(f"Unexpected error while appending supply history: {e}", exc_info=True)
+            logger.error("Unexpected error while appending supply history", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
     
     @staticmethod
@@ -284,44 +233,25 @@ class SupplierService:
         supplier_id: str,
         current_user: dict = None
     ) -> Dict[str, Any]:
-        """
-        Upload a document related to a supplier.
-        
-        Args:
-            data: The document data to upload
-            supplier_id: The ID of the supplier
-            current_user: Optional user info for tracking who uploaded the document
-            
-        Returns:
-            Message indicating success
-        """
-        logger.info(f"Uploading document for supplier ID: {supplier_id}")
+        """Upload a document related to a supplier."""
+        logger.info("Uploading document", extra={"supplier_id": supplier_id})
         try:
             if current_user:
                 data["uploaded_by"] = current_user.get("associate_id")
                 
             await SupplierModel.upload_document(data, supplier_id)
-            logger.info(f"Document uploaded successfully for supplier ID: {supplier_id}")
+            logger.info("Document uploaded successfully", extra={"supplier_id": supplier_id})
             return {"message": "Document uploaded successfully"}
         except RuntimeError as re:
-            logger.error(f"RuntimeError while uploading document: {re}", exc_info=True)
+            logger.error("RuntimeError while uploading document", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
         except Exception as e:
-            logger.error(f"Unexpected error while uploading document: {e}", exc_info=True)
+            logger.error("Unexpected error while uploading document", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)
             
     @staticmethod
     async def bulk_upload_suppliers(data: List[dict], current_user: dict):
-        """
-        Bulk upload multiple suppliers from a list of dictionaries.
-        
-        Args:
-            data: List of supplier data dictionaries
-            current_user: User information for tracking who created the suppliers
-            
-        Returns:
-            Dictionary with counts of inserted and failed records, plus error details
-        """
+        """Bulk upload multiple suppliers from a list of dictionaries."""
         valid_records = []
         errors = []
 
@@ -334,7 +264,7 @@ class SupplierService:
                 supplier_dict["created_by"] = current_user["associate_id"]
                 valid_records.append(supplier_dict)
             except ValidationError as ve:
-                logger.warning(f"Row {i + 1} validation error: {ve}")
+                logger.warning("Row validation error", extra={"row": i + 1, "error": str(ve)})
                 errors.append({"row": i + 1, "errors": ve.errors()})
 
         if not valid_records:
@@ -405,22 +335,10 @@ class SupplierService:
         associate_id: str,
         branch_id: str = None
     ) -> Dict[str, Any]:
-        """
-        Fetches detailed information about suppliers for dashboard widgets.
-        
-        Args:
-            merchant_id: The ID of the merchant
-            associate_id: The ID of the associate requesting the data
-            branch_id: Optional branch ID for filtering
-            
-        Returns:
-            Dictionary containing widget data
-        """
-        logger.info(f"Fetching info widget data for merchant ID: {merchant_id}")
+        """Fetches detailed information about suppliers for dashboard widgets."""
+        logger.info("Fetching info widget data", extra={"merchant_id": merchant_id})
         try:
-            # Only try to fetch user preferences if cache functionality is available
             if CACHE_AVAILABLE:
-                # Fetch user preferences if available
                 user_pref = await fetch_one_document(
                     "list_key_score_cards",
                     {"merchant_id": merchant_id}
@@ -431,7 +349,7 @@ class SupplierService:
                         (view for view in user_pref["views"] if view.get("name") == "suppliers"),
                         None
                     )
-                logger.info(f"User preferences for widget view: {suppliers_view}")
+                logger.info("User preferences for widget view", extra={"view": suppliers_view})
 
                 supplier_data = None
                 if suppliers_view:
@@ -439,7 +357,6 @@ class SupplierService:
                     if supplier_data is None:
                         return {}
                 else:
-                    # If no user_pref, return empty widgets or a default structure
                     supplier_data = {}
 
                 return supplier_data
@@ -447,8 +364,8 @@ class SupplierService:
         except HTTPException as he:
             raise he
         except RuntimeError as re:
-            logger.error(f"RuntimeError while fetching widget data: {re}", exc_info=True)
+            logger.error("RuntimeError while fetching widget data", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
         except Exception as e:
-            logger.error(f"Unexpected error while fetching widget data: {e}", exc_info=True)
+            logger.error("Unexpected error while fetching widget data", exc_info=e)
             raise HTTPException(status_code=500, detail=INTERNAL_SERVER_ERROR)

app/services/taxonomy_service.py

@@ -3,59 +3,50 @@ import uuid
 from typing import Any, Dict, List, Optional
 
 from fastapi import HTTPException
+from insightfy_utils.logging import get_logger
 from app.models.taxonomy_model import TaxonomyModel
 from app.utils.catalogue_utils import sanitize_document_for_mongo
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 class TaxonomyService:
     @staticmethod
-    async def create_taxonomy(item:any)-> Dict[str, Any]:
+    async def create_taxonomy(item: any) -> Dict[str, Any]:
         try:
             data = item.dict(by_alias=True, exclude_none=True)
-            logger.info(f"Creating Taxonomy with data: {data}")
-            inserted_id= await TaxonomyModel.create_append_delete_taxonomy(data)
+            logger.info("Creating Taxonomy", extra={"data": data})
+            inserted_id = await TaxonomyModel.create_append_delete_taxonomy(data)
             return {
                 'message': 'Taxonomy created successfully',
                 'id': inserted_id
             }
 
         except RuntimeError as re:
-            logger.error(f"RuntimeError while creating catalogue item: {re}", exc_info=True)
+            logger.error("RuntimeError while creating taxonomy", exc_info=re)
             raise HTTPException(status_code=500, detail=str(re))
 
         except Exception as e:
-            logger.error(f"Unexpected error while creating catalogue item: {e}", exc_info=True)
+            logger.error("Unexpected error while creating taxonomy", exc_info=e)
             raise HTTPException(status_code=500, detail="Internal server error")
         
     @staticmethod
-    async def update_taxonomy(
-            id: str,
-            update_data: dict
-        ) -> dict:
-
-            result = await TaxonomyModel.update_taxonomy(id, update_data)
-        
-            return {"message": "Taxonomy updated successfully"} if result else {"message": "No changes made"}
+    async def update_taxonomy(id: str, update_data: dict) -> dict:
+        result = await TaxonomyModel.update_taxonomy(id, update_data)
+        return {"message": "Taxonomy updated successfully"} if result else {"message": "No changes made"}
         
     @staticmethod
     async def delete_taxonomy(item_id: str) -> Dict[str, Any]:
-        """
-        Soft delete or remove an item from the catalogue.
-        """
-        logger.info(f"Attempting to delete taxonomy with item_id: {item_id}")
+        """Soft delete or remove an item from the catalogue."""
+        logger.info("Attempting to delete taxonomy", extra={"item_id": item_id})
         success = await TaxonomyModel.delete_taxonomy(item_id)
-        logger.info(f"Delete taxonomy result for item_id {item_id}: {success}")
+        logger.info("Delete taxonomy result", extra={"item_id": item_id, "success": success})
         if success:
             return {"message": "taxonomy deleted"}
         else:
             return {"message": "taxonomy not found"}
 
     @staticmethod
-    async def list_taxonomy(
-        merchant_id: str,
-        type=None
-    ) -> Dict[str, Any]:
+    async def list_taxonomy(merchant_id: str, type=None) -> Dict[str, Any]:
         """
         Retrieve a catalogue taxonomy item by ID.
         Returns a flat structure with merchant_id and arrays of taxonomy items.
@@ -109,4 +100,3 @@ class TaxonomyService:
             result["subcategories"] = item["subcategories"]
             
         return result
- 

app/sql.py

@@ -1,27 +1,25 @@
 # database.py
 from __future__ import annotations
 
-import logging
 import sqlalchemy
 import databases
+from insightfy_utils.db import PostgresConnector
+from insightfy_utils.logging import setup_logging, get_logger
 
-# 🔒 Single source of truth for config/env:
-# settings.py loads .env (locally) and builds DATABASE_URI safely.
 from settings import DATABASE_URI
 
 # -----------------------------------------------------------------------------
-# Logging
+# Logging (migrated to insightfy-utils)
 # -----------------------------------------------------------------------------
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-)
-logger = logging.getLogger(__name__)
+setup_logging(level="INFO", format_type="json", app_name="insightfy-bloom-ms-ems-sql")
+logger = get_logger(__name__)
 
 # -----------------------------------------------------------------------------
-# Database URL from settings (no direct os.getenv or extra load_dotenv here)
+# Database URL from settings
 # -----------------------------------------------------------------------------
-DATABASE_URL = DATABASE_URI  # alias if other parts of the app expect DATABASE_URL
+DATABASE_URL = DATABASE_URI
+
+logger.info("Using DATABASE_URL", extra={"database_url": DATABASE_URL})
 
 if not DATABASE_URL:
     logger.error("DATABASE_URI is empty or missing from settings.")
@@ -39,12 +37,11 @@ if not DATABASE_URL:
 # Initialize the database connection and metadata
 # -----------------------------------------------------------------------------
 try:
-    # `databases` uses async drivers internally (asyncpg for +asyncpg).
     database = databases.Database(DATABASE_URL)
     metadata = sqlalchemy.MetaData()
     logger.info("Database configuration loaded successfully.")
 except Exception as e:
-    logger.exception("Failed to initialize database configuration.")
+    logger.exception("Failed to initialize database configuration.", exc_info=e)
     raise
 
 # -----------------------------------------------------------------------------
@@ -58,7 +55,7 @@ async def connect_to_database() -> None:
         await database.connect()
         logger.info("Successfully connected to the database.")
     except Exception as e:
-        logger.exception("Error connecting to the database.")
+        logger.exception("Error connecting to the database.", exc_info=e)
         raise
 
 async def disconnect_from_database() -> None:
@@ -69,7 +66,7 @@ async def disconnect_from_database() -> None:
         await database.disconnect()
         logger.info("Successfully disconnected from the database.")
     except Exception as e:
-        logger.exception("Error disconnecting from the database.")
+        logger.exception("Error disconnecting from the database.", exc_info=e)
         raise
     
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
@@ -89,7 +86,7 @@ async_engine = create_async_engine(
     # Connection arguments for asyncpg
     connect_args={
         "server_settings": {
-            "application_name": "insightfy-tms",
+            "application_name": "insightfy-ems",  # Updated from tms to ems
             "jit": "off"
         },
         "command_timeout": 60,

app/utils/jwt.py

@@ -1,6 +1,9 @@
 from jose import ExpiredSignatureError, jwt, JWTError
+from insightfy_utils.logging import get_logger
 from settings import SECRET_KEY, ALGORITHM
 
+logger = get_logger(__name__)
+
  
 def decode_jwt_token(token: str) -> dict:
     try:
@@ -12,5 +15,5 @@ def decode_jwt_token(token: str) -> dict:
         raise ValueError("Token has expired")
 
     except JWTError as e:
-        print(f"❌ Invalid token: {e}")
+        logger.error("Invalid token", exc_info=e)
         raise ValueError("Invalid token")

requirements.txt

@@ -1,16 +1,36 @@
-fastapi>=0.95,<1.0
-uvicorn[standard]>=0.22.0
-pymongo
-motor>=3.0
-pydantic
-python-dotenv
-pydantic[email]
-databases
-asyncpg
-sqlalchemy
-redis
-httpx==0.28.1
-python-jose==3.4.0
-coverage==7.8.0
-pandas==2.2.3
-python-multipart==0.0.20
+# Core Framework
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+python-dotenv>=1.0.0
+pydantic>=2.0.0
+pydantic-settings>=2.0.0
+
+# Database
+asyncpg>=0.29.0
+sqlalchemy>=2.0.0
+databases>=0.8.0
+
+# MongoDB
+motor>=3.3.0
+pymongo>=4.6.0
+
+# Redis/Cache
+redis>=5.0.0
+
+# Authentication
+pyjwt>=2.8.0
+python-jose[cryptography]>=3.3.0
+passlib[bcrypt]>=1.7.4
+
+# Shared utilities library
+insightfy-utils==0.1.0
+
+# Development
+pytest>=7.4.0
+pytest-asyncio>=0.21.0
+black>=23.0.0
+flake8>=6.0.0
+mypy>=1.7.0
+
+httpx>=0.24.0
+pandas>=1.5.0

settings.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 
 import os
 from urllib.parse import quote_plus, urlencode
-from dotenv import load_dotenv
+from insightfy_utils.config import load_env
 
-load_dotenv()  # keep this so local .env is picked up
+load_env()  # Now properly implemented in insightfy-utils
 
 # ────────────────────────────────────────────────────────────────────────────────
 # Security