Update trace decorator to not use start_child (#4440)

Author: sl0thentr0py

sentry_sdk/tracing_utils.py

@@ -729,9 +729,10 @@ async def func_with_tracing(*args, **kwargs):
                 )
                 return await func(*args, **kwargs)
 
-            with span.start_child(
+            with sentry_sdk.start_span(
                 op=OP.FUNCTION,
                 name=qualname_from_function(func),
+                only_if_parent=True,
             ):
                 return await func(*args, **kwargs)
 
@@ -757,9 +758,10 @@ def func_with_tracing(*args, **kwargs):
                 )
                 return func(*args, **kwargs)
 
-            with span.start_child(
+            with sentry_sdk.start_span(
                 op=OP.FUNCTION,
                 name=qualname_from_function(func),
+                only_if_parent=True,
             ):
                 return func(*args, **kwargs)
 

tests/conftest.py

@@ -3,9 +3,7 @@
 import socket
 import warnings
 from threading import Thread
-from contextlib import contextmanager
 from http.server import BaseHTTPRequestHandler, HTTPServer
-from unittest import mock
 
 import pytest
 import jsonschema
@@ -35,12 +33,6 @@
 
 from tests import _warning_recorder, _warning_recorder_mgr
 
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from typing import Optional
-    from collections.abc import Iterator
-
 
 SENTRY_EVENT_SCHEMA = "./checkouts/data-schemas/relay/event.schema.json"
 
@@ -637,23 +629,6 @@ def werkzeug_set_cookie(client, servername, key, value):
         client.set_cookie(key, value)
 
 
-@contextmanager
-def patch_start_tracing_child(fake_transaction_is_none=False):
-    # type: (bool) -> Iterator[Optional[mock.MagicMock]]
-    if not fake_transaction_is_none:
-        fake_transaction = mock.MagicMock()
-        fake_start_child = mock.MagicMock()
-        fake_transaction.start_child = fake_start_child
-    else:
-        fake_transaction = None
-        fake_start_child = None
-
-    with mock.patch(
-        "sentry_sdk.tracing_utils.get_current_span", return_value=fake_transaction
-    ):
-        yield fake_start_child
-
-
 class ApproxDict(dict):
     def __eq__(self, other):
         # For an ApproxDict to equal another dict, the other dict just needs to contain

tests/test_basics.py

@@ -748,32 +748,36 @@ def _hello_world(word):
 
 
 def test_functions_to_trace(sentry_init, capture_events):
-    functions_to_trace = [
-        {"qualified_name": "tests.test_basics._hello_world"},
-        {"qualified_name": "time.sleep"},
-    ]
-
-    sentry_init(
-        traces_sample_rate=1.0,
-        functions_to_trace=functions_to_trace,
-    )
+    original_sleep = time.sleep
+    try:
+        functions_to_trace = [
+            {"qualified_name": "tests.test_basics._hello_world"},
+            {"qualified_name": "time.sleep"},
+        ]
+
+        sentry_init(
+            traces_sample_rate=1.0,
+            functions_to_trace=functions_to_trace,
+        )
 
-    events = capture_events()
+        events = capture_events()
 
-    with start_span(name="something"):
-        time.sleep(0)
+        with start_span(name="something"):
+            time.sleep(0)
 
-        for word in ["World", "You"]:
-            _hello_world(word)
+            for word in ["World", "You"]:
+                _hello_world(word)
 
-    assert len(events) == 1
+        assert len(events) == 1
 
-    (event,) = events
+        (event,) = events
 
-    assert len(event["spans"]) == 3
-    assert event["spans"][0]["description"] == "time.sleep"
-    assert event["spans"][1]["description"] == "tests.test_basics._hello_world"
-    assert event["spans"][2]["description"] == "tests.test_basics._hello_world"
+        assert len(event["spans"]) == 3
+        assert event["spans"][0]["description"] == "time.sleep"
+        assert event["spans"][1]["description"] == "tests.test_basics._hello_world"
+        assert event["spans"][2]["description"] == "tests.test_basics._hello_world"
+    finally:
+        time.sleep = original_sleep
 
 
 class WorldGreeter:

tests/tracing/test_decorator.py

@@ -3,10 +3,9 @@
 
 import pytest
 
+import sentry_sdk
 from sentry_sdk.tracing import trace
-from sentry_sdk.tracing_utils import start_child_span_decorator
 from sentry_sdk.utils import logger
-from tests.conftest import patch_start_tracing_child
 
 
 def my_example_function():
@@ -17,68 +16,80 @@ async def my_async_example_function():
     return "return_of_async_function"
 
 
-@pytest.mark.forked
-def test_trace_decorator():
-    with patch_start_tracing_child() as fake_start_child:
+def test_trace_decorator(sentry_init, capture_events):
+    sentry_init(traces_sample_rate=1.0)
+    events = capture_events()
+
+    with sentry_sdk.start_span(name="test"):
         result = my_example_function()
-        fake_start_child.assert_not_called()
         assert result == "return_of_sync_function"
 
-        result2 = start_child_span_decorator(my_example_function)()
-        fake_start_child.assert_called_once_with(
-            op="function", name="test_decorator.my_example_function"
-        )
+        result2 = trace(my_example_function)()
         assert result2 == "return_of_sync_function"
 
+    (event,) = events
+    (span,) = event["spans"]
+    assert span["op"] == "function"
+    assert span["description"] == "test_decorator.my_example_function"
+
+
+def test_trace_decorator_no_trx(sentry_init, capture_events):
+    sentry_init(traces_sample_rate=1.0)
+    events = capture_events()
+
+    with mock.patch.object(logger, "debug", mock.Mock()) as fake_debug:
+        result = my_example_function()
+        assert result == "return_of_sync_function"
+        fake_debug.assert_not_called()
 
-@pytest.mark.forked
-def test_trace_decorator_no_trx():
-    with patch_start_tracing_child(fake_transaction_is_none=True):
-        with mock.patch.object(logger, "debug", mock.Mock()) as fake_debug:
-            result = my_example_function()
-            fake_debug.assert_not_called()
-            assert result == "return_of_sync_function"
+        result2 = trace(my_example_function)()
+        assert result2 == "return_of_sync_function"
+        fake_debug.assert_called_once_with(
+            "Cannot create a child span for %s. "
+            "Please start a Sentry transaction before calling this function.",
+            "test_decorator.my_example_function",
+        )
 
-            result2 = start_child_span_decorator(my_example_function)()
-            fake_debug.assert_called_once_with(
-                "Cannot create a child span for %s. "
-                "Please start a Sentry transaction before calling this function.",
-                "test_decorator.my_example_function",
-            )
-            assert result2 == "return_of_sync_function"
+    assert len(events) == 0
 
 
-@pytest.mark.forked
 @pytest.mark.asyncio
-async def test_trace_decorator_async():
-    with patch_start_tracing_child() as fake_start_child:
+async def test_trace_decorator_async(sentry_init, capture_events):
+    sentry_init(traces_sample_rate=1.0)
+    events = capture_events()
+
+    with sentry_sdk.start_span(name="test"):
         result = await my_async_example_function()
-        fake_start_child.assert_not_called()
         assert result == "return_of_async_function"
 
-        result2 = await start_child_span_decorator(my_async_example_function)()
-        fake_start_child.assert_called_once_with(
-            op="function",
-            name="test_decorator.my_async_example_function",
-        )
+        result2 = await trace(my_async_example_function)()
         assert result2 == "return_of_async_function"
 
+    (event,) = events
+    (span,) = event["spans"]
+    assert span["op"] == "function"
+    assert span["description"] == "test_decorator.my_async_example_function"
+
 
 @pytest.mark.asyncio
-async def test_trace_decorator_async_no_trx():
-    with patch_start_tracing_child(fake_transaction_is_none=True):
-        with mock.patch.object(logger, "debug", mock.Mock()) as fake_debug:
-            result = await my_async_example_function()
-            fake_debug.assert_not_called()
-            assert result == "return_of_async_function"
-
-            result2 = await start_child_span_decorator(my_async_example_function)()
-            fake_debug.assert_called_once_with(
-                "Cannot create a child span for %s. "
-                "Please start a Sentry transaction before calling this function.",
-                "test_decorator.my_async_example_function",
-            )
-            assert result2 == "return_of_async_function"
+async def test_trace_decorator_async_no_trx(sentry_init, capture_events):
+    sentry_init(traces_sample_rate=1.0)
+    events = capture_events()
+
+    with mock.patch.object(logger, "debug", mock.Mock()) as fake_debug:
+        result = await my_async_example_function()
+        fake_debug.assert_not_called()
+        assert result == "return_of_async_function"
+
+        result2 = await trace(my_async_example_function)()
+        fake_debug.assert_called_once_with(
+            "Cannot create a child span for %s. "
+            "Please start a Sentry transaction before calling this function.",
+            "test_decorator.my_async_example_function",
+        )
+        assert result2 == "return_of_async_function"
+
+    assert len(events) == 0
 
 
 def test_functions_to_trace_signature_unchanged_sync(sentry_init):