Merge URL checks into single check

Author: alukach

src/stac_auth_proxy/app.py

@@ -31,13 +31,13 @@ def create_app(settings: Optional[Settings] = None) -> FastAPI:
     #
     # Application
     #
-    upstream_urls = [
-        settings.upstream_url,
-        settings.oidc_discovery_internal_url or settings.oidc_discovery_url,
-    ]
     lifespan = LifespanManager(
         on_startup=(
-            [ServerHealthCheck(url=url) for url in upstream_urls]
+            [
+                ServerHealthCheck(
+                    urls=[settings.upstream_url, settings.oidc_discovery_internal_url]
+                )
+            ]
             if settings.wait_for_upstream
             else []
         )

src/stac_auth_proxy/lifespan/ServerHealthCheck.py

@@ -14,44 +14,42 @@
 class ServerHealthCheck:
     """Health check for upstream API."""
 
-    url: str | HttpUrl
+    urls: list[str | HttpUrl]
     max_retries: int = 5
-    retry_delay: float = 0.25
+    retry_delay: float = 0.5
     retry_delay_max: float = 10.0
     timeout: float = 5.0
 
     def __post_init__(self):
         """Convert url to string if it's a HttpUrl."""
-        if isinstance(self.url, HttpUrl):
-            self.url = str(self.url)
+        self.urls = [str(url) if isinstance(url, HttpUrl) else url for url in self.urls]
 
-    async def _check_health(self) -> bool:
+    async def _check_health(self, url: str) -> bool:
         """Check if upstream API is responding."""
-        try:
-            async with httpx.AsyncClient() as client:
-                response = await client.get(
-                    self.url, timeout=self.timeout, follow_redirects=True
-                )
-                response.raise_for_status()
-                return True
-        except Exception as e:
-            logger.warning(f"Upstream health check for {self.url!r} failed: {e}")
-            return False
-
-    async def __call__(self) -> None:
-        """Wait for upstream API to become available."""
         for attempt in range(self.max_retries):
-            if await self._check_health():
-                logger.info(f"Upstream API {self.url!r} is healthy")
-                return
+            try:
+                async with httpx.AsyncClient() as client:
+                    response = await client.get(
+                        url, timeout=self.timeout, follow_redirects=True
+                    )
+                    response.raise_for_status()
+                    logger.info(f"Upstream API {url!r} is healthy")
+                    return True
+            except Exception as e:
+                logger.warning(f"Upstream health check for {url!r} failed: {e}")
 
             retry_in = min(self.retry_delay * (2**attempt), self.retry_delay_max)
             logger.warning(
-                f"Upstream API {self.url!r} not healthy, retrying in {retry_in:.1f}s "
+                f"Upstream API {url!r} not healthy, retrying in {retry_in:.1f}s "
                 f"(attempt {attempt + 1}/{self.max_retries})"
             )
             await asyncio.sleep(retry_in)
 
         raise RuntimeError(
-            f"Upstream API {self.url!r} failed to respond after {self.max_retries} attempts"
+            f"Upstream API {url!r} failed to respond after {self.max_retries} attempts"
         )
+
+    async def __call__(self) -> None:
+        """Wait for upstream API to become available."""
+        for url in self.urls:
+            await self._check_health(url)