From 1890264c540d1bfce605be4fc85607c583a0e2c2 Mon Sep 17 00:00:00 2001 From: kzahiri1 Date: Thu, 19 Nov 2026 12:07:49 -0800 Subject: [PATCH] Keep an active rate limit when a later header is shorter. The transport spec says a new shorter limit must not replace one that is still running. Co-authored-by: Cursor --- sentry_sdk/transport.py | 20 +++++++++++++++--- tests/test_transport.py | 45 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 62 insertions(+), 3 deletions(-) diff --git a/sentry_sdk/transport.py b/sentry_sdk/transport.py index 28bd88dc3d..0b31686163 100644 --- a/sentry_sdk/transport.py +++ b/sentry_sdk/transport.py @@ -193,6 +193,15 @@ def is_healthy(self: "Self") -> bool: return True + +def _keep_longer_rate_limit(disabled_until, category, until): + # type: (Dict[Optional[EventDataCategory], datetime], Optional[EventDataCategory], datetime) -> None + """Store until unless a later deadline is already recorded for category.""" + previous = disabled_until.get(category) + if previous is None or until > previous: + disabled_until[category] = until + + def _parse_rate_limits( header: str, now: "Optional[datetime]" = None ) -> "Iterable[Tuple[Optional[EventDataCategory], datetime]]": @@ -341,7 +350,10 @@ def _update_rate_limits( header = self._get_header_value(response, "x-sentry-rate-limits") if header: logger.warning("Rate-limited via x-sentry-rate-limits") - self._disabled_until.update(_parse_rate_limits(header)) + # A later, shorter limit must not replace one that is still active. + # https://develop.sentry.dev/sdk/foundations/transport/rate-limiting/ + for category, until in _parse_rate_limits(header): + _keep_longer_rate_limit(self._disabled_until, category, until) # old sentries only communicate global rate limit hits via the # retry-after header on 429. This header can also be emitted on new @@ -354,8 +366,10 @@ def _update_rate_limits( if retry_after_value is not None else None ) or 60 - self._disabled_until[None] = datetime.now(timezone.utc) + timedelta( - seconds=retry_after + _keep_longer_rate_limit( + self._disabled_until, + None, + datetime.now(timezone.utc) + timedelta(seconds=retry_after), ) def _handle_request_error( diff --git a/tests/test_transport.py b/tests/test_transport.py index b955222061..4f355cbf36 100644 --- a/tests/test_transport.py +++ b/tests/test_transport.py @@ -44,6 +44,7 @@ AsyncHttpTransport, HttpTransport, _parse_rate_limits, + _keep_longer_rate_limit, ) server = None @@ -473,6 +474,50 @@ def test_parse_rate_limits(input, expected): assert dict(_parse_rate_limits(input, now=NOW)) == expected +def test_shorter_rate_limit_keeps_the_longer_deadline(): + disabled = {} + longer = NOW + timedelta(seconds=3600) + shorter = NOW + timedelta(seconds=0) + _keep_longer_rate_limit(disabled, "error", longer) + _keep_longer_rate_limit(disabled, "error", shorter) + assert disabled["error"] == longer + # An expired deadline still yields to a newer one. + _keep_longer_rate_limit(disabled, "error", NOW - timedelta(seconds=5)) + assert disabled["error"] == longer + renewed = NOW + timedelta(seconds=10) + disabled["error"] = NOW - timedelta(seconds=5) + _keep_longer_rate_limit(disabled, "error", renewed) + assert disabled["error"] == renewed + + +class _HeaderResponse: + def __init__(self, status, headers): + self.status = status + self.headers = headers + + +def test_rate_limit_header_does_not_shorten_active_limit(capturing_server, make_client): + client = make_client(send_client_reports=False) + capturing_server.respond_with( + code=200, + headers={"X-Sentry-Rate-Limits": "3600:error:organization, 0:error:project"}, + ) + client.capture_event({"type": "event"}) + client.flush() + until = client.transport._disabled_until["error"] + assert until > datetime.now(timezone.utc) + timedelta(seconds=3000) + + client.transport._update_rate_limits( + _HeaderResponse(200, {"x-sentry-rate-limits": "1:error"}) + ) + assert client.transport._disabled_until["error"] == until + + client.transport._disabled_until[None] = datetime.now(timezone.utc) + timedelta(seconds=3600) + kept = client.transport._disabled_until[None] + client.transport._update_rate_limits(_HeaderResponse(429, {"retry-after": "1"})) + assert client.transport._disabled_until[None] == kept + + def test_envelope_too_large_response(capturing_server, make_client): client = make_client()