Slight logic change, more logging

Author: mephenor

src/ghga_service_commons/transports/config.py

@@ -36,10 +36,10 @@ class RatelimitingTransportConfig(BaseSettings):
     """TODO"""
 
     jitter: NonNegativeFloat = Field(
-        default=0.05, description="Max amoun of jitter to add to each request"
+        default=0.001, description="Max amount of jitter to add to each request"
     )
-    reset_after: int | None = Field(
-        default=None,
+    reset_after: int = Field(
+        default=1,
         description="Amount of requests after which the stored delay from a 429 response is ignored again. If set to `None`, it's never forgotten.",
     )
 
@@ -67,7 +67,5 @@ class CompositeConfig(RatelimitingTransportConfig, RetryTransportConfig):
     """TOOD"""
 
 
-class CompositeCacheConfig(
-    CacheTransportConfig, RatelimitingTransportConfig, RetryTransportConfig
-):
+class CompositeCacheConfig(CompositeConfig, CacheTransportConfig):
     """TOOD"""

src/ghga_service_commons/transports/factory.py

@@ -18,6 +18,7 @@
 from hishel import AsyncCacheTransport, AsyncInMemoryStorage
 from httpx import AsyncHTTPTransport
 
+from .config import CompositeCacheConfig, CompositeConfig
 from .ratelimiting import AsyncRatelimitingTransport
 from .retry import AsyncRetryTransport
 
@@ -26,7 +27,7 @@ class CompositeTransportFactory:
     """TODO"""
 
     @classmethod
-    def _create_common_transport_layers(cls, config, transport):
+    def _create_common_transport_layers(cls, config: CompositeConfig, transport):
         """TODO"""
         retry_transport = AsyncRetryTransport(config=config, transport=transport)
         ratelimiting_transport = AsyncRatelimitingTransport(
@@ -35,14 +36,16 @@ def _create_common_transport_layers(cls, config, transport):
         return ratelimiting_transport
 
     @classmethod
-    def create_ratelimiting_retry_transport(cls, config) -> AsyncRatelimitingTransport:
+    def create_ratelimiting_retry_transport(
+        cls, config: CompositeConfig
+    ) -> AsyncRatelimitingTransport:
         """TODO"""
         base_transport = AsyncHTTPTransport()
         return cls._create_common_transport_layers(config, base_transport)
 
     @classmethod
     def create_ratelimiting_retry_transport_with_cache(
-        cls, config
+        cls, config: CompositeCacheConfig
     ) -> AsyncRatelimitingTransport:
         """TODO"""
         base_transport = AsyncHTTPTransport()

src/ghga_service_commons/transports/ratelimiting.py

@@ -36,10 +36,10 @@ def __init__(
         self, config: RatelimitingTransportConfig, transport: httpx.AsyncBaseTransport
     ) -> None:
         self._jitter = config.jitter
-        self._num_requests = 0
-        self._reset_after: int | None = config.reset_after
         self._transport = transport
-        self._last_call_time = datetime.now(timezone.utc)
+        self._num_requests = 0
+        self._reset_after: int = config.reset_after
+        self._last_request_time = datetime.now(timezone.utc)
         self._wait_time: float = 0
 
     async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
@@ -52,7 +52,7 @@ async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
         :rtype: httpx.Response
         """
         # Caculate seconds since the last request has been fired and corresponding wait time
-        time_elapsed = (self._last_call_time - datetime.now(timezone.utc)).seconds
+        time_elapsed = (self._last_request_time - datetime.now(timezone.utc)).seconds
         remaining_wait = max(0, self._wait_time - time_elapsed)
 
         # Add jitter to both cases and sleep
@@ -63,16 +63,17 @@ async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
                 random.uniform(remaining_wait, remaining_wait + self._jitter)  # noqa: S311
             )
 
-        # Update timestamp and delegate call
-        self._last_call_time = datetime.now(timezone.utc)
+        # Delegate call and update timestamp
         response = await self._transport.handle_async_request(request=request)
+        self._last_request_time = datetime.now(timezone.utc)
 
         # Update state
         self._num_requests += 1
         if response.status_code == 429:
             retry_after = response.headers.get("Retry-After")
             if retry_after:
                 self._wait_time = float(retry_after)
+                log.info("Received retry after response: %.3f s", self._wait_time)
             else:
                 log.warning(
                     "Retry-After header not present in 429 response, using fallback instead."