feat: Option to not trace HTTP requests based on status codes

Author: alexander-alderman-webb

sentry_sdk/consts.py

@@ -919,6 +919,7 @@ def __init__(
         max_stack_frames=DEFAULT_MAX_STACK_FRAMES,  # type: Optional[int]
         enable_logs=False,  # type: bool
         before_send_log=None,  # type: Optional[Callable[[Log, Hint], Optional[Log]]]
+        trace_ignore_status_codes=[],  # type: Sequence[Union[int, Tuple[int, int]]]
     ):
         # type: (...) -> None
         """Initialize the Sentry SDK with the given parameters. All parameters described here can be used in a call to `sentry_sdk.init()`.
@@ -1307,6 +1308,16 @@ def __init__(
             function will be retained. If the function returns None, the log will
             not be sent to Sentry.
 
+        :param trace_ignore_status_codes: An optional property that disables tracing for
+            HTTP requests with certain response codes.
+
+            The option is a list, where elements are individual response codes, or inclusive
+            ranges of response codes. Requests are not traced if any code matches or
+            any provided range contains the response code.
+
+            If `trace_ignore_status_codes` is not provided, requests with any status code
+            may be traced.
+
         :param _experiments:
         """
         pass

sentry_sdk/tracing.py

@@ -30,6 +30,7 @@
     from typing import Tuple
     from typing import Union
     from typing import TypeVar
+    from typing import Sequence
 
     from typing_extensions import TypedDict, Unpack
 
@@ -970,6 +971,30 @@ def _get_scope_from_finish_args(
 
         return scope_or_hub
 
+    def _in_http_status_code_range(self, code, code_ranges):
+        # type: (int, Sequence[Union[int, Tuple[int, int]]]) -> bool
+        for target in code_ranges:
+            if isinstance(target, int):
+                print(code, target, code == target, type(code), type(target))
+                if code == target:
+                    return True
+                continue
+
+            if (
+                len(target) != 2
+                or not isinstance(target[0], int)
+                or not isinstance(target[1], int)
+            ):
+                logger.warning(
+                    "trace_ignore_status_codes must be a sequences including only integers or pairs of integers."
+                )
+                continue
+
+            if target[0] <= code <= target[1]:
+                return True
+
+        return False
+
     def finish(
         self,
         scope=None,  # type: Optional[sentry_sdk.Scope]
@@ -1039,6 +1064,12 @@ def finish(
 
         super().finish(scope, end_timestamp)
 
+        if SPANDATA.HTTP_STATUS_CODE in self._data and self._in_http_status_code_range(
+            self._data[SPANDATA.HTTP_STATUS_CODE],
+            client.options["trace_ignore_status_codes"],
+        ):
+            self.sampled = False
+
         if not self.sampled:
             # At this point a `sampled = None` should have already been resolved
             # to a concrete decision.

tests/tracing/test_ignore_status_codes.py

@@ -0,0 +1,81 @@
+import sentry_sdk
+from sentry_sdk import start_transaction, start_span
+
+import pytest
+
+
+def test_no_ignored_codes(sentry_init, capture_events):
+    sentry_init(
+        traces_sample_rate=1.0,
+    )
+    events = capture_events()
+
+    with start_transaction(op="http", name="GET /"):
+        span_or_tx = sentry_sdk.get_current_span()
+        span_or_tx.set_data("http.response.status_code", 404)
+
+    assert len(events) == 1
+
+
+@pytest.mark.parametrize("status_code", [200, 404])
+def test_single_code_ignored(sentry_init, capture_events, status_code):
+    sentry_init(
+        traces_sample_rate=1.0,
+        trace_ignore_status_codes=(404,),
+    )
+    events = capture_events()
+
+    with start_transaction(op="http", name="GET /"):
+        span_or_tx = sentry_sdk.get_current_span()
+        span_or_tx.set_data("http.response.status_code", status_code)
+
+    if status_code == 404:
+        assert not events
+    else:
+        assert len(events) == 1
+
+
+@pytest.mark.parametrize("status_code", [200, 305, 307, 399, 404])
+def test_range_ignored(sentry_init, capture_events, status_code):
+    sentry_init(
+        traces_sample_rate=1.0,
+        trace_ignore_status_codes=((305, 399),),
+    )
+    events = capture_events()
+
+    with start_transaction(op="http", name="GET /"):
+        span_or_tx = sentry_sdk.get_current_span()
+        span_or_tx.set_data("http.response.status_code", status_code)
+
+    if 305 <= status_code <= 399:
+        assert not events
+    else:
+        assert len(events) == 1
+
+
+@pytest.mark.parametrize("status_code", [200, 301, 303, 355, 404])
+def test_variety_ignored(sentry_init, capture_events, status_code):
+    sentry_init(
+        traces_sample_rate=1.0,
+        trace_ignore_status_codes=(
+            301,
+            302,
+            303,
+            (305, 399),
+            (401, 404),
+        ),
+    )
+    events = capture_events()
+
+    with start_transaction(op="http", name="GET /"):
+        span_or_tx = sentry_sdk.get_current_span()
+        span_or_tx.set_data("http.response.status_code", status_code)
+
+    if (
+        301 <= status_code <= 303
+        or 305 <= status_code <= 399
+        or 401 <= status_code <= 404
+    ):
+        assert not events
+    else:
+        assert len(events) == 1