Merge branch 'master' into py-2305-add-query-source-to-methods-that-were-missing-it

Author: ericapisani

scripts/populate_tox/package_dependencies.jsonl

@@ -655,6 +655,81 @@ async def test_query_source_enabled(
     assert SPANDATA.CODE_FUNCTION in data
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("span_streaming", [True, False])
+async def test_query_source(sentry_init, capture_events, capture_items, span_streaming):
+    sentry_init(
+        integrations=[AsyncPGIntegration()],
+        traces_sample_rate=1.0,
+        enable_db_query_source=True,
+        db_query_source_threshold_ms=0,
+        _experiments={
+            "trace_lifecycle": "stream" if span_streaming else "static",
+        },
+    )
+
+    if span_streaming:
+        items = capture_items("span")
+        with sentry_sdk.traces.start_span(name="test_transaction"):
+            conn: Connection = await connect(PG_CONNECTION_URI)
+
+            await conn.execute(
+                "INSERT INTO users(name, password, dob) VALUES ('Alice', 'secret', '1990-12-25')",
+            )
+
+            await conn.close()
+        sentry_sdk.flush()
+
+        spans = [item.payload for item in items]
+
+        assert len(spans) == 3
+
+        connect_span = spans[0]
+        insert_span = spans[1]
+        segment = spans[2]
+
+        assert segment["name"] == "test_transaction"
+        assert insert_span["name"].startswith("INSERT INTO")
+        assert connect_span["name"] == "connect"
+        data = insert_span.get("attributes", {})
+    else:
+        events = capture_events()
+
+        with start_transaction(name="test_transaction", sampled=True):
+            conn: Connection = await connect(PG_CONNECTION_URI)
+
+            await conn.execute(
+                "INSERT INTO users(name, password, dob) VALUES ('Alice', 'secret', '1990-12-25')",
+            )
+
+            await conn.close()
+
+        (event,) = events
+        span = event["spans"][-1]
+        assert span["description"].startswith("INSERT INTO")
+        data = span.get("data", {})
+
+    lineno_key = "code.line.number" if span_streaming else SPANDATA.CODE_LINENO
+    filepath_key = "code.file.path" if span_streaming else SPANDATA.CODE_FILEPATH
+
+    assert lineno_key in data
+    assert filepath_key in data
+    assert SPANDATA.CODE_NAMESPACE in data
+    assert SPANDATA.CODE_FUNCTION in data
+
+    assert type(data.get(lineno_key)) == int
+    assert data.get(lineno_key) > 0
+    assert (
+        data.get(SPANDATA.CODE_NAMESPACE) == "tests.integrations.asyncpg.test_asyncpg"
+    )
+    assert data.get(filepath_key).endswith("tests/integrations/asyncpg/test_asyncpg.py")
+
+    is_relative_path = data.get(filepath_key)[0] != os.sep
+    assert is_relative_path
+
+    assert data.get(SPANDATA.CODE_FUNCTION) == "test_query_source"
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize("span_streaming", [True, False])
 async def test_query_source_with_module_in_search_path(

scripts/populate_tox/releases.jsonl

@@ -723,15 +723,17 @@ def test_transaction_style(
 ):
     sentry_init(
         integrations=[DjangoIntegration(transaction_style=transaction_style)],
+        traces_sample_rate=1.0,
         send_default_pii=True,
     )
     events = capture_events()
     content, status, headers = unpack_werkzeug_response(client.get(client_url))
     assert content == expected_response
 
-    (event,) = events
-    assert event["transaction"] == expected_transaction
-    assert event["transaction_info"] == {"source": expected_source}
+    (error, transaction) = events
+    assert error["transaction"] == expected_transaction
+    assert transaction["transaction"] == expected_transaction
+    assert transaction["transaction_info"] == {"source": expected_source}
 
 
 def test_request_body(sentry_init, client, capture_events):
@@ -1212,30 +1214,33 @@ def test_custom_urlconf_middleware(
     )
     events = capture_events()
 
-    content, status, _headers = unpack_werkzeug_response(client.get("/custom/ok"))
-    assert status.lower() == "200 ok"
-    assert content == b"custom ok"
-
-    event = events.pop(0)
-    assert event["transaction"] == "/custom/ok"
-    if middleware_spans:
-        assert "custom_urlconf_middleware" in render_span_tree(
-            event["spans"], event["contexts"]["trace"]
-        )
+    try:
+        content, status, _headers = unpack_werkzeug_response(client.get("/custom/ok"))
+        assert status.lower() == "200 ok"
+        assert content == b"custom ok"
+
+        event = events.pop(0)
+        assert event["transaction"] == "/custom/ok"
+        if middleware_spans:
+            assert "custom_urlconf_middleware" in render_span_tree(
+                event["spans"], event["contexts"]["trace"]
+            )
 
-    _content, status, _headers = unpack_werkzeug_response(client.get("/custom/exc"))
-    assert status.lower() == "500 internal server error"
+        _content, status, _headers = unpack_werkzeug_response(client.get("/custom/exc"))
+        assert status.lower() == "500 internal server error"
 
-    error_event, transaction_event = events
-    assert error_event["transaction"] == "/custom/exc"
-    assert error_event["exception"]["values"][-1]["mechanism"]["type"] == "django"
-    assert transaction_event["transaction"] == "/custom/exc"
-    if middleware_spans:
-        assert "custom_urlconf_middleware" in render_span_tree(
-            transaction_event["spans"], transaction_event["contexts"]["trace"]
-        )
+        error_event, transaction_event = events
+        assert error_event["transaction"] == "/custom/exc"
+        assert error_event["exception"]["values"][-1]["mechanism"]["type"] == "django"
+        assert transaction_event["transaction"] == "/custom/exc"
+        if middleware_spans:
+            assert "custom_urlconf_middleware" in render_span_tree(
+                transaction_event["spans"], transaction_event["contexts"]["trace"]
+            )
 
-    settings.MIDDLEWARE.pop(0)
+    finally:
+        settings.MIDDLEWARE.pop(0)
+        client.application.load_middleware()
 
 
 def test_get_receiver_name():

tests/integrations/asyncpg/test_asyncpg.py

@@ -243,10 +243,6 @@ def assert_single_transaction_without_profile_chunks(envelopes):
         pytest.param(get_client_options(False), id="experiment"),
     ],
 )
-@mock.patch(
-    "sentry_sdk.profiler.continuous_profiler.ProfileBuffer.should_flush",
-    lambda a, b: True,
-)  # Force flushing profile of first transaction.
 def test_continuous_profiler_auto_start_and_manual_stop(
     sentry_init,
     capture_envelopes,
@@ -270,14 +266,11 @@ def test_continuous_profiler_auto_start_and_manual_stop(
         with sentry_sdk.start_span(op="op"):
             pass
 
-    # Wait so profiles are captured before assertions.
-    sentry_sdk.profiler.continuous_profiler._scheduler.teardown()
-
-    assert_single_transaction_with_profile_chunks(envelopes, thread)
-
     for _ in range(3):
         stop_profiler_func()
 
+        assert_single_transaction_with_profile_chunks(envelopes, thread)
+
         envelopes.clear()
 
         with sentry_sdk.start_transaction(name="profiling"):
@@ -292,9 +285,11 @@ def test_continuous_profiler_auto_start_and_manual_stop(
 
         with sentry_sdk.start_transaction(name="profiling"):
             with sentry_sdk.start_span(op="op"):
-                time.sleep(0.05)
+                pass
 
-        assert_single_transaction_with_profile_chunks(envelopes, thread)
+    stop_profiler_func()
+
+    assert_single_transaction_with_profile_chunks(envelopes, thread)
 
 
 @pytest.mark.parametrize(
@@ -431,12 +426,12 @@ def test_continuous_profiler_manual_start_and_stop_unsampled(
 
     with sentry_sdk.start_transaction(name="profiling"):
         with sentry_sdk.start_span(op="op"):
-            time.sleep(0.05)
-
-    assert_single_transaction_without_profile_chunks(envelopes)
+            pass
 
     stop_profiler_func()
 
+    assert_single_transaction_without_profile_chunks(envelopes)
+
 
 @pytest.mark.parametrize(
     "mode",
@@ -629,7 +624,6 @@ def test_continuous_profiler_manual_start_and_stop_noop_when_using_trace_lifecyl
         mock_teardown.assert_not_called()
 
 
-@mock.patch("sentry_sdk.profiler.continuous_profiler.PROFILE_BUFFER_SECONDS", 0.01)
 def test_continuous_profiler_run_does_not_null_buffer(
     sentry_init,
     capture_envelopes,
@@ -662,8 +656,7 @@ def test_continuous_profiler_run_does_not_null_buffer(
     envelopes.clear()
     with sentry_sdk.start_transaction(name="profiling"):
         with sentry_sdk.start_span(op="op"):
-            time.sleep(0.1)
-    assert_single_transaction_with_profile_chunks(envelopes, thread)
+            pass
 
     # Get the scheduler and create a sentinel buffer.
     # We'll call run() directly to verify it doesn't null out self.buffer.
@@ -673,6 +666,8 @@ def test_continuous_profiler_run_does_not_null_buffer(
     # Stop the profiler so the thread exits cleanly
     stop_profiler()
 
+    assert_single_transaction_with_profile_chunks(envelopes, thread)
+
     # Now set up a fresh buffer and mark the scheduler as not running
     # (simulating the state right after ensure_running() created a new buffer
     # but the old thread hasn't done cleanup yet).