Improve handling of situation where a request body is never read in the handler

ericapisani · ericapisani · commit b7c0ec6b9702 · 2026-05-15T11:25:07.000-04:00
diff --git a/sentry_sdk/integrations/flask.py b/sentry_sdk/integrations/flask.py
@@ -3,7 +3,6 @@
 import sentry_sdk
 from sentry_sdk.integrations import DidNotEnable, Integration, _check_minimum_version
 from sentry_sdk.integrations._wsgi_common import (
-    _RAW_DATA_EXCEPTIONS,
     DEFAULT_HTTP_METHODS_TO_CAPTURE,
     RequestExtractor,
     _serialize_request_body_data,
@@ -46,6 +45,7 @@
         request_started,
     )
     from markupsafe import Markup
+    from werkzeug.exceptions import ClientDisconnected
 except ImportError:
     raise DidNotEnable("Flask is not installed")
 
@@ -191,13 +191,7 @@ def _set_request_body_data_on_streaming_segment(
         if not request_body_within_bounds(client, content_length):
             data = AnnotatedValue.substituted_because_over_size_limit()
         else:
-            # Only use data that Werkzeug has already cached — never consume
-            # wsgi.input ourselves, as that would break user code that reads
-            # the stream directly.
-            # You can find where this gets set here:
-            # https://github.com/pallets/werkzeug/blob/1b00618e787f40dfb21eba29caf8f8be7c8e1d93/src/werkzeug/wrappers/request.py#L444
             raw_data = getattr(request, "_cached_data", None)
-
             parsed_body = None
             if "form" in request.__dict__:
                 extractor = FlaskRequestExtractor(request)
@@ -206,6 +200,19 @@ def _set_request_body_data_on_streaming_segment(
                 extractor = FlaskRequestExtractor(request)
                 if extractor.is_json():
                     parsed_body = extractor.json()
+            else:
+                # The route never read the body via Werkzeug, but it
+                # may have consumed wsgi.input directly. get_data()
+                # raises ClientDisconnected if the stream is exhausted.
+                try:
+                    raw_data = request.get_data()
+                except ClientDisconnected:
+                    raw_data = None
+
+                if raw_data:
+                    extractor = FlaskRequestExtractor(request)
+                    if extractor.is_json():
+                        parsed_body = extractor.json()
 
             if parsed_body is not None:
                 data = parsed_body
diff --git a/tests/integrations/flask/test_flask.py b/tests/integrations/flask/test_flask.py
@@ -406,13 +406,18 @@ def index():
     assert len(event["request"]["data"]["foo"]) == DEFAULT_MAX_VALUE_LENGTH
 
 
-def test_flask_formdata_request_appear_transaction_body(
-    sentry_init, capture_events, app
+@pytest.mark.parametrize("span_streaming", [True, False])
+def test_flask_formdata_request_appear_in_segment_or_transaction_body(
+    sentry_init, capture_events, capture_items, app, span_streaming
 ):
     """
-    Test that ensures that transaction request data contains body, even if no exception was raised
+    Test that ensures that transaction/segment request data contains body, even if no exception was raised
     """
-    sentry_init(integrations=[flask_sentry.FlaskIntegration()], traces_sample_rate=1.0)
+    sentry_init(
+        integrations=[flask_sentry.FlaskIntegration()],
+        traces_sample_rate=1.0,
+        _experiments={"trace_lifecycle": "stream"} if span_streaming else {},
+    )
 
     data = {"username": "sentry-user", "age": "26"}
 
@@ -430,17 +435,29 @@ def index():
         capture_message("hi")
         return "ok"
 
-    events = capture_events()
+    if span_streaming:
+        items = capture_items("event", "span")
+    else:
+        events = capture_events()
 
     client = app.test_client()
     response = client.post("/", data=data)
     assert response.status_code == 200
 
-    event, transaction_event = events
+    if span_streaming:
+        sentry_sdk.flush()
+
+        spans = [i for i in items if i.type == "span"]
+        assert len(spans) == 1
+        span = spans[0].payload
+
+        assert span["attributes"]["http.request.body.data"] == json.dumps(data)
+    else:
+        event, transaction_event = events
 
-    assert "request" in transaction_event
-    assert "data" in transaction_event["request"]
-    assert transaction_event["request"]["data"] == data
+        assert "request" in transaction_event
+        assert "data" in transaction_event["request"]
+        assert transaction_event["request"]["data"] == data
 
 
 @pytest.mark.parametrize("input_char", ["a", b"a"])
@@ -1357,6 +1374,86 @@ def test_sensitive_header_scrubbing_span_streaming(sentry_init, capture_items, a
     assert span["attributes"]["http.request.header.x-custom-header"] == "passthrough"
 
 
+def test_request_body_captured_when_route_ignores_body_span_streaming(
+    sentry_init, capture_items, app
+):
+    """
+    When the route handler never reads the request body, the SDK should
+    still capture it in _request_finished via request.get_data().
+    """
+    sentry_init(
+        integrations=[flask_sentry.FlaskIntegration()],
+        traces_sample_rate=1.0,
+        max_request_body_size="always",
+        _experiments={"trace_lifecycle": "stream"},
+    )
+
+    body = {"key": "value"}
+
+    @app.route("/ignore-body", methods=["POST"])
+    def ignore_body_endpoint():
+        return "ok"
+
+    items = capture_items("span")
+
+    client = app.test_client()
+    response = client.post("/ignore-body", json=body)
+    assert response.status_code == 200
+
+    sentry_sdk.flush()
+
+    assert len(items) == 1
+    span = items[0].payload
+    assert span["attributes"]["http.request.body.data"] == json.dumps(body)
+
+
+def test_client_disconnected_handled_gracefully_span_streaming(
+    sentry_init, capture_items, app
+):
+    from unittest.mock import patch
+
+    from werkzeug.exceptions import ClientDisconnected
+
+    sentry_init(
+        integrations=[flask_sentry.FlaskIntegration()],
+        traces_sample_rate=1.0,
+        max_request_body_size="always",
+        _experiments={"trace_lifecycle": "stream"},
+    )
+
+    @app.route("/disconnect", methods=["POST"])
+    def disconnect_endpoint():
+        # Simulate a client that disconnected: patch get_data so that
+        # when _request_finished tries to read the body it raises.
+        request._cached_data = None
+        request.__dict__.pop("form", None)
+        patch.object(
+            type(request._get_current_object()),
+            "get_data",
+            side_effect=ClientDisconnected(),
+        ).start()
+        return "ok"
+
+    items = capture_items("span")
+
+    client = app.test_client()
+    try:
+        response = client.post(
+            "/disconnect",
+            data=b'{"key": "value"}',
+            content_type="application/json",
+        )
+        assert response.status_code == 200
+    finally:
+        patch.stopall()
+
+    sentry_sdk.flush()
+
+    assert len(items) == 1
+    span = items[0].payload
+    assert "http.request.body.data" not in span.get("attributes", {})
+
+
 def test_wsgi_input_direct_read_does_not_hang_span_streaming(
     sentry_init, capture_items, app
 ):
