getsentry · sentrivana · Aug 12, 2026 · Aug 7, 2026 · Aug 7, 2026 · Aug 7, 2026
@@ -7,7 +7,7 @@
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.traces import StreamedSpan
 from sentry_sdk.tracing import Span
-from sentry_sdk.tracing_utils import has_span_streaming_enabled
+from sentry_sdk.tracing_utils import add_http_breadcrumb, has_span_streaming_enabled
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     parse_url,
@@ -64,54 +64,83 @@ def _sentry_request_created(
     if client.get_integration(Boto3Integration) is None:
         return
 
+    parsed_url = None
+    if request.url is not None:
+        with capture_internal_exceptions():
+            parsed_url = parse_url(request.url, sanitize=False)
+
+    breadcrumb: "dict[str, Any]" = {}
+
     is_span_streaming_enabled = has_span_streaming_enabled(client.options)
-    span: "Union[Span, StreamedSpan]"
+    span: "Union[Span, StreamedSpan, None]" = None
     if is_span_streaming_enabled:
-        if sentry_sdk.traces.get_current_span() is None:
-            return
-        span = sentry_sdk.traces.start_span(
-            name=description,
-            attributes={
-                "sentry.op": OP.HTTP_CLIENT,
-                "sentry.origin": Boto3Integration.origin,
-                SPANDATA.RPC_METHOD: f"{service_id}/{operation_name}",
-            },
-        )
-        if request.url is not None and should_send_default_pii():
-            with capture_internal_exceptions():
-                parsed_url = parse_url(request.url, sanitize=False)
-                span.set_attribute(SPANDATA.URL_FULL, parsed_url.url)
-                span.set_attribute(SPANDATA.URL_QUERY, parsed_url.query)
-                span.set_attribute(SPANDATA.URL_FRAGMENT, parsed_url.fragment)
+        if parsed_url and should_send_default_pii():
+            breadcrumb.update(
+                {
+                    SPANDATA.URL_FULL: parsed_url.url,
+                    SPANDATA.URL_QUERY: parsed_url.query,
+                    SPANDATA.URL_FRAGMENT: parsed_url.fragment,
+                }
+            )
 
         if request.method is not None:
-            span.set_attribute(SPANDATA.HTTP_REQUEST_METHOD, request.method)
+            breadcrumb[SPANDATA.HTTP_REQUEST_METHOD] = request.method
+
+        if sentry_sdk.traces.get_current_span() is not None:
+            span = sentry_sdk.traces.start_span(
+                name=description,
+                attributes={
+                    "sentry.op": OP.HTTP_CLIENT,
+                    "sentry.origin": Boto3Integration.origin,
+                    SPANDATA.RPC_METHOD: f"{service_id}/{operation_name}",
+                },
+            )
+            if parsed_url and should_send_default_pii():
+                span.set_attributes(
+                    {
+                        SPANDATA.URL_FULL: parsed_url.url,
+                        SPANDATA.URL_QUERY: parsed_url.query,
+                        SPANDATA.URL_FRAGMENT: parsed_url.fragment,
+                    }
+                )
+
+            if request.method is not None:
+                span.set_attribute(SPANDATA.HTTP_REQUEST_METHOD, request.method)
     else:
         span = sentry_sdk.start_span(
             op=OP.HTTP_CLIENT,
             name=description,
             origin=Boto3Integration.origin,
         )
 
-        if request.url is not None:
-            with capture_internal_exceptions():
-                parsed_url = parse_url(request.url, sanitize=False)
-                span.set_data("aws.request.url", parsed_url.url)
-                span.set_data(SPANDATA.HTTP_QUERY, parsed_url.query)
-                span.set_data(SPANDATA.HTTP_FRAGMENT, parsed_url.fragment)
+        if parsed_url:
+            span.set_data("aws.request.url", parsed_url.url)
+            span.set_data(SPANDATA.HTTP_QUERY, parsed_url.query)
+            span.set_data(SPANDATA.HTTP_FRAGMENT, parsed_url.fragment)
+            breadcrumb.update(
+                {
+                    "aws.request.url": parsed_url.url,
+                    SPANDATA.HTTP_QUERY: parsed_url.query,
+                    SPANDATA.HTTP_FRAGMENT: parsed_url.fragment,
+                }
+            )
 
         span.set_tag("aws.service_id", service_id.hyphenize())
         span.set_tag("aws.operation_name", operation_name)
         if request.method is not None:
             span.set_data(SPANDATA.HTTP_METHOD, request.method)
+            breadcrumb[SPANDATA.HTTP_METHOD] = request.method
 
-    # We do it in order for subsequent http calls/retries be
-    # attached to this span.
-    span.__enter__()
+        # We do it in order for subsequent http calls/retries be
+        # attached to this span.
+        span.__enter__()
 
-    # request.context is an open-ended data-structure
-    # where we can add anything useful in request life cycle.
-    request.context["_sentrysdk_span"] = span
+    add_http_breadcrumb(None, breadcrumb)
+
+    if span is not None:
+        # request.context is an open-ended data-structure
+        # where we can add anything useful in request life cycle.
+        request.context["_sentrysdk_span"] = span
 
 
 def _sentry_after_call(
@@ -122,6 +151,7 @@ def _sentry_after_call(
     # Span could be absent if the integration is disabled.
     if span is None:
         return
+
     span.__exit__(None, None, None)
 
     body = parsed.get("Body")
@@ -186,4 +216,5 @@ def _sentry_after_call_error(
     # Span could be absent if the integration is disabled.
     if span is None:
         return
+
     span.__exit__(type(exception), exception, None)
@@ -700,8 +700,6 @@ def finish(
             if has_ai_op or is_ai_span_op:
                 self.set_data("gen_ai.conversation.id", conversation_id)
 
-        maybe_create_breadcrumbs_from_span(scope, self)
-
         return None
 
     def to_json(self) -> "Dict[str, Any]":
@@ -1495,5 +1493,4 @@ def calculate_interest_rate(amount, rate, years):
     extract_sentrytrace_data,
     has_span_streaming_enabled,
     has_tracing_enabled,
-    maybe_create_breadcrumbs_from_span,
 )
@@ -225,32 +225,6 @@ def add_http_breadcrumb(status_code: "Optional[int]", data: "dict[str, Any]") ->
     sentry_sdk.add_breadcrumb(**kwargs)
 
 
-def maybe_create_breadcrumbs_from_span(
-    scope: "sentry_sdk.Scope", span: "sentry_sdk.tracing.Span"
-) -> None:
-    if span.op == OP.HTTP_CLIENT and span.origin not in (
-        "auto.http.aiohttp",
-        "auto.http.pyreqwest",
-        "auto.http.httpx",
-        "auto.http.httpx2",
-        "auto.http.stdlib.httplib",
-    ):
-        level = None
-        status_code = span._data.get(SPANDATA.HTTP_STATUS_CODE)
-        if status_code:
-            if 500 <= status_code <= 599:
-                level = "error"
-            elif 400 <= status_code <= 499:
-                level = "warning"
-
-        if level:
-            scope.add_breadcrumb(
-                type="http", category="httplib", data=span._data, level=level
-            )
-        else:
-            scope.add_breadcrumb(type="http", category="httplib", data=span._data)
-
-
 def _get_frame_module_abs_path(frame: "FrameType") -> "Optional[str]":
     try:
         return frame.f_code.co_filename

@@ -4,6 +4,8 @@
 import pytest
 
 import sentry_sdk
+from sentry_sdk import capture_message
+from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations.boto3 import Boto3Integration
 from tests.conftest import ApproxDict
 from tests.integrations.boto3 import read_fixture
@@ -360,3 +362,79 @@ def test_span_origin(
 
         assert event["contexts"]["trace"]["origin"] == "manual"
         assert event["spans"][0]["origin"] == "auto.http.boto3"
+
+
+def test_breadcrumb(sentry_init, capture_events):
+    sentry_init(
+        integrations=[Boto3Integration()],
+        default_integrations=False,
+    )
+
+    s3 = session.resource("s3")
+    bucket = s3.Bucket("bucket")
+
+    events = capture_events()
+
+    with MockResponse(s3.meta.client, 200, {}, read_fixture("s3_list.xml")):
+        _ = [obj for obj in bucket.objects.all()]
+
+    capture_message("Testing!")
+
+    (event,) = events
+    (crumb,) = event["breadcrumbs"]["values"]
+    assert crumb["type"] == "http"
+    assert crumb["category"] == "httplib"
+    assert crumb["data"] == ApproxDict(
+        {
+            "aws.request.url": mock.ANY,
+            SPANDATA.HTTP_METHOD: "GET",
+            SPANDATA.HTTP_QUERY: mock.ANY,
+            SPANDATA.HTTP_FRAGMENT: "",
+        }
+    )
+
+
+@pytest.mark.parametrize("send_default_pii", [True, False])
+def test_breadcrumb_span_streaming(sentry_init, capture_events, send_default_pii):
+    sentry_init(
+        integrations=[Boto3Integration()],
+        default_integrations=False,
+        trace_lifecycle="stream",
+        send_default_pii=send_default_pii,
+    )
+
+    s3 = session.resource("s3")
+    bucket = s3.Bucket("bucket")
+
+    events = capture_events()
+
+    with sentry_sdk.traces.start_span(name="custom parent"), MockResponse(
+        s3.meta.client, 200, {}, read_fixture("s3_list.xml")
+    ):
+        _ = [obj for obj in bucket.objects.all()]
+
+    capture_message("Testing!")
+
+    (event,) = events
+    (crumb,) = event["breadcrumbs"]["values"]
+    assert crumb["type"] == "http"
+    assert crumb["category"] == "httplib"
+
+    if send_default_pii:
+        assert crumb["data"] == ApproxDict(
+            {
+                SPANDATA.URL_FULL: mock.ANY,
+                SPANDATA.HTTP_REQUEST_METHOD: "GET",
+                SPANDATA.URL_QUERY: mock.ANY,
+                SPANDATA.URL_FRAGMENT: "",
+            }
+        )
+    else:
+        assert crumb["data"] == ApproxDict(
+            {
+                SPANDATA.HTTP_REQUEST_METHOD: "GET",
+            }
+        )
+        assert SPANDATA.URL_FULL not in crumb["data"]
+        assert SPANDATA.URL_QUERY not in crumb["data"]
+        assert SPANDATA.URL_FRAGMENT not in crumb["data"]