chore(sentry apps): Ignore a bunch more client side errors (#95829)

Author: Christinarlong

src/sentry/sentry_apps/tasks/sentry_apps.py

@@ -7,7 +7,8 @@
 from typing import Any
 
 from django.urls import reverse
-from requests.exceptions import ChunkedEncodingError, RequestException
+from requests import HTTPError, Timeout
+from requests.exceptions import ChunkedEncodingError, ConnectionError, RequestException
 
 from sentry import analytics, features, nodestore
 from sentry.api.serializers import serialize
@@ -78,8 +79,15 @@
 }
 
 retry_decorator = retry(
-    on=(RequestException, ApiHostError, ApiTimeoutError),
-    on_silent=(ChunkedEncodingError),
+    on=(RequestException),
+    on_silent=(
+        ChunkedEncodingError,
+        Timeout,
+        ApiHostError,
+        ApiTimeoutError,
+        ConnectionError,
+        HTTPError,
+    ),
     ignore=(
         ClientError,
         SentryAppSentryError,

tests/sentry/sentry_apps/tasks/test_sentry_apps.py

@@ -4,7 +4,8 @@
 import pytest
 import responses
 from django.urls import reverse
-from requests.exceptions import ChunkedEncodingError
+from requests import HTTPError
+from requests.exceptions import ChunkedEncodingError, ConnectionError, Timeout
 
 from sentry.api.serializers import serialize
 from sentry.api.serializers.rest_framework import convert_dict_key_case, snake_to_camel_case
@@ -71,6 +72,10 @@ def raiseException():
     raise Exception
 
 
+def raiseHTTPError():
+    raise HTTPError()
+
+
 class RequestMock:
     def __init__(self):
         self.body = "blah blah"
@@ -99,6 +104,9 @@ def __init__(self):
 )
 MockResponseInstance = MockResponse({}, b"{}", "", True, 200, raiseStatusFalse, None)
 MockResponse404 = MockResponse({}, b'{"bruh": "bruhhhhhhh"}', "", False, 404, raiseException, None)
+MockResponse504 = MockResponse(headers, json_content, "", False, 504, raiseStatusFalse, None)
+MockResponse503 = MockResponse(headers, json_content, "", False, 503, raiseStatusFalse, None)
+MockResponse502 = MockResponse(headers, json_content, "", False, 502, raiseHTTPError, None)
 
 
 class TestSendAlertEvent(TestCase, OccurrenceTestMixin):
@@ -594,6 +602,126 @@ def test_ignores_restricted_ip_error(self, capture_exception, safe_urlopen):
         assert len(capture_exception.mock_calls) == 0
         assert safe_urlopen.called
 
+    @patch("sentry_sdk.capture_exception")
+    def test_ignores_timeout_error(self, capture_exception, safe_urlopen):
+        safe_urlopen.side_effect = Timeout()
+
+        event = self.store_event(data={}, project_id=self.project.id)
+        assert event.group is not None
+
+        # The task should complete without reporting to sentry when Timeout is raised
+        # because it's in the on_silent list of the retry decorator
+        with self.tasks():
+            post_process_group(
+                is_new=True,
+                is_regression=False,
+                is_new_group_environment=False,
+                cache_key=write_event_to_cache(event),
+                group_id=event.group_id,
+                project_id=self.project.id,
+                eventstream_type=EventStreamEventType.Error.value,
+            )
+
+        # Verify that the exception was not captured by Sentry since it's on_silent
+        assert len(capture_exception.mock_calls) == 0
+        assert safe_urlopen.called
+
+    @patch("sentry_sdk.capture_exception")
+    def test_ignores_api_host_error(self, capture_exception, safe_urlopen):
+        safe_urlopen.return_value = MockResponse503
+
+        event = self.store_event(data={}, project_id=self.project.id)
+        assert event.group is not None
+
+        # The task should complete without reporting to sentry when ApiHostError is raised
+        # because it's in the on_silent list of the retry decorator
+        with self.tasks():
+            post_process_group(
+                is_new=True,
+                is_regression=False,
+                is_new_group_environment=False,
+                cache_key=write_event_to_cache(event),
+                group_id=event.group_id,
+                project_id=self.project.id,
+                eventstream_type=EventStreamEventType.Error.value,
+            )
+
+        # Verify that the exception was not captured by Sentry since it's on_silent
+        assert len(capture_exception.mock_calls) == 0
+        assert safe_urlopen.called
+
+    @patch("sentry_sdk.capture_exception")
+    def test_ignores_api_timeout_error(self, capture_exception, safe_urlopen):
+        safe_urlopen.return_value = MockResponse504
+
+        event = self.store_event(data={}, project_id=self.project.id)
+        assert event.group is not None
+
+        # The task should complete without reporting to sentry when ApiTimeoutError is raised
+        # because it's in the on_silent list of the retry decorator
+        with self.tasks():
+            post_process_group(
+                is_new=True,
+                is_regression=False,
+                is_new_group_environment=False,
+                cache_key=write_event_to_cache(event),
+                group_id=event.group_id,
+                project_id=self.project.id,
+                eventstream_type=EventStreamEventType.Error.value,
+            )
+
+        # Verify that the exception was not captured by Sentry since it's on_silent
+        assert len(capture_exception.mock_calls) == 0
+        assert safe_urlopen.called
+
+    @patch("sentry_sdk.capture_exception")
+    def test_ignores_connection_error(self, capture_exception, safe_urlopen):
+        safe_urlopen.side_effect = ConnectionError()
+
+        event = self.store_event(data={}, project_id=self.project.id)
+        assert event.group is not None
+
+        # The task should complete without reporting to sentry when ConnectionError is raised
+        # because it's in the on_silent list of the retry decorator
+        with self.tasks():
+            post_process_group(
+                is_new=True,
+                is_regression=False,
+                is_new_group_environment=False,
+                cache_key=write_event_to_cache(event),
+                group_id=event.group_id,
+                project_id=self.project.id,
+                eventstream_type=EventStreamEventType.Error.value,
+            )
+
+        # Verify that the exception was not captured by Sentry since it's on_silent
+        assert len(capture_exception.mock_calls) == 0
+        assert safe_urlopen.called
+
+    @patch("sentry_sdk.capture_exception")
+    def test_ignores_http_error(self, capture_exception, safe_urlopen):
+        safe_urlopen.return_value = MockResponse502
+
+        event = self.store_event(data={}, project_id=self.project.id)
+        assert event.group is not None
+
+        # The task should complete without reporting to sentry when HTTPError is raised
+        # because it's in the on_silent list of the retry decorator
+        with self.tasks():
+            post_process_group(
+                is_new=True,
+                is_regression=False,
+                is_new_group_environment=False,
+                cache_key=write_event_to_cache(event),
+                group_id=event.group_id,
+                project_id=self.project.id,
+                eventstream_type=EventStreamEventType.Error.value,
+            )
+
+        # Verify that the exception was not captured by Sentry since it's on_silent
+        assert len(capture_exception.mock_calls) == 0
+        assert safe_urlopen.called
+
     @patch("sentry_sdk.capture_exception")
     def test_silently_retries_chunked_encoding_error_unpublished(
         self, capture_exception, safe_urlopen