working ids task and logging changes

db/repositories.py

@@ -1,6 +1,8 @@
 from sqlalchemy.orm import Session
 from sqlalchemy import cast, or_, String
 from sqlalchemy.dialects.postgresql import JSONB
+
+from logger_manager import log_debug, log_error
 from . import models
 from interfaces.ingredientModels import IngredientAnalysisResult 
 from interfaces.productModels import ProductCreate
@@ -14,6 +16,7 @@ class IngredientRepository:
         exact_match = self.db.query(models.Ingredient).filter(models.Ingredient.name.ilike(name)).first()
     
         if exact_match:
+            log_debug(f"Exact match found for ingredient: {name}")
             return exact_match
         
         # If no exact match, try searching in alternate names
@@ -23,10 +26,12 @@ class IngredientRepository:
                 models.Ingredient.alternate_names.cast(JSONB).op('?')(name)
             ).first()
             
+            if alternate_match:
+                log_debug(f"Alternate match found for ingredient: {name}")
+            
             return alternate_match
         except Exception as e:
-            from logger_manager import logger
-            logger.error(f"Error searching alternate names: {e}")
+            log_error(f"Error searching alternate names: {e}",e)
             return None
         
     def get_all_ingredients(self, skip: int = 0, limit: int = 100):

interfaces/ingredientModels.py

@@ -5,6 +5,7 @@ from pydantic import BaseModel, Field
 # Define a structured output model
 class IngredientAnalysisResult(BaseModel):
     name: str
+    id: int
     alternate_names: List[str] = Field(default_factory=list)
     is_found: bool = False
     safety_rating: int = 5

logger_manager.py

@@ -14,7 +14,7 @@ console_handler = logging.StreamHandler()
 console_handler.setLevel(logging.ERROR)
 
 # Create a formatter and set it for both handlers
-formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s - %(pathname)s:%(lineno)d")
 file_handler.setFormatter(formatter)
 console_handler.setFormatter(formatter)
 
@@ -24,21 +24,18 @@ logger.addHandler(console_handler)
 
 def log_debug(message: str):
     logger.debug(message)
-    log_info(f"Debug: {message}")
-    log_error(f"Debug: {message}")
 
 def log_info(message: str):
     logger.info(message)
 
 def log_warning(message: str):
     logger.warning(message)
-    log_info(f"Warning: {message}")
-    log_error(f"Warning: {message}")
 
-def log_error(message: str):
-    logger.error(message)
+def log_error(message: str, exc: Exception = None):
+    if exc:
+        logger.error(message, exc_info=True)
+    else:
+        logger.error(message)
 
 def log_critical(message: str):
     logger.critical(message)
-    log_info(f"Critical: {message}")
-    log_error(f"Critical: {message}")

routers/analysis.py

@@ -14,7 +14,7 @@ from interfaces.productModels import ProductIngredientsRequest
 from services.auth_service import get_current_user
 from PIL import Image
 import cv2
-from logger_manager import log_info, log_error, logger
+from logger_manager import log_info, log_error
 from db.database import get_db,SessionLocal
 from db.repositories import IngredientRepository
 from dotenv import load_dotenv
@@ -49,6 +49,7 @@ def ingredient_db_to_pydantic(db_ingredient):
         name=db_ingredient.name,
         alternate_names=db_ingredient.alternate_names or [],
         is_found=True,
+        id=db_ingredient.id,
         safety_rating=db_ingredient.safety_rating or 5,
         description=db_ingredient.description or "No description available",
         health_effects=db_ingredient.health_effects or ["Unknown"],
@@ -149,14 +150,14 @@ async def get_image(image_name: str):
 @traceable
 async def process_ingredient_endpoint(request: IngredientRequest, db: Session = Depends(get_db)):
     try:
-        logger.info(f"Received request to process ingredient: {request.name}")
+        log_info(f"Received request to process ingredient: {request.name}")
         
         # Check if we already have this ingredient in the database
         repo = IngredientRepository(db)
         db_ingredient = repo.get_ingredient_by_name(request.name)
         
         if db_ingredient:
-            logger.info(f"Found existing ingredient in database: {request.name}")
+            log_info(f"Found existing ingredient in database: {request.name}")
             # Convert DB model to Pydantic model
             # (This would need a function to correctly map the data)
             return ingredient_db_to_pydantic(db_ingredient)
@@ -173,11 +174,11 @@ async def process_ingredient_endpoint(request: IngredientRequest, db: Session =
         
         # Save to database
         repo.create_ingredient(result)
-        logger.info(f"Saved new ingredient to database: {request.name}")
+        log_info(f"Saved new ingredient to database: {request.name}")
         
         return result
     except Exception as e:
-        logger.error(f"Error processing ingredient: {e}")
+        log_error(f"Error processing ingredient: {e}",e)
         raise HTTPException(status_code=500, detail="Internal Server Error")
 
 async def process_single_ingredient(ingredient_name: str):
@@ -214,7 +215,7 @@ async def process_single_ingredient(ingredient_name: str):
                 
                 return ingredient_data
     except Exception as e:
-        log_error(f"Error processing ingredient {ingredient_name}: {str(e)}")
+        log_error(f"Error processing ingredient {ingredient_name}: {str(e)}",e)
         # Return a minimal result on error to avoid failing the entire batch
         return IngredientAnalysisResult(
             name=ingredient_name,
@@ -262,10 +263,13 @@ async def process_ingredients_endpoint(product_ingredient: ProductIngredientsReq
             } if current_user else {}
         )
         
+        # print("Product analysis result:", product_analysis)
+        
         # Step 3: Prepare final response
         result = {
             "ingredients_count": len(ingredients),
             "processed_ingredients": ingredient_results,
+            "ingredient_ids": product_analysis["ingredient_ids"],
             "overall_analysis": product_analysis,
             "user_id": current_user.id if current_user else None,
             "timestamp": datetime.now(tz=pytz.timezone('Asia/Kolkata')).isoformat()
@@ -275,5 +279,5 @@ async def process_ingredients_endpoint(product_ingredient: ProductIngredientsReq
         return result
         
     except Exception as e:
-        log_error(f"Error in process_ingredients_endpoint: {str(e)}")
+        log_error(f"Error in process_ingredients_endpoint: {str(e)}",e)
         raise HTTPException(status_code=500, detail="Internal Server Error")

routers/auth.py

@@ -23,7 +23,7 @@ def register(user: UserCreate, db: Session = Depends(get_db)):
         log_info("User registered successfully")
         return {"access_token": access_token, "token_type": "bearer"}
     except Exception as e:
-        log_error(f"Error in register endpoint: {str(e)}")
+        log_error(f"Error in register endpoint: {str(e)}",e)
         raise HTTPException(status_code=500, detail="Internal Server Error")
 
 @router.post("/login", response_model=Token)
@@ -45,7 +45,7 @@ def login(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depend
         log_info("User logged in successfully")
         return {"access_token": access_token, "token_type": "bearer"}
     except Exception as e:
-        log_error(f"Error in login endpoint: {str(e)}")
+        log_error(f"Error in login endpoint: {str(e)}",e)
         raise HTTPException(status_code=500, detail="Internal Server Error")
 
 @router.get("/user", response_model=UserResponse)
@@ -54,7 +54,7 @@ def read_users_me(current_user: User = Depends(get_current_active_user)):
     try:
         return current_user
     except Exception as e:
-        log_error(f"Error in read_users_me endpoint: {str(e)}")
+        log_error(f"Error in read_users_me endpoint: {str(e)}",e)
         raise HTTPException(status_code=500, detail="Internal Server Error")
         
 @router.get("/user/email", response_model=UserResponse)
@@ -67,5 +67,5 @@ def read_user_by_email(email: str, db: Session = Depends(get_db)):
             raise HTTPException(status_code=404, detail="User not found")
         return user
     except Exception as e:
-        log_error(f"Error in read_user_by_email endpoint: {str(e)}")
+        log_error(f"Error in read_user_by_email endpoint: {str(e)}",e)
         raise HTTPException(status_code=500, detail="Internal Server Error")

routers/history.py

@@ -26,7 +26,7 @@ def create_scan(scan: ScanHistoryCreate, db: Session = Depends(get_db)):
         log_info("Scan recorded successfully")
         return scan_entry
     except Exception as e:
-        log_error(f"Error in create_scan endpoint: {str(e)}")
+        log_error(f"Error in create_scan endpoint: {str(e)}",e)
         raise HTTPException(status_code=500, detail="Internal Server Error")
 
 @router.get("/scan/{user_id}", response_model=list[ScanHistoryResponse])
@@ -40,5 +40,5 @@ def read_scan_history(user_id: int, db: Session = Depends(get_db)):
         log_info("Scan history retrieved successfully")
         return scan_history
     except Exception as e:
-        log_error(f"Error in read_scan_history endpoint: {str(e)}")
+        log_error(f"Error in read_scan_history endpoint: {str(e)}",e)
         raise HTTPException(status_code=500, detail="Internal Server Error")

routers/product.py

@@ -75,7 +75,7 @@ async def add_target_to_vuforia(image_name: str, image_path: str) -> str:
             log_error(f"Failed to add target {image_name}: {response.text}")
             raise Exception(f"Failed to add target {image_name}: {response.text}")
     except Exception as e:
-        log_error(f"Error adding target {image_name}: {e}")
+        log_error(f"Error adding target {image_name}: {e}",e)
         raise
 
 
@@ -114,7 +114,7 @@ async def add_product_to_database(
         return True
     except Exception as e:
         db.rollback()
-        log_error(f"Error adding/updating markers for product {product_id} in database: {e}")
+        log_error(f"Error adding/updating markers for product {product_id} in database: {e}",e)
         raise HTTPException(status_code=500, detail=f"Error adding/updating markers for product {product_id}: {e}")
 
 

services/auth_service.py

@@ -26,7 +26,7 @@ def verify_password(plain_password, hashed_password):
     try:
         return pwd_context.verify(plain_password, hashed_password)
     except Exception as e:
-        log_error(f"Error verifying password: {str(e)}")
+        log_error(f"Error verifying password: {str(e)}",e)
         raise HTTPException(status_code=500, detail=str(e))
 
 def get_password_hash(password):
@@ -34,7 +34,7 @@ def get_password_hash(password):
     try:
         return pwd_context.hash(password)
     except Exception as e:
-        log_error(f"Error hashing password: {str(e)}")
+        log_error(f"Error hashing password: {str(e)}",e)
         raise HTTPException(status_code=500, detail=str(e))
 
 def get_user(db, email: str):
@@ -42,7 +42,7 @@ def get_user(db, email: str):
     try:
         return db.query(User).filter(func.lower(User.email) == email.lower()).first()
     except Exception as e:
-        log_error(f"Error getting user: {str(e)}")
+        log_error(f"Error getting user: {str(e)}",e)
         raise HTTPException(status_code=500, detail=str(e))
 
 def authenticate_user(db: Session, username: str, password: str):
@@ -77,10 +77,10 @@ async def get_current_user(db: Session = Depends(get_db), token: str = Depends(o
             raise credentials_exception
         token_data = TokenData(email=email)
     except JWTError as e:
-        log_error(f"JWT error: {str(e)}")
+        log_error(f"JWT error: {str(e)}",e)
         raise credentials_exception
     except Exception as e:
-        log_error(f"Error decoding token: {str(e)}")
+        log_error(f"Error decoding token: {str(e)}",e)
         raise HTTPException(status_code=500, detail=str(e))
     user = get_user(db, email=token_data.email)
     if user is None:
@@ -94,7 +94,7 @@ async def get_current_active_user(current_user: User = Depends(get_current_user)
             raise HTTPException(status_code=400, detail="Inactive user")
         return UserResponse.from_orm(current_user)
     except Exception as e:
-        log_error(f"Error getting current active user: {str(e)}")
+        log_error(f"Error getting current active user: {str(e)}",e)
         raise HTTPException(status_code=500, detail=str(e))
 
 def create_user(db: Session, name: str, email: str, password: str):
@@ -107,5 +107,5 @@ def create_user(db: Session, name: str, email: str, password: str):
         db.refresh(db_user)
         return db_user
     except Exception as e:
-        log_error(f"Error creating user: {str(e)}")
+        log_error(f"Error creating user: {str(e)}",e)
         raise HTTPException(status_code=500, detail=str(e))

services/ingredientFinderAgent.py

@@ -10,7 +10,7 @@ from langchain_google_genai import ChatGoogleGenerativeAI
 
 # modular
 from interfaces.ingredientModels import IngredientAnalysisResult,IngredientState
-from logger_manager import logger
+from logger_manager import log_debug, log_error, log_info, log_warning
 from utils.agent_tools import search_local_db,search_web,search_wikipedia,search_open_food_facts,search_usda,search_pubchem
 
 # Load environment variables from .env file
@@ -100,7 +100,7 @@ def analyze_ingredient(state: IngredientState) -> IngredientState:
     
     # Basic validation
     if not api_key:
-        logger.error("No Google API key found in environment variables")
+        log_error("No Google API key found in environment variables")
         new_state = state.copy()
         new_state["result"] = {
             "name": state["ingredient"],
@@ -120,7 +120,7 @@ def analyze_ingredient(state: IngredientState) -> IngredientState:
             # convert_system_message_to_human=True
         )
     except Exception as e:
-        logger.error(f"Error initializing LLM: {e}")
+        log_error(f"Error initializing LLM: {e}",e)
         new_state = state.copy()
         new_state["result"] = {
             "name": state["ingredient"],
@@ -133,11 +133,11 @@ def analyze_ingredient(state: IngredientState) -> IngredientState:
     
     # Get sources from state
     sources_data = state["sources_data"]
-    logger.info(f"Analyzing ingredient with {len(sources_data)} total sources")
+    log_info(f"Analyzing ingredient with {len(sources_data)} total sources")
     
     # Filter for successful sources only
     found_sources = [source for source in sources_data if source.get('found', False)]
-    logger.info(f"Found {len(found_sources)} sources with usable data")
+    log_info(f"Found {len(found_sources)} sources with usable data")
     
     # Create default result structure
     result = {
@@ -180,12 +180,12 @@ def analyze_ingredient(state: IngredientState) -> IngredientState:
                 
                 source_texts.append(source_text)
             except Exception as e:
-                logger.error(f"Error formatting source {source_name}: {e}")
+                log_error(f"Error formatting source {source_name}: {e}",e)
                 source_texts.append(f"--- {source_name} ---\nError formatting data: {str(e)}")
         
         # Combine all source texts
         combined_data = "\n\n".join(source_texts)
-        logger.info(f"Combined data for analysis:\n{combined_data[:500]}...(truncated)")
+        log_info(f"Combined data for analysis:\n{combined_data[:500]}...(truncated)")
         
         # Create the analysis prompt
         analysis_prompt = f"""
@@ -218,14 +218,14 @@ def analyze_ingredient(state: IngredientState) -> IngredientState:
         
         # Process with LLM
         try:
-            logger.info("Sending analysis prompt to LLM")
+            log_info("Sending analysis prompt to LLM")
             llm_response = llm.invoke(analysis_prompt)
-            logger.info("Received LLM response")
+            log_info("Received LLM response")
             
             # Extract and parse JSON from LLM response
             try:
                 analysis_text = llm_response.content
-                logger.debug(f"LLM response: {analysis_text[:500]}...(truncated)")
+                log_debug(f"LLM response: {analysis_text[:500]}...(truncated)")
                 
                 # Find JSON in the response
                 start_idx = analysis_text.find('{')
@@ -244,17 +244,17 @@ def analyze_ingredient(state: IngredientState) -> IngredientState:
                         "allergic_info": analysis.get("allergic_info", []),
                         "diet_type": analysis.get("diet_type", "unknown"),
                     })
-                    logger.info(f"Analysis complete - Safety Rating: {result['safety_rating']}")
+                    log_info(f"Analysis complete - Safety Rating: {result['safety_rating']}")
                 else:
-                    logger.warning("Could not find JSON in LLM response")
+                    log_warning("Could not find JSON in LLM response")
                     result["description"] = "Error: Failed to parse LLM analysis output."
             except json.JSONDecodeError as e:
-                logger.error(f"JSON parsing error: {e}")
+                log_error(f"JSON parsing error: {e}",e)
                 result["description"] = f"Error parsing analysis: {str(e)}"
                 
         except Exception as e:
-            logger.error(f"Error in LLM analysis: {e}")
-            logger.error(traceback.format_exc())
+            log_error(f"Error in LLM analysis: {e}",e)
+            log_error(traceback.format_exc())
             result.update({
                 "description": f"Error in analysis: {str(e)}",
                 "health_effects": ["Error in analysis"],
@@ -360,7 +360,7 @@ class IngredientInfoAgentLangGraph:
             tool_name = str(tool_func).split()[0]
         
         source_name = tool_name.replace("search_", "").replace("_", " ").title()
-        logger.info(f"Searching {source_name} for {ingredient}")
+        log_info(f"Searching {source_name} for {ingredient}")
         
         try:
             # Run the tool function in a thread pool to avoid blocking
@@ -368,15 +368,15 @@ class IngredientInfoAgentLangGraph:
             result = await loop.run_in_executor(None, partial(tool_func.invoke, ingredient))
             
             if result.get("found", False):
-                logger.info(f"{source_name} found data for {ingredient}")
+                log_info(f"{source_name} found data for {ingredient}")
             return result
         except Exception as e:
-            logger.error(f"Error in {source_name} search: {e}")
+            log_error(f"Error in {source_name} search: {e}",e)
             return {"source": source_name, "found": False, "error": str(e)}
     
     async def process_ingredient_async(self, ingredient: str) -> IngredientAnalysisResult:
         """Process an ingredient using parallel data fetching."""
-        logger.info(f"=== Parallel processing for: {ingredient} ===")
+        log_info(f"=== Parallel processing for: {ingredient} ===")
         
         # Define all the tools to run in parallel
         tools = [
@@ -417,10 +417,10 @@ class IngredientInfoAgentLangGraph:
         
         # Extract the result or create a default
         if final_state.get("result"):
-            logger.info(f"Analysis complete for {ingredient}")
+            log_info(f"Analysis complete for {ingredient}")
             return IngredientAnalysisResult(**final_state["result"])
         else:
-            logger.info(f"No result in final state for {ingredient}, returning default")
+            log_info(f"No result in final state for {ingredient}, returning default")
             return IngredientAnalysisResult(
                 name=ingredient, 
                 is_found=len(sources_data) > 0, 
@@ -432,49 +432,49 @@ class IngredientInfoAgentLangGraph:
         Process an ingredient using direct sequential approach instead of async.
         This method provides compatibility with synchronous code.
         """
-        logger.info(f"=== Sequential processing for: {ingredient} ===")
+        log_info(f"=== Sequential processing for: {ingredient} ===")
         
         # Initialize empty sources data
         sources_data = []
         
         # Run each tool directly in sequence and collect results
-        logger.info(f"Searching local database for {ingredient}")
+        log_info(f"Searching local database for {ingredient}")
         result = search_local_db.invoke(ingredient)
 
         if result.get("found", False):
             sources_data.append(result)
-            logger.info(f"Local DB found data for {ingredient}")
+            log_info(f"Local DB found data for {ingredient}")
         
-        logger.info(f"Searching web for {ingredient}")
+        log_info(f"Searching web for {ingredient}")
         result = search_web.invoke(ingredient)
         if result.get("found", False):
             sources_data.append(result)
-            logger.info(f"Web search found data for {ingredient}")
+            log_info(f"Web search found data for {ingredient}")
         
-        logger.info(f"Searching Wikipedia for {ingredient}")
+        log_info(f"Searching Wikipedia for {ingredient}")
         result = search_wikipedia.invoke(ingredient)
         if result.get("found", False):
             sources_data.append(result)
-            logger.info(f"Wikipedia found data for {ingredient}")
+            log_info(f"Wikipedia found data for {ingredient}")
         
-        logger.info(f"Searching Open Food Facts for {ingredient}")
+        log_info(f"Searching Open Food Facts for {ingredient}")
         result = search_open_food_facts.invoke(ingredient)
         if result.get("found", False):
             sources_data.append(result)
-            logger.info(f"Open Food Facts found data for {ingredient}")
+            log_info(f"Open Food Facts found data for {ingredient}")
         
         
-        logger.info(f"Searching USDA for {ingredient}")
+        log_info(f"Searching USDA for {ingredient}")
         result = search_usda.invoke(ingredient)
         if result.get("found", False):
             sources_data.append(result)
-            logger.info(f"USDA found data for {ingredient}")
+            log_info(f"USDA found data for {ingredient}")
         
-        logger.info(f"Searching PubChem for {ingredient}")
+        log_info(f"Searching PubChem for {ingredient}")
         result = search_pubchem.invoke(ingredient)
         if result.get("found", False):
             sources_data.append(result)
-            logger.info(f"PubChem found data for {ingredient}")
+            log_info(f"PubChem found data for {ingredient}")
         
         state = IngredientState(ingredient=ingredient,
                                  sources_data=sources_data,
@@ -486,11 +486,11 @@ class IngredientInfoAgentLangGraph:
         
         # Extract the result or create a default
         if final_state.get("result"):
-            logger.info(f"Analysis complete for {ingredient}")
+            log_info(f"Analysis complete for {ingredient}")
 
             return IngredientAnalysisResult(**final_state["result"])
         else:
-            logger.info(f"No result in final state for {ingredient}, returning default")
+            log_info(f"No result in final state for {ingredient}, returning default")
             return IngredientAnalysisResult(
                 name=ingredient, 
                 is_found=len(sources_data) > 0, 

services/productAnalyzerAgent.py

@@ -3,7 +3,7 @@ from typing import List, Dict, Any, Optional
 from dotenv import load_dotenv
 from langchain_core.messages import HumanMessage
 from langchain_google_genai import ChatGoogleGenerativeAI
-from logger_manager import logger
+from logger_manager import log_error, log_info
 from interfaces.ingredientModels import IngredientAnalysisResult
 
 # Load environment variables
@@ -17,7 +17,7 @@ async def analyze_product_ingredients(
     Analyze multiple ingredients to provide a comprehensive product analysis
     for AR display, considering user preferences and dietary restrictions.
     """
-    logger.info(f"Analyzing product with {len(ingredients_data)} ingredients")
+    log_info(f"Analyzing product with {len(ingredients_data)} ingredients")
     
     # Initialize LLM
     api_key = os.getenv("LLM_API_KEY")
@@ -89,14 +89,18 @@ analysis that would be helpful for a consumer viewing this in an AR application.
     "concerns": (array of strings)
   }},
   "ingredient_interactions": (array of strings),
-  "key_takeaway": (string),
-  "ingredient_ids": (array of integers)
+  "key_takeaway": (string)
 }}
 
 Only include factual information based on the provided data. If information is unavailable for any field, use appropriate default values. If the data required is too obvious then give appropriate answer.
+IMPORTANT: Ensure your response is valid JSON with double quotes (") around property names and string values. 
+Avoid single quotes (') for JSON properties and values.
+Ensure all elements in arrays and objects are separated by commas, and don't include trailing commas.
+Also strictly follow the JSON format in your response.
+
 """
     
-    logger.info("Sending product analysis prompt to LLM")
+    log_info("Sending product analysis prompt to LLM")
     
     try:
         # Process with LLM
@@ -115,10 +119,10 @@ Only include factual information based on the provided data. If information is u
             try:
                 analysis = json.loads(json_match.group(0))
                 analysis["ingredient_ids"] = ingredient_ids
-                logger.info("Successfully parsed product analysis")
+                log_info("Successfully parsed product analysis")
                 return analysis
             except json.JSONDecodeError as e:
-                logger.error(f"JSON parsing error: {e}")
+                log_error(f"JSON parsing error: {e}",e)
                 # Return a simplified analysis on error
                 return {
                     "overall_safety_score": calculate_average_safety(ingredients_data),
@@ -128,7 +132,7 @@ Only include factual information based on the provided data. If information is u
                     "ingredient_ids": ingredient_ids
                 }
         else:
-            logger.error("Could not find JSON in LLM response")
+            log_error("Could not find JSON in LLM response")
             return {
                 "overall_safety_score": calculate_average_safety(ingredients_data),
                 "error": "Failed to generate structured analysis",
@@ -137,7 +141,7 @@ Only include factual information based on the provided data. If information is u
             }
     
     except Exception as e:
-        logger.error(f"Error in product analysis: {e}")
+        log_error(f"Error in product analysis: {e}",e)
         # Fallback analysis based on simple calculations
         return generate_fallback_analysis(ingredients_data, ingredient_ids)
 

services/scan_history.py

@@ -19,7 +19,7 @@ def record_scan(db: Session, user_id: int, product_id: int) -> ScanHistory:
         log_info("Scan recorded successfully")
         return scan_entry
     except Exception as e:
-        log_error(f"Error recording scan: {str(e)}")
+        log_error(f"Error recording scan: {str(e)}",e)
         raise HTTPException(status_code=500, detail="Internal Server Error")
 
 def get_scan_history(db: Session, user_id: int) -> list[ScanHistory]:
@@ -32,5 +32,5 @@ def get_scan_history(db: Session, user_id: int) -> list[ScanHistory]:
         log_info("Scan history retrieved successfully")
         return scan_history
     except Exception as e:
-        log_error(f"Error getting scan history: {str(e)}")
+        log_error(f"Error getting scan history: {str(e)}",e)
         raise HTTPException(status_code=500, detail="Internal Server Error")

utils/agent_tools.py

@@ -6,7 +6,7 @@ from dotenv import load_dotenv
 
 from typing import Dict, Any
 # modular
-from logger_manager import logger
+from logger_manager import log_error, log_info, log_warning
 from dotenv import load_dotenv
 
 import aiohttp
@@ -19,8 +19,6 @@ from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
 from langchain_core.tools import tool
 
 
-from logger_manager import logger
-
 # Load environment variables from .env file
 load_dotenv()
 
@@ -28,10 +26,10 @@ load_dotenv()
 SCRAPED_DB_PATH = "data/Food_Aditives_E_numbers.csv"  # Ensure this file exists
 if os.path.exists(SCRAPED_DB_PATH):
     additives_df = pd.read_csv(SCRAPED_DB_PATH)
-    logger.info(f"Loaded database with {len(additives_df)} entries")
+    log_info(f"Loaded database with {len(additives_df)} entries")
 else:
     additives_df = None
-    logger.warning("Scraped database not found!")
+    log_warning("Scraped database not found!")
 
 
 # Define a rate limit (adjust as needed)
@@ -47,7 +45,7 @@ DUCKDUCKGO_MAX_RETRIES = int(os.getenv("DUCKDUCKGO_MAX_RETRIES", "3"))  # Max re
 @tool("search_local_db")
 def search_local_db(ingredient: str) -> Dict[str, Any]:
     """Search local database for ingredient information. E number database scrapped"""
-    logger.info(f"Searching local DB for: {ingredient}")
+    log_info(f"Searching local DB for: {ingredient}")
     if additives_df is not None:
         match = additives_df[additives_df['Name of Additive'].str.contains(ingredient, case=False, na=False, regex=False)]
         if not match.empty:
@@ -57,7 +55,7 @@ def search_local_db(ingredient: str) -> Dict[str, Any]:
 @tool("search_open_food_facts")
 def search_open_food_facts(ingredient: str) -> Dict[str, Any]:
     """Search Open Food Facts database for ingredient information."""
-    logger.info(f"Searching Open Food Facts for: {ingredient}")
+    log_info(f"Searching Open Food Facts for: {ingredient}")
     
     try:
         open_food_facts_api = "https://world.openfoodfacts.org/api/v0"
@@ -90,13 +88,13 @@ def search_open_food_facts(ingredient: str) -> Dict[str, Any]:
         return {"source": "Open Food Facts", "found": False, "data": None}
     
     except Exception as e:
-        logger.error(f"Error searching Open Food Facts: {e}")
+        log_error(f"Error searching Open Food Facts: {e}",e)
         return {"source": "Open Food Facts", "found": False, "error": str(e)}
 
 @tool("search_usda")
 def search_usda(ingredient: str) -> Dict[str, Any]:
     """Search USDA FoodData Central for ingredient information."""
-    logger.info(f"Searching USDA for: {ingredient}")
+    log_info(f"Searching USDA for: {ingredient}")
     
     try:
         usda_api = "https://api.nal.usda.gov/fdc/v1"
@@ -125,12 +123,12 @@ def search_usda(ingredient: str) -> Dict[str, Any]:
         return {"source": "USDA FoodData Central", "found": False, "data": None}
     
     except Exception as e:
-        logger.error(f"Error searching USDA: {e}")
+        log_error(f"Error searching USDA: {e}",e)
         return {"source": "USDA FoodData Central", "found": False, "error": str(e)}
 
 async def async_search_pubchem(ingredient: str) -> Dict[str, Any]:
     """Asynchronously search PubChem for chemical information about the ingredient."""
-    logger.info(f"Searching PubChem for: {ingredient}")
+    log_info(f"Searching PubChem for: {ingredient}")
     
     try:
         pubchem_api = "https://pubchem.ncbi.nlm.nih.gov/rest/pug_view/data"
@@ -146,19 +144,19 @@ async def async_search_pubchem(ingredient: str) -> Dict[str, Any]:
                         if response.status == 200:
                             return await response.json()
                         else:
-                            logger.warning(f"PubChem returned status: {response.status} for URL: {url}")
+                            log_warning(f"PubChem returned status: {response.status} for URL: {url}")
                             return None
                 except asyncio.TimeoutError:
                     if retry_count < PUBCHEM_MAX_RETRIES:
                         delay = (2 ** retry_count) * 5  # Exponential backoff
-                        logger.warning(f"PubChem timeout for URL '{url}'. Retrying in {delay:.2f} seconds (attempt {retry_count + 1}/{PUBCHEM_MAX_RETRIES})")
+                        log_warning(f"PubChem timeout for URL '{url}'. Retrying in {delay:.2f} seconds (attempt {retry_count + 1}/{PUBCHEM_MAX_RETRIES})")
                         await asyncio.sleep(delay)
                         return await fetch_data(url, timeout, retry_count + 1)  # Recursive retry
                     else:
-                        logger.error(f"Max retries reached for PubChem timeout on URL: {url}")
+                        log_error(f"Max retries reached for PubChem timeout on URL: {url}",asyncio.TimeoutError)
                         return None
                 except Exception as e:
-                    logger.error(f"PubChem error for URL '{url}': {e}")
+                    log_error(f"PubChem error for URL '{url}': {e}",e)
                     return None
             
             data = await fetch_data(search_url)
@@ -187,7 +185,7 @@ async def async_search_pubchem(ingredient: str) -> Dict[str, Any]:
             return {"source": "PubChem", "found": False, "data": None}
     
     except Exception as e:
-        logger.error(f"Error searching PubChem: {e}")
+        log_error(f"Error searching PubChem: {e}",e)
         return {"source": "PubChem", "found": False, "error": str(e)}
 
 @tool("search_pubchem")
@@ -205,7 +203,7 @@ def search_pubchem(ingredient: str) -> Dict[str, Any]:
 @tool("search_wikipedia")
 def search_wikipedia(ingredient: str) -> Dict[str, Any]:
     """Search Wikipedia for ingredient information."""
-    logger.info(f"Searching Wikipedia for: {ingredient}")
+    log_info(f"Searching Wikipedia for: {ingredient}")
     
     try:
         wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
@@ -238,13 +236,13 @@ def search_wikipedia(ingredient: str) -> Dict[str, Any]:
         return {"source": "Wikipedia", "found": False, "data": None}
     
     except Exception as e:
-        logger.error(f"Error searching Wikipedia: {e}")
+        log_error(f"Error searching Wikipedia: {e}",e)
         return {"source": "Wikipedia", "found": False, "error": str(e)}
 
 @tool("search_web")
 def search_web(ingredient: str) -> Dict[str, Any]:
     """Search web for ingredient information using DuckDuckGo."""
-    logger.info(f"Searching web for: {ingredient}")
+    log_info(f"Searching web for: {ingredient}")
     
     try:
         duckduckgo = DuckDuckGoSearchRun()
@@ -257,5 +255,5 @@ def search_web(ingredient: str) -> Dict[str, Any]:
                 all_results.append({"query": query, "result": result})
         return {"source": "DuckDuckGo", "found": bool(all_results), "data": all_results}
     except Exception as e:
-        logger.error(f"Web search error: {e}")
+        log_error(f"Web search error: {e}",e)
         return {"source": "DuckDuckGo", "found": False, "error": str(e)}