fixed routing issue of pulse umbrella api endpoints

app/routes/news.py

@@ -51,8 +51,16 @@ async def get_umbrella_news(category: str, limit: int = 20):
         import asyncio
         per_cat_limit = max(5, math.ceil(limit / len(sub_categories)))
 
-        # Fetch all subcategories in parallel using the existing get_news_by_category function
-        tasks = [get_news_by_category(cat, limit=per_cat_limit, page=1) for cat in sub_categories]
+        # Semaphore caps simultaneous Appwrite+Upstash connections to 4.
+        # Without this, 10 parallel fetches spike Upstash burst limits causing
+        # "Upstash request failed" blank errors seen in production logs.
+        _sem = asyncio.Semaphore(4)
+
+        async def _fetch_with_sem(cat: str):
+            async with _sem:
+                return await get_news_by_category(cat, limit=per_cat_limit, page=1)
+
+        tasks = [_fetch_with_sem(cat) for cat in sub_categories]
         results = await asyncio.gather(*tasks, return_exceptions=True)
 
         seen = set()
@@ -73,11 +81,24 @@ async def get_umbrella_news(category: str, limit: int = 20):
         # Sort by published_at descending
         def get_pub_date(art):
             pub = art.get('published_at') or art.get('publishedAt')
-            return pub or ""
+            return str(pub) if pub else ""
 
         merged.sort(key=lambda x: get_pub_date(x), reverse=True)
         final_articles = merged[:limit]
 
+        # Sanitize datetime objects to ISO strings before JSON caching.
+        # Appwrite returns Python datetime objects in article dicts which are
+        # not JSON serializable. The _DatetimeEncoder in upstash_cache now
+        # handles this at the json.dumps level — this is belt-and-suspenders.
+        def _sanitize_for_cache(art: dict) -> dict:
+            from datetime import datetime as dt
+            return {
+                k: v.isoformat() if isinstance(v, dt) else v
+                for k, v in art.items()
+            }
+
+        cache_safe_articles = [_sanitize_for_cache(a) for a in final_articles]
+
         response_data = NewsResponse(
             success=True,
             category=category,
@@ -90,7 +111,7 @@ async def get_umbrella_news(category: str, limit: int = 20):
         if upstash_cache.enabled:
             await upstash_cache.set(
                 cache_key,
-                {"articles": final_articles},
+                {"articles": cache_safe_articles},
                 ttl=300
             )
 

app/services/upstash_cache.py

@@ -16,11 +16,23 @@ import httpx
 import json
 import logging
 from typing import Any, Optional
-from datetime import datetime
+from datetime import datetime, date
 
 logger = logging.getLogger(__name__)
 
 
+class _DatetimeEncoder(json.JSONEncoder):
+    """
+    JSON encoder that converts datetime/date objects to ISO-8601 strings.
+    Prevents 'Object of type datetime is not JSON serializable' when caching
+    article dicts that contain Appwrite-returned datetime fields.
+    """
+    def default(self, obj):
+        if isinstance(obj, (datetime, date)):
+            return obj.isoformat()
+        return super().default(obj)
+
+
 class UpstashCache:
     """
     REST-based Redis caching service for Upstash
@@ -181,8 +193,9 @@ class UpstashCache:
             return False
         
         try:
-            # Serialize to JSON
-            serialized = json.dumps(value)
+            # Serialize to JSON — use _DatetimeEncoder to handle datetime objects
+            # that Appwrite returns in article dicts (e.g. published_at, created_at)
+            serialized = json.dumps(value, cls=_DatetimeEncoder)
             
             # Check size (warn if >1MB)
             size_kb = len(serialized) / 1024