Make geo lookups non-blocking with bulk DB writes and background tasks

backend/app/services/ban_service.py

@@ -10,6 +10,7 @@ so BanGUI never modifies or locks the fail2ban database.
 
 from __future__ import annotations
 
+import asyncio
 import json
 from datetime import UTC, datetime
 from typing import TYPE_CHECKING, Any
@@ -344,20 +345,26 @@ async def bans_by_country(
 
     1. Queries the fail2ban DB with ``GROUP BY ip`` to get the per-IP ban
        counts for all unique IPs in the window — no row-count cap.
-    2. Batch-resolves every unique IP via :func:`~app.services.geo_service.lookup_batch`
-       (100 IPs per HTTP call) instead of one-at-a-time lookups.
+    2. Serves geo data from the in-memory cache only (non-blocking).
+       Any IPs not yet in the cache are scheduled for background resolution
+       via :func:`asyncio.create_task` so the response is returned immediately
+       and subsequent requests benefit from the warmed cache.
     3. Returns a ``{country_code: count}`` aggregation and the 200 most
-       recent raw rows (already geo-cached from step 2) for the companion
-       table.
+       recent raw rows for the companion table.
+
+    Note:
+        On the very first request a large number of IPs may be uncached and
+        the country map will be sparse.  The background task will resolve them
+        and the next request will return a complete map.  This trade-off keeps
+        the endpoint fast regardless of dataset size.
 
     Args:
         socket_path: Path to the fail2ban Unix domain socket.
         range_: Time-range preset.
-        http_session: Optional :class:`aiohttp.ClientSession` for batch
-            geo lookups.  When provided, :func:`geo_service.lookup_batch`
-            is used instead of the *geo_enricher* callable.
+        http_session: Optional :class:`aiohttp.ClientSession` for background
+            geo lookups.  When ``None``, only cached data is used.
         geo_enricher: Legacy async ``(ip) -> GeoInfo | None`` callable;
-            used when *http_session* is ``None``.
+            used when *http_session* is ``None`` (e.g. tests).
         app_db: Optional BanGUI application database used to persist newly
             resolved geo entries across restarts.
         origin: Optional origin filter — ``"blocklist"`` restricts results to
@@ -367,8 +374,6 @@ async def bans_by_country(
         :class:`~app.models.ban.BansByCountryResponse` with per-country
         aggregation and the companion ban list.
     """
-    import asyncio
-
     from app.services import geo_service  # noqa: PLC0415
 
     since: int = _since_unix(range_)
@@ -417,15 +422,26 @@ async def bans_by_country(
         ) as cur:
             companion_rows = await cur.fetchall()
 
-    # Batch-resolve all unique IPs (much faster than individual lookups).
     unique_ips: list[str] = [str(r["ip"]) for r in agg_rows]
     geo_map: dict[str, Any] = {}
 
     if http_session is not None and unique_ips:
-        try:
-            geo_map = await geo_service.lookup_batch(unique_ips, http_session, db=app_db)
-        except Exception as exc:  # noqa: BLE001
-            log.warning("ban_service_batch_geo_failed", error=str(exc))
+        # Serve only what is already in the in-memory cache — no API calls on
+        # the hot path.  Uncached IPs are resolved asynchronously in the
+        # background so subsequent requests benefit from a warmer cache.
+        geo_map, uncached = geo_service.lookup_cached_only(unique_ips)
+        if uncached:
+            log.info(
+                "ban_service_geo_background_scheduled",
+                uncached=len(uncached),
+                cached=len(geo_map),
+            )
+            # Fire-and-forget: lookup_batch handles rate-limiting / retries.
+            # The dirty-set flush task persists results to the DB.
+            asyncio.create_task(  # noqa: RUF006
+                geo_service.lookup_batch(uncached, http_session, db=app_db),
+                name="geo_bans_by_country",
+            )
     elif geo_enricher is not None and unique_ips:
         # Fallback: legacy per-IP enricher (used in tests / older callers).
         async def _safe_lookup(ip: str) -> tuple[str, Any]: