⚡ perf: Add Redis caching to /v1/xon-pulse and /v1/rss

Author: DevaOnBreaches

api/v1/feeds.py

@@ -1,18 +1,51 @@
 """Feed endpoints for RSS and XON Pulse."""
 
+import json
 import logging
-from typing import List
+from datetime import timedelta
+from typing import Dict, List, Optional
+
 from fastapi import APIRouter, Request, Response
+from feedgen.feed import FeedGenerator
 from google.cloud import datastore
 from pydantic import BaseModel
-from feedgen.feed import FeedGenerator
+from redis import Redis
+
+from config.settings import REDIS_DB, REDIS_HOST, REDIS_PORT
 from models.base import BaseResponse
 from services.send_email import send_exception_email
 from utils.custom_limiter import custom_rate_limiter
 from utils.safe_encoding import escape_rss_content, escape_url_fragment
 
 router = APIRouter()
 
+# Redis client for caching
+redis_client = Redis(
+    host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, decode_responses=True
+)
+
+# Cache TTL: 12 hours for feeds
+FEEDS_CACHE_TTL_HOURS = 12
+
+
+def get_cached_feed(cache_key: str) -> Optional[str]:
+    """Retrieve cached feed from Redis."""
+    try:
+        return redis_client.get(cache_key)
+    except Exception:
+        pass
+    return None
+
+
+def cache_feed(
+    cache_key: str, content: str, expiry_hours: int = FEEDS_CACHE_TTL_HOURS
+) -> None:
+    """Cache feed content in Redis."""
+    try:
+        redis_client.setex(cache_key, timedelta(hours=expiry_hours), content)
+    except Exception:
+        pass
+
 
 class PulseNewsItem(BaseModel):
     """Model for individual news item."""
@@ -34,6 +67,14 @@ class PulseNewsResponse(BaseResponse):
 async def get_pulse_data(request: Request):
     """Generate news feed for presenting all data breaches news."""
     try:
+        # Check cache first
+        cache_key = "feeds:xon-pulse"
+        cached_result = get_cached_feed(cache_key)
+        if cached_result:
+            cached_data = json.loads(cached_result)
+            return PulseNewsResponse(**cached_data)
+
+        # Cache miss - fetch from Datastore
         client = datastore.Client()
         query = client.query(kind="xon-pulse")
         results = list(query.fetch())
@@ -48,6 +89,14 @@ async def get_pulse_data(request: Request):
             )
             data.append(item)
 
+        # Cache the response
+        response_data = {
+            "status": "success",
+            "data": [item.model_dump() for item in data],
+            "status_code": 200,
+        }
+        cache_feed(cache_key, json.dumps(response_data))
+
         return PulseNewsResponse(status="success", data=data, status_code=200)
     except Exception as exc:
         logging.error("Failed to fetch news feed: %s", str(exc))
@@ -68,6 +117,13 @@ async def get_pulse_data(request: Request):
 async def rss_feed(request: Request):
     """Generate RSS feed for presenting all data breaches in XoN."""
     try:
+        # Check cache first
+        cache_key = "feeds:rss"
+        cached_rss = get_cached_feed(cache_key)
+        if cached_rss:
+            return Response(content=cached_rss, media_type="application/rss+xml")
+
+        # Cache miss - generate RSS feed
         feed_generator = FeedGenerator()
         feed_generator.title("XposedOrNot Data Breaches")
         feed_generator.description("Live updates of uploaded data breaches")
@@ -102,6 +158,17 @@ async def rss_feed(request: Request):
             feed_entry.guid(guid=entity_key, permalink=True)
 
         rss_content = feed_generator.rss_str()
+
+        # Cache the RSS content (decode bytes to string for Redis)
+        cache_feed(
+            cache_key,
+            (
+                rss_content.decode("utf-8")
+                if isinstance(rss_content, bytes)
+                else rss_content
+            ),
+        )
+
         return Response(content=rss_content, media_type="application/rss+xml")
 
     except Exception as exc:

api/v1/metrics.py

@@ -95,6 +95,13 @@ async def get_detailed_metrics_endpoint(request: Request) -> DetailedMetricsResp
         if not validate_url(request):
             raise HTTPException(status_code=400, detail="Invalid request URL")
 
+        # Check cache first
+        cache_key = "metrics:detailed"
+        cached_result = get_cached_metrics(cache_key)
+        if cached_result:
+            return DetailedMetricsResponse(**cached_result)
+
+        # Cache miss - fetch and process
         metrics = await get_detailed_metrics()
 
         # Process top breaches
@@ -130,6 +137,19 @@ async def get_detailed_metrics_endpoint(request: Request) -> DetailedMetricsResp
                 }
             )
 
+        # Build response and cache it
+        response_data = {
+            "Breaches_Count": metrics["breaches_count"],
+            "Breaches_Records": metrics["breaches_total_records"],
+            "Pastes_Count": str(metrics["pastes_count"]),
+            "Pastes_Records": metrics["pastes_total_records"],
+            "Yearly_Breaches_Count": metrics["yearly_count"],
+            "Industry_Breaches_Count": metrics["industry_breaches_count"],
+            "Top_Breaches": top_breaches,
+            "Recent_Breaches": recent_breaches,
+        }
+        cache_metrics(cache_key, response_data)
+
         return DetailedMetricsResponse(
             Breaches_Count=metrics["breaches_count"],
             Breaches_Records=metrics["breaches_total_records"],