sentry-sdk 3.0.0a1__py2.py3-none-any.whl → 3.0.0a2__py2.py3-none-any.whl

sentry_sdk/integrations/loguru.py

@@ -1,22 +1,27 @@
 import enum
 
+import sentry_sdk
 from sentry_sdk.integrations import Integration, DidNotEnable
 from sentry_sdk.integrations.logging import (
     BreadcrumbHandler,
     EventHandler,
     _BaseHandler,
 )
+from sentry_sdk.logger import _log_level_to_otel
 
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from logging import LogRecord
-    from typing import Optional, Tuple, Any
+    from typing import Any, Optional
 
 try:
     import loguru
     from loguru import logger
     from loguru._defaults import LOGURU_FORMAT as DEFAULT_FORMAT
+
+    if TYPE_CHECKING:
+        from loguru import Message
 except ImportError:
     raise DidNotEnable("LOGURU is not installed")
 
@@ -31,6 +36,10 @@ class LoggingLevels(enum.IntEnum):
     CRITICAL = 50
 
 
+DEFAULT_LEVEL = LoggingLevels.INFO.value
+DEFAULT_EVENT_LEVEL = LoggingLevels.ERROR.value
+
+
 SENTRY_LEVEL_FROM_LOGURU_LEVEL = {
     "TRACE": "DEBUG",
     "DEBUG": "DEBUG",
@@ -41,59 +50,76 @@ SENTRY_LEVEL_FROM_LOGURU_LEVEL = {
     "CRITICAL": "CRITICAL",
 }
 
-DEFAULT_LEVEL = LoggingLevels.INFO.value
-DEFAULT_EVENT_LEVEL = LoggingLevels.ERROR.value
-# We need to save the handlers to be able to remove them later
-# in tests (they call `LoguruIntegration.__init__` multiple times,
-# and we can't use `setup_once` because it's called before
-# than we get configuration).
-_ADDED_HANDLERS = (None, None)  # type: Tuple[Optional[int], Optional[int]]
+# Map Loguru level numbers to corresponding OTel level numbers
+SEVERITY_TO_OTEL_SEVERITY = {
+    LoggingLevels.CRITICAL: 21,  # fatal
+    LoggingLevels.ERROR: 17,  # error
+    LoggingLevels.WARNING: 13,  # warn
+    LoggingLevels.SUCCESS: 11,  # info
+    LoggingLevels.INFO: 9,  # info
+    LoggingLevels.DEBUG: 5,  # debug
+    LoggingLevels.TRACE: 1,  # trace
+}
 
 
 class LoguruIntegration(Integration):
     identifier = "loguru"
 
+    level = DEFAULT_LEVEL  # type: Optional[int]
+    event_level = DEFAULT_EVENT_LEVEL  # type: Optional[int]
+    breadcrumb_format = DEFAULT_FORMAT
+    event_format = DEFAULT_FORMAT
+    sentry_logs_level = DEFAULT_LEVEL  # type: Optional[int]
+
     def __init__(
         self,
         level=DEFAULT_LEVEL,
         event_level=DEFAULT_EVENT_LEVEL,
         breadcrumb_format=DEFAULT_FORMAT,
         event_format=DEFAULT_FORMAT,
+        sentry_logs_level=DEFAULT_LEVEL,
     ):
-        # type: (Optional[int], Optional[int], str | loguru.FormatFunction, str | loguru.FormatFunction) -> None
-        global _ADDED_HANDLERS
-        breadcrumb_handler, event_handler = _ADDED_HANDLERS
-
-        if breadcrumb_handler is not None:
-            logger.remove(breadcrumb_handler)
-            breadcrumb_handler = None
-        if event_handler is not None:
-            logger.remove(event_handler)
-            event_handler = None
-
-        if level is not None:
-            breadcrumb_handler = logger.add(
-                LoguruBreadcrumbHandler(level=level),
-                level=level,
-                format=breadcrumb_format,
-            )
-
-        if event_level is not None:
-            event_handler = logger.add(
-                LoguruEventHandler(level=event_level),
-                level=event_level,
-                format=event_format,
-            )
-
-        _ADDED_HANDLERS = (breadcrumb_handler, event_handler)
+        # type: (Optional[int], Optional[int], str | loguru.FormatFunction, str | loguru.FormatFunction, Optional[int]) -> None
+        LoguruIntegration.level = level
+        LoguruIntegration.event_level = event_level
+        LoguruIntegration.breadcrumb_format = breadcrumb_format
+        LoguruIntegration.event_format = event_format
+        LoguruIntegration.sentry_logs_level = sentry_logs_level
 
     @staticmethod
     def setup_once():
         # type: () -> None
-        pass  # we do everything in __init__
+        if LoguruIntegration.level is not None:
+            logger.add(
+                LoguruBreadcrumbHandler(level=LoguruIntegration.level),
+                level=LoguruIntegration.level,
+                format=LoguruIntegration.breadcrumb_format,
+            )
+
+        if LoguruIntegration.event_level is not None:
+            logger.add(
+                LoguruEventHandler(level=LoguruIntegration.event_level),
+                level=LoguruIntegration.event_level,
+                format=LoguruIntegration.event_format,
+            )
+
+        if LoguruIntegration.sentry_logs_level is not None:
+            logger.add(
+                loguru_sentry_logs_handler,
+                level=LoguruIntegration.sentry_logs_level,
+            )
 
 
 class _LoguruBaseHandler(_BaseHandler):
+    def __init__(self, *args, **kwargs):
+        # type: (*Any, **Any) -> None
+        if kwargs.get("level"):
+            kwargs["level"] = SENTRY_LEVEL_FROM_LOGURU_LEVEL.get(
+                kwargs.get("level", ""), DEFAULT_LEVEL
+            )
+
+        super().__init__(*args, **kwargs)
+
     def _logging_to_event_level(self, record):
         # type: (LogRecord) -> str
         try:
@@ -107,24 +133,72 @@ class _LoguruBaseHandler(_BaseHandler):
 class LoguruEventHandler(_LoguruBaseHandler, EventHandler):
     """Modified version of :class:`sentry_sdk.integrations.logging.EventHandler` to use loguru's level names."""
 
-    def __init__(self, *args, **kwargs):
-        # type: (*Any, **Any) -> None
-        if kwargs.get("level"):
-            kwargs["level"] = SENTRY_LEVEL_FROM_LOGURU_LEVEL.get(
-                kwargs.get("level", ""), DEFAULT_LEVEL
-            )
-
-        super().__init__(*args, **kwargs)
+    pass
 
 
 class LoguruBreadcrumbHandler(_LoguruBaseHandler, BreadcrumbHandler):
     """Modified version of :class:`sentry_sdk.integrations.logging.BreadcrumbHandler` to use loguru's level names."""
 
-    def __init__(self, *args, **kwargs):
-        # type: (*Any, **Any) -> None
-        if kwargs.get("level"):
-            kwargs["level"] = SENTRY_LEVEL_FROM_LOGURU_LEVEL.get(
-                kwargs.get("level", ""), DEFAULT_LEVEL
-            )
+    pass
 
-        super().__init__(*args, **kwargs)
+
+def loguru_sentry_logs_handler(message):
+    # type: (Message) -> None
+    # This is intentionally a callable sink instead of a standard logging handler
+    # since otherwise we wouldn't get direct access to message.record
+    client = sentry_sdk.get_client()
+
+    if not client.is_active():
+        return
+
+    if not client.options["_experiments"].get("enable_logs", False):
+        return
+
+    record = message.record
+
+    if (
+        LoguruIntegration.sentry_logs_level is None
+        or record["level"].no < LoguruIntegration.sentry_logs_level
+    ):
+        return
+
+    otel_severity_number, otel_severity_text = _log_level_to_otel(
+        record["level"].no, SEVERITY_TO_OTEL_SEVERITY
+    )
+
+    attrs = {"sentry.origin": "auto.logger.loguru"}  # type: dict[str, Any]
+
+    project_root = client.options["project_root"]
+    if record.get("file"):
+        if project_root is not None and record["file"].path.startswith(project_root):
+            attrs["code.file.path"] = record["file"].path[len(project_root) + 1 :]
+        else:
+            attrs["code.file.path"] = record["file"].path
+
+    if record.get("line") is not None:
+        attrs["code.line.number"] = record["line"]
+
+    if record.get("function"):
+        attrs["code.function.name"] = record["function"]
+
+    if record.get("thread"):
+        attrs["thread.name"] = record["thread"].name
+        attrs["thread.id"] = record["thread"].id
+
+    if record.get("process"):
+        attrs["process.pid"] = record["process"].id
+        attrs["process.executable.name"] = record["process"].name
+
+    if record.get("name"):
+        attrs["logger.name"] = record["name"]
+
+    client._capture_experimental_log(
+        {
+            "severity_text": otel_severity_text,
+            "severity_number": otel_severity_number,
+            "body": record["message"],
+            "attributes": attrs,
+            "time_unix_nano": int(record["time"].timestamp() * 1e9),
+            "trace_id": None,
+        }
+    )

sentry_sdk/integrations/openai.py

@@ -156,7 +156,7 @@ def _new_chat_completion_common(f, *args, **kwargs):
             if should_send_default_pii() and integration.include_prompts:
                 set_data_normalized(
                     span,
-                    "ai.responses",
+                    SPANDATA.AI_RESPONSES,
                     list(map(lambda x: x.message, res.choices)),
                 )
             _calculate_chat_completion_usage(
@@ -331,15 +331,15 @@ def _new_embeddings_create_common(f, *args, **kwargs):
             should_send_default_pii() and integration.include_prompts
         ):
             if isinstance(kwargs["input"], str):
-                set_data_normalized(span, "ai.input_messages", [kwargs["input"]])
+                set_data_normalized(span, SPANDATA.AI_INPUT_MESSAGES, [kwargs["input"]])
             elif (
                 isinstance(kwargs["input"], list)
                 and len(kwargs["input"]) > 0
                 and isinstance(kwargs["input"][0], str)
             ):
-                set_data_normalized(span, "ai.input_messages", kwargs["input"])
+                set_data_normalized(span, SPANDATA.AI_INPUT_MESSAGES, kwargs["input"])
         if "model" in kwargs:
-            set_data_normalized(span, "ai.model_id", kwargs["model"])
+            set_data_normalized(span, SPANDATA.AI_MODEL_ID, kwargs["model"])
 
         response = yield f, args, kwargs
 

sentry_sdk/integrations/redis/_async_common.py

@@ -44,13 +44,20 @@ def patch_redis_async_pipeline(
         ) as span:
             with capture_internal_exceptions():
                 span_data = get_db_data_fn(self)
+
+                try:
+                    command_seq = self._execution_strategy._command_queue
+                except AttributeError:
+                    if is_cluster:
+                        command_seq = self._command_stack
+                    else:
+                        command_seq = self.command_stack
+
                 pipeline_data = _get_pipeline_data(
                     is_cluster=is_cluster,
                     get_command_args_fn=get_command_args_fn,
                     is_transaction=False if is_cluster else self.is_transaction,
-                    command_stack=(
-                        self._command_stack if is_cluster else self.command_stack
-                    ),
+                    command_seq=command_seq,
                 )
                 _update_span(span, span_data, pipeline_data)
                 _create_breadcrumb("redis.pipeline.execute", span_data, pipeline_data)

sentry_sdk/integrations/redis/_sync_common.py

@@ -44,12 +44,17 @@ def patch_redis_pipeline(
             only_if_parent=True,
         ) as span:
             with capture_internal_exceptions():
+                try:
+                    command_seq = self._execution_strategy.command_queue
+                except AttributeError:
+                    command_seq = self.command_stack
+
                 span_data = get_db_data_fn(self)
                 pipeline_data = _get_pipeline_data(
                     is_cluster=is_cluster,
                     get_command_args_fn=get_command_args_fn,
                     is_transaction=False if is_cluster else self.transaction,
-                    command_stack=self.command_stack,
+                    command_seq=command_seq,
                 )
                 _update_span(span, span_data, pipeline_data)
                 _create_breadcrumb("redis.pipeline.execute", span_data, pipeline_data)

sentry_sdk/integrations/redis/redis_cluster.py

@@ -37,11 +37,17 @@ def _get_async_cluster_db_data(async_redis_cluster_instance):
 def _get_async_cluster_pipeline_db_data(async_redis_cluster_pipeline_instance):
     # type: (AsyncClusterPipeline[Any]) -> dict[str, Any]
     with capture_internal_exceptions():
-        return _get_async_cluster_db_data(
-            # the AsyncClusterPipeline has always had a `_client` attr but it is private so potentially problematic and mypy
-            # does not recognize it - see https://github.com/redis/redis-py/blame/v5.0.0/redis/asyncio/cluster.py#L1386
-            async_redis_cluster_pipeline_instance._client,  # type: ignore[attr-defined]
-        )
+        client = getattr(async_redis_cluster_pipeline_instance, "cluster_client", None)
+        if client is None:
+            # In older redis-py versions, the AsyncClusterPipeline had a `_client`
+            # attr but it is private so potentially problematic and mypy does not
+            # recognize it - see
+            # https://github.com/redis/redis-py/blame/v5.0.0/redis/asyncio/cluster.py#L1386
+            client = (
+                async_redis_cluster_pipeline_instance._client  # type: ignore[attr-defined]
+            )
+
+        return _get_async_cluster_db_data(client)
 
 
 def _get_cluster_db_data(redis_cluster_instance):

sentry_sdk/integrations/redis/utils.py

@@ -147,7 +147,7 @@ def _parse_rediscluster_command(command):
     return command.args
 
 
-def _get_pipeline_data(is_cluster, get_command_args_fn, is_transaction, command_stack):
+def _get_pipeline_data(is_cluster, get_command_args_fn, is_transaction, command_seq):
     # type: (bool, Any, bool, Sequence[Any]) -> dict[str, Any]
     data = {
         "redis.is_cluster": is_cluster,
@@ -155,14 +155,14 @@ def _get_pipeline_data(is_cluster, get_command_args_fn, is_transaction, command_
     }  # type: dict[str, Any]
 
     commands = []
-    for i, arg in enumerate(command_stack):
+    for i, arg in enumerate(command_seq):
         if i >= _MAX_NUM_COMMANDS:
             break
 
         command = get_command_args_fn(arg)
         commands.append(_get_safe_command(command[0], command[1:]))
 
-    data["redis.commands.count"] = len(command_stack)
+    data["redis.commands.count"] = len(command_seq)
     data["redis.commands.first_ten"] = commands
 
     return data

sentry_sdk/integrations/tornado.py

@@ -85,7 +85,7 @@ class TornadoIntegration(Integration):
         else:
 
             @coroutine  # type: ignore
-            def sentry_execute_request_handler(self, *args, **kwargs):  # type: ignore
+            def sentry_execute_request_handler(self, *args, **kwargs):
                 # type: (RequestHandler, *Any, **Any) -> Any
                 with _handle_request_impl(self):
                     result = yield from old_execute(self, *args, **kwargs)

sentry_sdk/logger.py

@@ -3,14 +3,24 @@ import functools
 import time
 from typing import Any
 
-from sentry_sdk import get_client, get_current_scope
+from sentry_sdk import get_client
 from sentry_sdk.utils import safe_repr
 
+OTEL_RANGES = [
+    # ((severity level range), severity text)
+    # https://opentelemetry.io/docs/specs/otel/logs/data-model
+    ((1, 4), "trace"),
+    ((5, 8), "debug"),
+    ((9, 12), "info"),
+    ((13, 16), "warn"),
+    ((17, 20), "error"),
+    ((21, 24), "fatal"),
+]
+
 
 def _capture_log(severity_text, severity_number, template, **kwargs):
     # type: (str, int, str, **Any) -> None
     client = get_client()
-    scope = get_current_scope()
 
     attrs = {
         "sentry.message.template": template,
@@ -18,7 +28,7 @@ def _capture_log(severity_text, severity_number, template, **kwargs):
     if "attributes" in kwargs:
         attrs.update(kwargs.pop("attributes"))
     for k, v in kwargs.items():
-        attrs[f"sentry.message.parameters.{k}"] = v
+        attrs[f"sentry.message.parameter.{k}"] = v
 
     attrs = {
         k: (
@@ -36,7 +46,6 @@ def _capture_log(severity_text, severity_number, template, **kwargs):
 
     # noinspection PyProtectedMember
     client._capture_experimental_log(
-        scope,
         {
             "severity_text": severity_text,
             "severity_number": severity_number,
@@ -51,6 +60,24 @@ def _capture_log(severity_text, severity_number, template, **kwargs):
 trace = functools.partial(_capture_log, "trace", 1)
 debug = functools.partial(_capture_log, "debug", 5)
 info = functools.partial(_capture_log, "info", 9)
-warning = functools.partial(_capture_log, "warning", 13)
+warning = functools.partial(_capture_log, "warn", 13)
 error = functools.partial(_capture_log, "error", 17)
 fatal = functools.partial(_capture_log, "fatal", 21)
+
+
+def _otel_severity_text(otel_severity_number):
+    # type: (int) -> str
+    for (lower, upper), severity in OTEL_RANGES:
+        if lower <= otel_severity_number <= upper:
+            return severity
+
+    return "default"
+
+
+def _log_level_to_otel(level, mapping):
+    # type: (int, dict[Any, int]) -> tuple[int, str]
+    for py_level, otel_severity_number in sorted(mapping.items(), reverse=True):
+        if level >= py_level:
+            return otel_severity_number, _otel_severity_text(otel_severity_number)
+
+    return 0, "default"

sentry_sdk/opentelemetry/contextvars_context.py

@@ -1,10 +1,12 @@
 from typing import cast, TYPE_CHECKING
 
-from opentelemetry.trace import set_span_in_context
+from opentelemetry.trace import get_current_span, set_span_in_context
+from opentelemetry.trace.span import INVALID_SPAN
 from opentelemetry.context import Context, get_value, set_value
 from opentelemetry.context.contextvars_context import ContextVarsRuntimeContext
 
 import sentry_sdk
+from sentry_sdk.tracing import Span
 from sentry_sdk.opentelemetry.consts import (
     SENTRY_SCOPES_KEY,
     SENTRY_FORK_ISOLATION_SCOPE_KEY,
@@ -60,6 +62,12 @@ class SentryContextVarsRuntimeContext(ContextVarsRuntimeContext):
         else:
             new_scope = current_scope.fork()
 
+            # carry forward a wrapped span reference since the otel context is always the
+            # source of truth for the active span
+            current_span = get_current_span(context)
+            if current_span != INVALID_SPAN:
+                new_scope._span = Span(otel_span=get_current_span(context))
+
         if should_use_isolation_scope:
             new_isolation_scope = should_use_isolation_scope
         elif should_fork_isolation_scope:

sentry_sdk/opentelemetry/span_processor.py

@@ -29,6 +29,7 @@ from sentry_sdk.opentelemetry.utils import (
     get_profile_context,
     get_sentry_meta,
     set_sentry_meta,
+    delete_sentry_meta,
 )
 from sentry_sdk.profiler.continuous_profiler import (
     try_autostart_continuous_profiler,
@@ -173,6 +174,7 @@ class SentrySpanProcessor(SpanProcessor):
         # TODO-neel-potel sort and cutoff max spans
 
         sentry_sdk.capture_event(transaction_event)
+        self._cleanup_references([span] + collected_spans)
 
     def _append_child_span(self, span):
         # type: (ReadableSpan) -> None
@@ -253,7 +255,6 @@ class SentrySpanProcessor(SpanProcessor):
             profile.__exit__(None, None, None)
             if profile.valid():
                 event["profile"] = profile
-                set_sentry_meta(span, "profile", None)
 
         return event
 
@@ -314,6 +315,11 @@ class SentrySpanProcessor(SpanProcessor):
 
         return common_json
 
+    def _cleanup_references(self, spans):
+        # type: (List[ReadableSpan]) -> None
+        for span in spans:
+            delete_sentry_meta(span)
+
     def _log_debug_info(self):
         # type: () -> None
         import pprint

sentry_sdk/opentelemetry/tracing.py

@@ -7,6 +7,7 @@ from sentry_sdk.opentelemetry import (
     SentrySampler,
     SentrySpanProcessor,
 )
+from sentry_sdk.utils import logger
 
 
 def patch_readable_span():
@@ -28,8 +29,31 @@ def patch_readable_span():
 
 def setup_sentry_tracing():
     # type: () -> None
-    provider = TracerProvider(sampler=SentrySampler())
-    provider.add_span_processor(SentrySpanProcessor())
-    trace.set_tracer_provider(provider)
+    # TracerProvider can only be set once. If we're the first ones setting it,
+    # there's no issue. If it already exists, we need to patch it.
+    from opentelemetry.trace import _TRACER_PROVIDER
+
+    if _TRACER_PROVIDER is not None:
+        logger.debug("[Tracing] Detected an existing TracerProvider, patching")
+        tracer_provider = _TRACER_PROVIDER
+        tracer_provider.sampler = SentrySampler()  # type: ignore[attr-defined]
+
+    else:
+        logger.debug("[Tracing] No TracerProvider set, creating a new one")
+        tracer_provider = TracerProvider(sampler=SentrySampler())
+        trace.set_tracer_provider(tracer_provider)
+
+    try:
+        existing_span_processors = (
+            tracer_provider._active_span_processor._span_processors  # type: ignore[attr-defined]
+        )
+    except Exception:
+        existing_span_processors = []
+
+    for span_processor in existing_span_processors:
+        if isinstance(span_processor, SentrySpanProcessor):
+            break
+    else:
+        tracer_provider.add_span_processor(SentrySpanProcessor())  # type: ignore[attr-defined]
 
     set_global_textmap(SentryPropagator())

sentry_sdk/opentelemetry/utils.py

@@ -464,6 +464,14 @@ def set_sentry_meta(span, key, value):
     span._sentry_meta = sentry_meta  # type: ignore[union-attr]
 
 
+def delete_sentry_meta(span):
+    # type: (Union[AbstractSpan, ReadableSpan]) -> None
+    try:
+        del span._sentry_meta  # type: ignore[union-attr]
+    except AttributeError:
+        pass
+
+
 def get_profile_context(span):
     # type: (ReadableSpan) -> Optional[dict[str, str]]
     if not span.attributes:

sentry_sdk/scope.py

@@ -172,8 +172,8 @@ class Scope:
         "_flags",
     )
 
-    def __init__(self, ty=None, client=None):
-        # type: (Optional[ScopeType], Optional[sentry_sdk.Client]) -> None
+    def __init__(self, ty=None):
+        # type: (Optional[ScopeType]) -> None
         self._type = ty
 
         self._event_processors = []  # type: List[EventProcessor]
@@ -185,9 +185,6 @@ class Scope:
 
         self.client = NonRecordingClient()  # type: sentry_sdk.client.BaseClient
 
-        if client is not None:
-            self.set_client(client)
-
         self.clear()
 
         incoming_trace_information = self._load_trace_data_from_env()
@@ -732,12 +729,6 @@ class Scope:
         """Get current tracing span."""
         return self._span
 
-    @span.setter
-    def span(self, span):
-        # type: (Optional[Span]) -> None
-        """Set current tracing span."""
-        self._span = span
-
     @property
     def profile(self):
         # type: () -> Optional[Profile]

sentry_sdk/tracing.py

@@ -15,7 +15,6 @@ from opentelemetry.trace.status import Status, StatusCode
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.version import __version__ as otel_version
 
-import sentry_sdk
 from sentry_sdk.consts import (
     DEFAULT_SPAN_NAME,
     DEFAULT_SPAN_ORIGIN,
@@ -189,7 +188,7 @@ class Span:
         If otel_span is passed explicitly, just acts as a proxy.
 
         If span is passed explicitly, use it. The only purpose of this param
-        if backwards compatibility with start_transaction(transaction=...).
+        is backwards compatibility with start_transaction(transaction=...).
 
         If only_if_parent is True, just return an INVALID_SPAN
         and avoid instrumentation if there's no active parent span.
@@ -271,19 +270,21 @@ class Span:
             )
         )
 
-    def __enter__(self):
-        # type: () -> Span
-        # XXX use_span? https://github.com/open-telemetry/opentelemetry-python/blob/3836da8543ce9751051e38a110c0468724042e62/opentelemetry-api/src/opentelemetry/trace/__init__.py#L547
-        #
-        # create a Context object with parent set as current span
+    def activate(self):
+        # type: () -> None
         ctx = otel_trace.set_span_in_context(self._otel_span)
         # set as the implicit current context
         self._ctx_token = context.attach(ctx)
 
-        # get the new scope that was forked on context.attach
-        self.scope = sentry_sdk.get_current_scope()
-        self.scope.span = self
+    def deactivate(self):
+        # type: () -> None
+        if self._ctx_token:
+            context.detach(self._ctx_token)
+            del self._ctx_token
 
+    def __enter__(self):
+        # type: () -> Span
+        self.activate()
         return self
 
     def __exit__(self, ty, value, tb):
@@ -299,8 +300,7 @@ class Span:
                 self.set_status(SPANSTATUS.OK)
 
         self.finish()
-        context.detach(self._ctx_token)
-        del self._ctx_token
+        self.deactivate()
 
     @property
     def description(self):

sentry_sdk/tracing_utils.py

@@ -729,9 +729,10 @@ def start_child_span_decorator(func):
                 )
                 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 start_child_span_decorator(func):
                 )
                 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)