Bug fix

src/api/routes.py

@@ -74,45 +74,66 @@ def _execute_mongo_op_in_thread(op_spec: Dict, client: MongoClient, database_nam
     Executes a single MongoDB operation.
     This function is intended to be run in a separate thread.
     """
-    db = client[database_name]
-    collection = db[op_spec["collection"]]
-    operation_name = op_spec["operation"]
-
-    if operation_name == "update_one":
-        collection.update_one(
-            op_spec["filter"],
-            op_spec["update"],
-            upsert=op_spec.get("upsert", False),
-            array_filters=op_spec.get("array_filters")
-        )
-    elif operation_name == "insert_one":
-        # Ensure 'document' key exists for insert_one
-        collection.insert_one(op_spec["document"])
-    # Add other specific operations as needed (e.g., find_one, delete_one)
-    else:
-        logger.error(f"Unsupported MongoDB operation in batch: {operation_name}")
-        raise ValueError(f"Unsupported MongoDB operation: {operation_name}")
+    try:
+        if client is None:
+            logger.warning("MongoDB client is None. Skipping operation.")
+            return
+            
+        db = client[database_name]
+        collection = db[op_spec["collection"]]
+        operation_name = op_spec["operation"]
+
+        if operation_name == "update_one":
+            collection.update_one(
+                op_spec["filter"],
+                op_spec["update"],
+                upsert=op_spec.get("upsert", False),
+                array_filters=op_spec.get("array_filters")
+            )
+        elif operation_name == "insert_one":
+            # Ensure 'document' key exists for insert_one
+            collection.insert_one(op_spec["document"])
+        # Add other specific operations as needed (e.g., find_one, delete_one)
+        else:
+            logger.error(f"Unsupported MongoDB operation in batch: {operation_name}")
+            raise ValueError(f"Unsupported MongoDB operation: {operation_name}")
+    except Exception as e:
+        logger.error(f"Error executing MongoDB operation {op_spec.get('operation', 'unknown')}: {e}")
+        # Don't raise the exception to avoid failing the entire batch
 
 # Batch processing for MongoDB operations
 async def batch_mongodb_operations(operations: List[Dict]) -> None:
     """Execute MongoDB operations in batches."""
     batch_size = 50
     try:
+        # Check if MongoDB is available
+        if mongodb.db is None:
+            logger.warning("MongoDB not available. Skipping batch operations.")
+            return
+            
         # Attempt to get DB name from the existing mongodb setup
-        db_name = mongodb.news_collection.database.name
-    except AttributeError:
-        logger.warning(
-            "Could not determine database name from mongodb.news_collection. "
-            "Using fallback 'recommender_db'. Please configure DB name properly."
-        )
-        db_name = "recommender_db" # FIXME: This should be configured via settings or a central DB config
+        try:
+            db_name = mongodb.news_collection.database.name
+        except AttributeError:
+            logger.warning(
+                "Could not determine database name from mongodb.news_collection. "
+                "Using fallback 'recommender_db'. Please configure DB name properly."
+            )
+            db_name = "recommender_db" # FIXME: This should be configured via settings or a central DB config
+    except Exception as e:
+        logger.warning(f"Could not access MongoDB: {e}. Skipping batch operations.")
+        return
 
     for i in range(0, len(operations), batch_size):
         batch = operations[i:i + batch_size]
-        await asyncio.gather(*[
-            asyncio.to_thread(_execute_mongo_op_in_thread, op, mongodb_client, db_name)
-            for op in batch
-        ])
+        try:
+            await asyncio.gather(*[
+                asyncio.to_thread(_execute_mongo_op_in_thread, op, mongodb._client, db_name)
+                for op in batch
+            ])
+        except Exception as e:
+            logger.error(f"Error executing batch MongoDB operations: {e}")
+            # Don't raise the exception to avoid failing the entire request
 
 #Getting recommendation using without user association
 @router.get("/recommendations/", response_model=RecommendationResponse)
@@ -189,21 +210,26 @@ async def get_recommendations_by_id_endpoint(
         # Add msid to the response
         recommendations_data["msid"] = msid
 
-        # Store session in MongoDB asynchronously using batch processing
-        session_data = {
-            "user_id": user_id,
-            "recommendations": recommendations_data.get("retrieved_documents", []),
-            "timestamp": datetime.now()
-        }
-        await batch_mongodb_operations([
-            {
-                "collection": "sessions",
-                "operation": "update_one",
-                "filter": {"user_id": user_id},
-                "update": {"$set": session_data},
-                "upsert": True
+        # Store session in MongoDB asynchronously using batch processing (optional)
+        try:
+            session_data = {
+                "user_id": user_id,
+                "recommendations": recommendations_data.get("retrieved_documents", []),
+                "timestamp": datetime.now()
             }
-        ])
+            await batch_mongodb_operations([
+                {
+                    "collection": "sessions",
+                    "operation": "update_one",
+                    "filter": {"user_id": user_id},
+                    "update": {"$set": session_data},
+                    "upsert": True
+                }
+            ])
+            logger.info(f"Session data saved to MongoDB for user {user_id}")
+        except Exception as mongo_error:
+            logger.warning(f"Could not save session data to MongoDB: {mongo_error}")
+            # Don't fail the request if MongoDB is unavailable
         
         end_time = time.time()
         logger.info(f"Recommendation generated in {(end_time - start_time)*1000:.2f}ms")
@@ -275,6 +301,11 @@ async def feedback_recommendation_endpoint(
 
         # Store feedback in MongoDB
         try:
+            # Check if MongoDB is available
+            if mongodb.db is None or mongodb.news_collection is None:
+                logger.warning("MongoDB not available. Skipping feedback storage.")
+                return {"message": "Response processed successfully (feedback storage unavailable)"}
+                
             # First, try to find if the user document exists
             user_doc = await asyncio.get_event_loop().run_in_executor(
                 thread_pool,
@@ -376,29 +407,33 @@ async def get_recommendations_with_summary_endpoint(
         articles_details_map = {}
         
         if doc_ids_to_fetch and (include_summary or include_smart_tip):
-            projection = {"_id": 0, "id": 1}
-            if include_summary:
-                projection.update({"story": 1, "syn": 1})  # Add syn field as fallback
-            if include_smart_tip:
-                projection.update({"seolocation": 1, "tn": 1, "hl": 1})
-            
-            # Use batch size of 50 for MongoDB queries
-            batch_size = 50
-            for i in range(0, len(doc_ids_to_fetch), batch_size):
-                batch_ids = doc_ids_to_fetch[i:i + batch_size]
-                fetched_articles_list = await asyncio.get_event_loop().run_in_executor(
-                    thread_pool,
-                    lambda: list(mongodb.news_collection.find(
-                        {"id": {"$in": batch_ids}},
-                        projection
-                    ))
-                )
-                for article in fetched_articles_list:
-                    if article.get("id"):
-                        # Use synopsis as fallback if story is not available
-                        if include_summary and not article.get("story") and article.get("syn"):
-                            article["story"] = article["syn"]
-                        articles_details_map[article["id"]] = article
+            try:
+                projection = {"_id": 0, "id": 1}
+                if include_summary:
+                    projection.update({"story": 1, "syn": 1})  # Add syn field as fallback
+                if include_smart_tip:
+                    projection.update({"seolocation": 1, "tn": 1, "hl": 1})
+                
+                # Use batch size of 50 for MongoDB queries
+                batch_size = 50
+                for i in range(0, len(doc_ids_to_fetch), batch_size):
+                    batch_ids = doc_ids_to_fetch[i:i + batch_size]
+                    fetched_articles_list = await asyncio.get_event_loop().run_in_executor(
+                        thread_pool,
+                        lambda: list(mongodb.news_collection.find(
+                            {"id": {"$in": batch_ids}},
+                            projection
+                        ))
+                    )
+                    for article in fetched_articles_list:
+                        if article.get("id"):
+                            # Use synopsis as fallback if story is not available
+                            if include_summary and not article.get("story") and article.get("syn"):
+                                article["story"] = article["syn"]
+                            articles_details_map[article["id"]] = article
+            except Exception as e:
+                logger.warning(f"Could not fetch article details from MongoDB: {e}")
+                # Continue without article details - recommendations will still work
 
         # Process documents in parallel using asyncio.gather
         async def process_doc_batch(docs_batch):