From 32ea92b330e67de8ab6913e603349a7d22547355 Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Mon, 31 Aug 2026 11:23:40 +0200 Subject: [PATCH 1/3] test(flask): Remove transactions and span_streaming parametrization --- tests/integrations/flask/test_flask.py | 283 ++++++------------------- 1 file changed, 70 insertions(+), 213 deletions(-) diff --git a/tests/integrations/flask/test_flask.py b/tests/integrations/flask/test_flask.py index c6140bfcf0..030c59bac5 100644 --- a/tests/integrations/flask/test_flask.py +++ b/tests/integrations/flask/test_flask.py @@ -116,7 +116,7 @@ def test_transaction_or_segment_style( flask_sentry.FlaskIntegration(transaction_style=transaction_style) ], traces_sample_rate=1.0, - trace_lifecycle="stream" if span_streaming else "static", + trace_lifecycle="stream", ) if span_streaming: @@ -450,7 +450,11 @@ def test_flask_formdata_request_appear_transaction_body( """ Test that ensures that transaction 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, + trace_lifecycle="stream", + ) data = {"username": "sentry-user", "age": "26"} @@ -819,14 +823,16 @@ def zerodivision(e): assert not events -@pytest.mark.parametrize("span_streaming", [True, False]) def test_tracing_success( - sentry_init, capture_events, capture_items, app, span_streaming + sentry_init, + capture_events, + capture_items, + app, ): sentry_init( traces_sample_rate=1.0, integrations=[flask_sentry.FlaskIntegration()], - trace_lifecycle="stream" if span_streaming else "static", + trace_lifecycle="stream", ) @app.before_request @@ -839,61 +845,40 @@ def hi_tx(): capture_message("hi") return "ok" - if span_streaming: - items = capture_items("event", "span") - else: - events = capture_events() + items = capture_items("event", "span") with app.test_client() as client: response = client.get("/message_tx") assert response.status_code == 200 - if span_streaming: - sentry_sdk.flush() - spans = [i.payload for i in items if i.type == "span"] - message_events = [i.payload for i in items if i.type == "event"] - - assert len(spans) == 1 - assert len(message_events) == 1 - - (segment,) = spans - (message_event,) = message_events + sentry_sdk.flush() + spans = [i.payload for i in items if i.type == "span"] + message_events = [i.payload for i in items if i.type == "event"] - assert segment["name"] == "hi_tx" - assert segment["status"] == SpanStatus.OK - assert segment["attributes"]["sentry.origin"] == "auto.http.flask" + assert len(spans) == 1 + assert len(message_events) == 1 - assert message_event["message"] == "hi" - assert message_event["transaction"] == "hi_tx" - assert message_event["tags"]["view"] == "yes" - assert message_event["tags"]["before_request"] == "yes" - else: - message_event, transaction_event = events + (segment,) = spans + (message_event,) = message_events - assert transaction_event["type"] == "transaction" - assert transaction_event["transaction"] == "hi_tx" - assert transaction_event["contexts"]["trace"]["status"] == "ok" - assert transaction_event["tags"]["view"] == "yes" - assert transaction_event["tags"]["before_request"] == "yes" + assert segment["name"] == "hi_tx" + assert segment["status"] == SpanStatus.OK + assert segment["attributes"]["sentry.origin"] == "auto.http.flask" - assert message_event["message"] == "hi" - assert message_event["transaction"] == "hi_tx" - assert message_event["tags"]["view"] == "yes" - assert message_event["tags"]["before_request"] == "yes" + assert message_event["message"] == "hi" + assert message_event["transaction"] == "hi_tx" + assert message_event["tags"]["view"] == "yes" + assert message_event["tags"]["before_request"] == "yes" -@pytest.mark.parametrize("span_streaming", [True, False]) -def test_tracing_error(sentry_init, capture_events, capture_items, app, span_streaming): +def test_tracing_error(sentry_init, capture_events, capture_items, app): sentry_init( traces_sample_rate=1.0, integrations=[flask_sentry.FlaskIntegration()], - trace_lifecycle="stream" if span_streaming else "static", + trace_lifecycle="stream", ) - if span_streaming: - items = capture_items("event", "span") - else: - events = capture_events() + items = capture_items("event", "span") @app.route("/error") def error(): @@ -904,33 +889,23 @@ def error(): response = client.get("/error") assert response.status_code == 500 - if span_streaming: - sentry_sdk.flush() - spans = [i.payload for i in items if i.type == "span"] - error_events = [i.payload for i in items if i.type == "event"] - - assert len(spans) == 1 - assert len(error_events) == 1 + sentry_sdk.flush() - (segment,) = spans - (error_event,) = error_events + spans = [i.payload for i in items if i.type == "span"] + error_events = [i.payload for i in items if i.type == "event"] - assert segment["name"] == "error" - assert segment["status"] == SpanStatus.ERROR + assert len(spans) == 1 + assert len(error_events) == 1 - assert error_event["transaction"] == "error" - (exception,) = error_event["exception"]["values"] - assert exception["type"] == "ZeroDivisionError" - else: - error_event, transaction_event = events + (segment,) = spans + (error_event,) = error_events - assert transaction_event["type"] == "transaction" - assert transaction_event["transaction"] == "error" - assert transaction_event["contexts"]["trace"]["status"] == "internal_error" + assert segment["name"] == "error" + assert segment["status"] == SpanStatus.ERROR - assert error_event["transaction"] == "error" - (exception,) = error_event["exception"]["values"] - assert exception["type"] == "ZeroDivisionError" + assert error_event["transaction"] == "error" + (exception,) = error_event["exception"]["values"] + assert exception["type"] == "ZeroDivisionError" def test_error_has_trace_context_if_tracing_disabled(sentry_init, capture_events, app): @@ -1054,98 +1029,31 @@ def index(): assert event["request"]["headers"]["Proxy-Authorization"] == "[Filtered]" -def test_response_status_code_ok_in_transaction_context( - sentry_init, capture_envelopes, app -): - """ - Tests that the response status code is added to the transaction context. - This also works for when there is an Exception during the request, but somehow the test flask app doesn't seem to trigger that. - """ +def test_span_origin(sentry_init, app, capture_events, capture_items): sentry_init( integrations=[flask_sentry.FlaskIntegration()], traces_sample_rate=1.0, - release="demo-release", + trace_lifecycle="stream", ) - envelopes = capture_envelopes() + items = capture_items("span") client = app.test_client() client.get("/message") - sentry_sdk.get_client().flush() - - (_, transaction_envelope, _) = envelopes - transaction = transaction_envelope.get_transaction_event() - - assert transaction["type"] == "transaction" - assert len(transaction["contexts"]) > 0 - assert "response" in transaction["contexts"].keys(), ( - "Response context not found in transaction" - ) - assert transaction["contexts"]["response"]["status_code"] == 200 - - -def test_response_status_code_not_found_in_transaction_context( - sentry_init, capture_envelopes, app -): - sentry_init( - integrations=[flask_sentry.FlaskIntegration()], - traces_sample_rate=1.0, - release="demo-release", - ) - - envelopes = capture_envelopes() - - client = app.test_client() - client.get("/not-existing-route") - - sentry_sdk.get_client().flush() - - (transaction_envelope, _) = envelopes - transaction = transaction_envelope.get_transaction_event() - - assert transaction["type"] == "transaction" - assert len(transaction["contexts"]) > 0 - assert "response" in transaction["contexts"].keys(), ( - "Response context not found in transaction" - ) - assert transaction["contexts"]["response"]["status_code"] == 404 - - -@pytest.mark.parametrize("span_streaming", [True, False]) -def test_span_origin(sentry_init, app, capture_events, capture_items, span_streaming): - sentry_init( - integrations=[flask_sentry.FlaskIntegration()], - traces_sample_rate=1.0, - trace_lifecycle="stream" if span_streaming else "static", - ) - - if span_streaming: - items = capture_items("span") - else: - events = capture_events() - - client = app.test_client() - client.get("/message") + sentry_sdk.flush() - if span_streaming: - sentry_sdk.flush() - spans = [i.payload for i in items] - assert len(spans) == 1 - (segment,) = spans - assert segment["attributes"]["sentry.origin"] == "auto.http.flask" - else: - (_, event) = events - assert event["contexts"]["trace"]["origin"] == "auto.http.flask" + spans = [i.payload for i in items] + assert len(spans) == 1 + (segment,) = spans + assert segment["attributes"]["sentry.origin"] == "auto.http.flask" -@pytest.mark.parametrize("span_streaming", [True, False]) def test_transaction_or_segment_http_method_default( sentry_init, app, capture_events, capture_items, - span_streaming, ): """ By default OPTIONS and HEAD requests do not create a transaction or segment. @@ -1153,13 +1061,10 @@ def test_transaction_or_segment_http_method_default( sentry_init( traces_sample_rate=1.0, integrations=[flask_sentry.FlaskIntegration()], - trace_lifecycle="stream" if span_streaming else "static", + trace_lifecycle="stream", ) - if span_streaming: - items = capture_items("span") - else: - events = capture_events() + items = capture_items("span") client = app.test_client() response = client.get("/nomessage") @@ -1171,25 +1076,19 @@ def test_transaction_or_segment_http_method_default( response = client.head("/nomessage") assert response.status_code == 200 - if span_streaming: - sentry_sdk.flush() - spans = [i.payload for i in items] - assert len(spans) == 1 - (segment,) = spans - assert segment["attributes"]["http.request.method"] == "GET" - else: - (event,) = events - assert len(events) == 1 - assert event["request"]["method"] == "GET" + sentry_sdk.flush() + + spans = [i.payload for i in items] + assert len(spans) == 1 + (segment,) = spans + assert segment["attributes"]["http.request.method"] == "GET" -@pytest.mark.parametrize("span_streaming", [True, False]) def test_transaction_or_segment_http_method_custom( sentry_init, app, capture_events, capture_items, - span_streaming, ): """ Configure FlaskIntegration to ONLY capture OPTIONS and HEAD requests. @@ -1204,13 +1103,10 @@ def test_transaction_or_segment_http_method_custom( ) # capitalization does not matter ) # case does not matter ], - trace_lifecycle="stream" if span_streaming else "static", + trace_lifecycle="stream", ) - if span_streaming: - items = capture_items("span") - else: - events = capture_events() + items = capture_items("span") client = app.test_client() response = client.get("/nomessage") @@ -1219,32 +1115,21 @@ def test_transaction_or_segment_http_method_custom( response = client.options("/nomessage") assert response.status_code == 200 - if span_streaming: - sentry_sdk.flush() - spans = [i.payload for i in items] - (options_segment,) = spans - assert options_segment["attributes"]["http.request.method"] == "OPTIONS" - - response = client.head("/nomessage") - assert response.status_code == 200 - - sentry_sdk.flush() - spans = [i.payload for i in items] - assert len(spans) == 2 - (_, head_segment) = spans + sentry_sdk.flush() - assert head_segment["attributes"]["http.request.method"] == "HEAD" - else: - (event1,) = events - assert event1["request"]["method"] == "OPTIONS" + spans = [i.payload for i in items] + (options_segment,) = spans + assert options_segment["attributes"]["http.request.method"] == "OPTIONS" - response = client.head("/nomessage") - assert response.status_code == 200 + response = client.head("/nomessage") + assert response.status_code == 200 - assert len(events) == 2 - (_, event2) = events + sentry_sdk.flush() + spans = [i.payload for i in items] + assert len(spans) == 2 + (_, head_segment) = spans - assert event2["request"]["method"] == "HEAD" + assert head_segment["attributes"]["http.request.method"] == "HEAD" @pytest.mark.parametrize( @@ -1686,34 +1571,6 @@ def index(): assert "data" not in event.get("_meta", {}).get("request", {}) -def test_flask_transaction_request_body_data_collection( - sentry_init, capture_events, app, monkeypatch -): - sentry_init( - integrations=[flask_sentry.FlaskIntegration()], - traces_sample_rate=1.0, - _experiments={"data_collection": {"http_bodies": []}}, - ) - monkeypatch.setattr(flask_sentry, "flask_login", None) - - data = {"username": "sentry-user", "age": "26"} - - @app.route("/", methods=["POST"]) - def index(): - capture_message("hi") - return "ok" - - events = capture_events() - - client = app.test_client() - response = client.post("/", content_type="application/json", data=data) - assert response.status_code == 200 - - event, transaction_event = events - assert "data" not in event["request"] - assert "data" not in transaction_event["request"] - - def test_flask_oversized_request_body_not_annotated_data_collection( sentry_init, capture_events, app, monkeypatch ): From 5f83b25c6b63dfbd17956948e2a3b8c8f07c4b34 Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Mon, 31 Aug 2026 11:24:54 +0200 Subject: [PATCH 2/3] . --- tests/integrations/flask/test_flask.py | 69 ++++---------------------- 1 file changed, 10 insertions(+), 59 deletions(-) diff --git a/tests/integrations/flask/test_flask.py b/tests/integrations/flask/test_flask.py index 030c59bac5..a3f9ef5b71 100644 --- a/tests/integrations/flask/test_flask.py +++ b/tests/integrations/flask/test_flask.py @@ -90,7 +90,6 @@ def test_has_context(sentry_init, app, capture_events): assert event["request"]["url"] == "http://localhost/message" -@pytest.mark.parametrize("span_streaming", [True, False]) @pytest.mark.parametrize( "url,transaction_style,expected_transaction,expected_source", [ @@ -119,26 +118,19 @@ def test_transaction_or_segment_style( trace_lifecycle="stream", ) - if span_streaming: - items = capture_items("span") - else: - events = capture_events() + items = capture_items("span") client = app.test_client() response = client.get(url) assert response.status_code == 200 - if span_streaming: - sentry_sdk.flush() - spans = [i.payload for i in items] - assert len(spans) == 1 - (segment,) = spans - assert segment["name"] == expected_transaction - assert segment["attributes"]["sentry.segment.name.source"] == expected_source - else: - (_, event) = events - assert event["transaction"] == expected_transaction - assert event["transaction_info"] == {"source": expected_source} + sentry_sdk.flush() + + spans = [i.payload for i in items] + assert len(spans) == 1 + (segment,) = spans + assert segment["name"] == expected_transaction + assert segment["attributes"]["sentry.segment.name.source"] == expected_source @pytest.mark.parametrize("debug", (True, False)) @@ -444,47 +436,6 @@ def index(): assert len(event["request"]["data"]["foo"]) == 1034 -def test_flask_formdata_request_appear_transaction_body( - sentry_init, capture_events, app -): - """ - Test that ensures that transaction request data contains body, even if no exception was raised - """ - sentry_init( - integrations=[flask_sentry.FlaskIntegration()], - traces_sample_rate=1.0, - trace_lifecycle="stream", - ) - - data = {"username": "sentry-user", "age": "26"} - - @app.route("/", methods=["POST"]) - def index(): - assert request.form["username"] == data["username"] - assert request.form["age"] == data["age"] - assert not request.get_data() - try: - assert not request.get_json() - except UnsupportedMediaType: - # flask/werkzeug 3 - pass - set_tag("view", "yes") - capture_message("hi") - return "ok" - - events = capture_events() - - client = app.test_client() - response = client.post("/", data=data) - assert response.status_code == 200 - - event, transaction_event = events - - 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"]) def test_flask_too_large_raw_request(sentry_init, input_char, capture_events, app): sentry_init( @@ -1049,7 +1000,7 @@ def test_span_origin(sentry_init, app, capture_events, capture_items): assert segment["attributes"]["sentry.origin"] == "auto.http.flask" -def test_transaction_or_segment_http_method_default( +def test_segment_http_method_default( sentry_init, app, capture_events, @@ -1084,7 +1035,7 @@ def test_transaction_or_segment_http_method_default( assert segment["attributes"]["http.request.method"] == "GET" -def test_transaction_or_segment_http_method_custom( +def test_segment_http_method_custom( sentry_init, app, capture_events, From 2990c90e42cfadc113079d80ad8f92b9a938586a Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Mon, 31 Aug 2026 11:37:35 +0200 Subject: [PATCH 3/3] missed some --- tests/integrations/flask/test_flask.py | 49 +++++++++----------------- 1 file changed, 16 insertions(+), 33 deletions(-) diff --git a/tests/integrations/flask/test_flask.py b/tests/integrations/flask/test_flask.py index a3f9ef5b71..09e8e51ef8 100644 --- a/tests/integrations/flask/test_flask.py +++ b/tests/integrations/flask/test_flask.py @@ -108,7 +108,6 @@ def test_transaction_or_segment_style( transaction_style, expected_transaction, expected_source, - span_streaming, ): sentry_init( integrations=[ @@ -217,7 +216,6 @@ def test_flask_login_partially_configured( assert event.get("user", {}).get("id") is None -@pytest.mark.parametrize("span_streaming", [True, False]) @pytest.mark.parametrize("send_default_pii", [True, False]) @pytest.mark.parametrize("user_id", [None, "42", 3]) def test_flask_login_configured( @@ -229,17 +227,13 @@ def test_flask_login_configured( capture_items, monkeypatch, integration_enabled_params, - span_streaming, ): - if span_streaming: - sentry_init( - integrations=[flask_sentry.FlaskIntegration()], - send_default_pii=send_default_pii, - traces_sample_rate=1.0, - trace_lifecycle="stream", - ) - else: - sentry_init(send_default_pii=send_default_pii, **integration_enabled_params) + sentry_init( + integrations=[flask_sentry.FlaskIntegration()], + send_default_pii=send_default_pii, + traces_sample_rate=1.0, + trace_lifecycle="stream", + ) class User: is_authenticated = is_active = True @@ -261,34 +255,23 @@ def login(): login_user(User()) return "ok" - if span_streaming: - items = capture_items("event", "span") - else: - events = capture_events() + items = capture_items("event", "span") client = app.test_client() assert client.get("/login").status_code == 200 assert client.get("/message").status_code == 200 - if span_streaming: - sentry_sdk.flush() - spans = [i.payload for i in items if i.type == "span"] - segment = next(s for s in spans if s["name"] == "hi") + sentry_sdk.flush() - if send_default_pii and user_id is not None: - assert segment["attributes"]["user.id"] == str(user_id) - assert segment["attributes"]["user.email"] == "user@example.com" - assert segment["attributes"]["user.name"] == "testuser" - else: - assert "user.id" not in segment.get("attributes", {}) + spans = [i.payload for i in items if i.type == "span"] + segment = next(s for s in spans if s["name"] == "hi") + + if send_default_pii and user_id is not None: + assert segment["attributes"]["user.id"] == str(user_id) + assert segment["attributes"]["user.email"] == "user@example.com" + assert segment["attributes"]["user.name"] == "testuser" else: - (event,) = events - if user_id is None or not send_default_pii: - assert event.get("user", {}).get("id") is None - else: - assert event["user"]["id"] == str(user_id) - assert event["user"]["email"] == "user@example.com" - assert event["user"]["username"] == "testuser" + assert "user.id" not in segment.get("attributes", {}) @pytest.mark.parametrize("max_value_length", [1024, None])