fix(issues) - Correct issues endpoint postgres timeout error handling (#88158)

follow up on #87691, it turns out the organization/issues endpoint
actually did not use handle_query_errors and so this fix did not catch.
added it now to the endpoint, aligning it with the other endpoints we
have there. Also made the catch more specific, as QUERY_CANCELED from
postgres are not always timeouts, same code is used for user
cancelations, which do not apply to the error message we are converting
to. Added endpoint tests as well to cover this.

Author: yuvmen

src/sentry/api/utils.py

@@ -427,7 +427,9 @@ def handle_query_errors() -> Generator[None]:
         raise APIException(detail=message)
     except OperationalError as error:
         if hasattr(error, "pgcode") and error.pgcode == psycopg2.errorcodes.QUERY_CANCELED:
-            if options.get("api.postgres-query-timeout-error-handling.enabled"):
+            error_message = str(error)
+            is_timeout = "canceling statement due to statement timeout" in error_message
+            if is_timeout and options.get("api.postgres-query-timeout-error-handling.enabled"):
                 sentry_sdk.set_tag("query.error_reason", "Postgres statement timeout")
                 sentry_sdk.capture_exception(error, level="warning")
                 raise Throttled(

src/sentry/issues/endpoints/organization_group_index.py

@@ -29,7 +29,7 @@
 from sentry.api.paginator import DateTimePaginator, Paginator
 from sentry.api.serializers import serialize
 from sentry.api.serializers.models.group_stream import StreamGroupSerializerSnuba
-from sentry.api.utils import get_date_range_from_stats_period
+from sentry.api.utils import get_date_range_from_stats_period, handle_query_errors
 from sentry.constants import ALLOWED_FUTURE_DELTA
 from sentry.exceptions import InvalidParams, InvalidSearchQuery
 from sentry.models.environment import Environment
@@ -41,7 +41,6 @@
 from sentry.search.events.constants import EQUALITY_OPERATORS
 from sentry.search.snuba.backend import assigned_or_suggested_filter
 from sentry.search.snuba.executors import FIRST_RELEASE_FILTERS, get_search_filter
-from sentry.snuba import discover
 from sentry.utils.cursors import Cursor, CursorResult
 from sentry.utils.validators import normalize_event_id
 
@@ -366,14 +365,15 @@ def get(self, request: Request, organization: Organization) -> Response:
             return Response(serialize(groups, request.user, serializer(), request=request))
 
         try:
-            cursor_result, query_kwargs = self._search(
-                request,
-                organization,
-                projects,
-                environments,
-                {"count_hits": True, "date_to": end, "date_from": start},
-            )
-        except (ValidationError, discover.InvalidSearchQuery) as exc:
+            with handle_query_errors():
+                cursor_result, query_kwargs = self._search(
+                    request,
+                    organization,
+                    projects,
+                    environments,
+                    {"count_hits": True, "date_to": end, "date_from": start},
+                )
+        except ValidationError as exc:
             return Response({"detail": str(exc)}, status=400)
 
         results = list(cursor_result)

tests/sentry/api/test_utils.py

@@ -204,6 +204,9 @@ def test_handle_postgres_timeout(self):
         class TimeoutError(OperationalError):
             pgcode = psycopg2.errorcodes.QUERY_CANCELED
 
+            def __str__(self):
+                return "canceling statement due to statement timeout"
+
         # Test when option is disabled (default)
         try:
             with handle_query_errors():
@@ -223,6 +226,21 @@ class TimeoutError(OperationalError):
                     == "Query timeout. Please try with a smaller date range or fewer conditions."
                 )
 
+    def test_handle_postgres_user_cancel(self):
+        class UserCancelError(OperationalError):
+            pgcode = psycopg2.errorcodes.QUERY_CANCELED
+
+            def __str__(self):
+                return "canceling statement due to user request"
+
+        # Should propagate the error regardless of the feature flag
+        with override_options({"api.postgres-query-timeout-error-handling.enabled": True}):
+            try:
+                with handle_query_errors():
+                    raise UserCancelError()
+            except Exception as e:
+                assert isinstance(e, UserCancelError)  # Should propagate original error
+
     @patch("sentry.api.utils.ParseError")
     def test_handle_other_operational_error(self, mock_parse_error):
         class OtherError(OperationalError):

tests/sentry/issues/endpoints/test_organization_group_index.py

@@ -4,6 +4,8 @@
 from unittest.mock import MagicMock, Mock, call, patch
 from uuid import uuid4
 
+import psycopg2
+from django.db import OperationalError
 from django.urls import reverse
 from django.utils import timezone
 
@@ -4059,6 +4061,45 @@ def test_flags_and_tags_query(self, _: MagicMock) -> None:
             response = self.get_success_response(query='flags["test:flag"]:false')
             assert len(json.loads(response.content)) == 0
 
+    def test_postgres_query_timeout(self, mock_query: MagicMock) -> None:
+        """Test that a Postgres OperationalError with QueryCanceled pgcode becomes a 429 error
+        only when it's a statement timeout, and remains a 500 for user cancellation"""
+
+        class TimeoutError(OperationalError):
+            pgcode = psycopg2.errorcodes.QUERY_CANCELED
+
+            def __str__(self):
+                return "canceling statement due to statement timeout"
+
+        class UserCancelError(OperationalError):
+            pgcode = psycopg2.errorcodes.QUERY_CANCELED
+
+            def __str__(self):
+                return "canceling statement due to user request"
+
+        self.login_as(user=self.user)
+
+        # Test statement timeout when option is disabled (default)
+        mock_query.side_effect = TimeoutError()
+        response = self.get_response()
+        assert response.status_code == 500  # Should propagate original error
+
+        # Test statement timeout when option is enabled
+        with override_options({"api.postgres-query-timeout-error-handling.enabled": True}):
+            mock_query.side_effect = TimeoutError()
+            response = self.get_response()
+            assert response.status_code == 429
+            assert (
+                response.data["detail"]
+                == "Query timeout. Please try with a smaller date range or fewer conditions."
+            )
+
+        # Test user cancellation - should return 500 regardless of feature flag
+        with override_options({"api.postgres-query-timeout-error-handling.enabled": True}):
+            mock_query.side_effect = UserCancelError()
+            response = self.get_response()
+            assert response.status_code == 500
+
 
 class GroupUpdateTest(APITestCase, SnubaTestCase):
     endpoint = "sentry-api-0-organization-group-index"