getsentry · antonpirker · Jun 15, 2023 · May 10, 2023 · May 15, 2023 · May 15, 2023
@@ -36,6 +36,9 @@
     "set_level",
     "set_measurement",
     "get_current_span",
+    "get_traceparent",
+    "get_baggage",
+    "continue_trace",
 ]
 
 # Initialize the debug support after everything is loaded

@@ -1,10 +1,13 @@
 import inspect
 
+from sentry_sdk._types import TYPE_CHECKING
 from sentry_sdk.hub import Hub
 from sentry_sdk.scope import Scope
-
-from sentry_sdk._types import TYPE_CHECKING
-from sentry_sdk.tracing import NoOpSpan
+from sentry_sdk.tracing import NoOpSpan, Transaction
+from sentry_sdk.tracing_utils import (
+    has_tracing_enabled,
+    normalize_incoming_data,
+)
 
 if TYPE_CHECKING:
     from typing import Any
@@ -24,7 +27,7 @@
         ExcInfo,
         MeasurementUnit,
     )
-    from sentry_sdk.tracing import Span, Transaction
+    from sentry_sdk.tracing import Span
 
     T = TypeVar("T")
     F = TypeVar("F", bound=Callable[..., Any])
@@ -54,6 +57,9 @@ def overload(x):
     "set_level",
     "set_measurement",
     "get_current_span",
+    "get_traceparent",
+    "get_baggage",
+    "continue_trace",
 ]
 
 
@@ -241,3 +247,54 @@ def get_current_span(hub=None):
 
     current_span = hub.scope.span
     return current_span
+
+
+def get_traceparent():
+    # type: () -> Optional[str]
+    """
+    Returns the traceparent either from the active span or from the scope.
+    """
+    hub = Hub.current
+    if hub.client is not None:
+        if has_tracing_enabled(hub.client.options) and hub.scope.span is not None:
+            return hub.scope.span.to_traceparent()
+
+    return hub.scope.get_traceparent()
+
+
+def get_baggage():
+    # type: () -> Optional[str]
+    """
+    Returns Baggage either from the active span or from the scope.
+    """
+    hub = Hub.current
+    if (
+        hub.client is not None
+        and has_tracing_enabled(hub.client.options)
+        and hub.scope.span is not None
+    ):
+        baggage = hub.scope.span.to_baggage()
+    else:
+        baggage = hub.scope.get_baggage()
+
+    if baggage is not None:
+        return baggage.serialize()
+
+    return None
+
+
+def continue_trace(environ_or_headers, op=None, name=None, source=None):
+    # type: (Dict[str, Any], Optional[str], Optional[str], Optional[str]) -> Transaction
+    """
+    Sets the propagation context from environment or headers and returns a transaction.
+    """
+    with Hub.current.configure_scope() as scope:
+        scope.generate_propagation_context(environ_or_headers)
+
+    transaction = Transaction.continue_from_headers(
+        normalize_incoming_data(environ_or_headers),
+        op=op,
+        name=name,
+        source=source,
+    )
+    return transaction
@@ -262,7 +262,7 @@ def _prepare_event(
 
         if scope is not None:
             is_transaction = event.get("type") == "transaction"
-            event_ = scope.apply_to_event(event, hint)
+            event_ = scope.apply_to_event(event, hint, self.options)
 
             # one of the event/error processors returned None
             if event_ is None:
@@ -507,11 +507,8 @@ def capture_event(
         is_checkin = event_opt.get("type") == "check_in"
         attachments = hint.get("attachments")
 
-        dynamic_sampling_context = (
-            event_opt.get("contexts", {})
-            .get("trace", {})
-            .pop("dynamic_sampling_context", {})
-        )
+        trace_context = event_opt.get("contexts", {}).get("trace") or {}
+        dynamic_sampling_context = trace_context.pop("dynamic_sampling_context", {})
 
         # If tracing is enabled all events should go to /envelope endpoint.
         # If no tracing is enabled only transactions, events with attachments, and checkins should go to the /envelope endpoint.

@@ -11,6 +11,7 @@
 from sentry_sdk.profiler import Profile
 from sentry_sdk.tracing import NoOpSpan, Span, Transaction
 from sentry_sdk.session import Session
+from sentry_sdk.tracing_utils import has_tracing_enabled
 from sentry_sdk.utils import (
     exc_info_from_error,
     event_from_exception,
@@ -322,14 +323,8 @@ def bind_client(
         top = self._stack[-1]
         self._stack[-1] = (new, top[1])
 
-    def capture_event(
-        self,
-        event,  # type: Event
-        hint=None,  # type: Optional[Hint]
-        scope=None,  # type: Optional[Any]
-        **scope_args  # type: Any
-    ):
-        # type: (...) -> Optional[str]
+    def capture_event(self, event, hint=None, scope=None, **scope_args):
+        # type: (Event, Optional[Hint], Optional[Scope], Any) -> Optional[str]
         """Captures an event. Alias of :py:meth:`sentry_sdk.Client.capture_event`."""
         client, top_scope = self._stack[-1]
         scope = _update_scope(top_scope, scope, scope_args)
@@ -341,14 +336,8 @@ def capture_event(
             return rv
         return None
 
-    def capture_message(
-        self,
-        message,  # type: str
-        level=None,  # type: Optional[str]
-        scope=None,  # type: Optional[Any]
-        **scope_args  # type: Any
-    ):
-        # type: (...) -> Optional[str]
+    def capture_message(self, message, level=None, scope=None, **scope_args):
+        # type: (str, Optional[str], Optional[Scope], Any) -> Optional[str]
         """Captures a message.  The message is just a string.  If no level
         is provided the default level is `info`.
 
@@ -362,13 +351,8 @@ def capture_message(
             {"message": message, "level": level}, scope=scope, **scope_args
         )
 
-    def capture_exception(
-        self,
-        error=None,  # type: Optional[Union[BaseException, ExcInfo]]
-        scope=None,  # type: Optional[Any]
-        **scope_args  # type: Any
-    ):
-        # type: (...) -> Optional[str]
+    def capture_exception(self, error=None, scope=None, **scope_args):
+        # type: (Optional[Union[BaseException, ExcInfo]], Optional[Scope], Any) -> Optional[str]
         """Captures an exception.
 
         :param error: An exception to catch. If `None`, `sys.exc_info()` will be used.
@@ -403,13 +387,8 @@ def _capture_internal_exception(
         """
         logger.error("Internal error in sentry_sdk", exc_info=exc_info)
 
-    def add_breadcrumb(
-        self,
-        crumb=None,  # type: Optional[Breadcrumb]
-        hint=None,  # type: Optional[BreadcrumbHint]
-        **kwargs  # type: Any
-    ):
-        # type: (...) -> None
+    def add_breadcrumb(self, crumb=None, hint=None, **kwargs):
+        # type: (Optional[Breadcrumb], Optional[BreadcrumbHint], Any) -> None
         """
         Adds a breadcrumb.
 
@@ -449,13 +428,8 @@ def add_breadcrumb(
         while len(scope._breadcrumbs) > max_breadcrumbs:
             scope._breadcrumbs.popleft()
 
-    def start_span(
-        self,
-        span=None,  # type: Optional[Span]
-        instrumenter=INSTRUMENTER.SENTRY,  # type: str
-        **kwargs  # type: Any
-    ):
-        # type: (...) -> Span
+    def start_span(self, span=None, instrumenter=INSTRUMENTER.SENTRY, **kwargs):
+        # type: (Optional[Span], str, Any) -> Span
         """
         Create and start timing a new span whose parent is the currently active
         span or transaction, if any. The return value is a span instance,
@@ -500,12 +474,9 @@ def start_span(
         return Span(**kwargs)
 
     def start_transaction(
-        self,
-        transaction=None,  # type: Optional[Transaction]
-        instrumenter=INSTRUMENTER.SENTRY,  # type: str
-        **kwargs  # type: Any
+        self, transaction=None, instrumenter=INSTRUMENTER.SENTRY, **kwargs
     ):
-        # type: (...) -> Union[Transaction, NoOpSpan]
+        # type: (Optional[Transaction], str, Any) -> Union[Transaction, NoOpSpan]
         """
         Start and return a transaction.
 
@@ -577,7 +548,9 @@ def push_scope(  # noqa: F811
         pass
 
     def push_scope(  # noqa
-        self, callback=None  # type: Optional[Callable[[Scope], None]]
+        self,
+        callback=None,  # type: Optional[Callable[[Scope], None]]
+        continue_trace=True,  # type: bool
     ):
         # type: (...) -> Optional[ContextManager[Scope]]
         """
@@ -595,7 +568,13 @@ def push_scope(  # noqa
             return None
 
         client, scope = self._stack[-1]
-        new_layer = (client, copy.copy(scope))
+
+        new_scope = copy.copy(scope)
+
+        if continue_trace:
+            new_scope.generate_propagation_context()
+
+        new_layer = (client, new_scope)
         self._stack.append(new_layer)
 
         return _ScopeManager(self)
@@ -626,7 +605,9 @@ def configure_scope(  # noqa: F811
         pass
 
     def configure_scope(  # noqa
-        self, callback=None  # type: Optional[Callable[[Scope], None]]
+        self,
+        callback=None,  # type: Optional[Callable[[Scope], None]]
+        continue_trace=True,  # type: bool
     ):
         # type: (...) -> Optional[ContextManager[Scope]]
 
@@ -639,6 +620,10 @@ def configure_scope(  # noqa
         """
 
         client, scope = self._stack[-1]
+
+        if continue_trace:
+            scope.generate_propagation_context()
+
         if callback is not None:
             if client is not None:
                 callback(scope)
@@ -721,18 +706,19 @@ def iter_trace_propagation_headers(self, span=None):
         from the span representing the request, if available, or the current
         span on the scope if not.
         """
-        span = span or self.scope.span
-        if not span:
-            return
-
         client = self._stack[-1][0]
-
         propagate_traces = client and client.options["propagate_traces"]
         if not propagate_traces:
             return
 
-        for header in span.iter_headers():
-            yield header
+        span = span or self.scope.span
+
+        if client and has_tracing_enabled(client.options) and span is not None:
+            for header in span.iter_headers():
+                yield header
+        else:
+            for header in self.scope.iter_headers():
+                yield header
 
     def trace_propagation_meta(self, span=None):
         # type: (Optional[Span]) -> str

@@ -1,6 +1,7 @@
 import sys
 import weakref
 
+from sentry_sdk.api import continue_trace
 from sentry_sdk._compat import reraise
 from sentry_sdk.consts import OP
 from sentry_sdk.hub import Hub
@@ -11,7 +12,7 @@
     _filter_headers,
     request_body_within_bounds,
 )
-from sentry_sdk.tracing import SOURCE_FOR_STYLE, Transaction, TRANSACTION_SOURCE_ROUTE
+from sentry_sdk.tracing import SOURCE_FOR_STYLE, TRANSACTION_SOURCE_ROUTE
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     event_from_exception,
@@ -101,7 +102,7 @@ async def sentry_app_handle(self, request, *args, **kwargs):
                         scope.clear_breadcrumbs()
                         scope.add_event_processor(_make_request_processor(weak_request))
 
-                    transaction = Transaction.continue_from_headers(
+                    transaction = continue_trace(
                         request.headers,
                         op=OP.HTTP_SERVER,
                         # If this transaction name makes it to the UI, AIOHTTP's

@@ -11,6 +11,7 @@
 
 from sentry_sdk._functools import partial
 from sentry_sdk._types import TYPE_CHECKING
+from sentry_sdk.api import continue_trace
 from sentry_sdk.consts import OP
 from sentry_sdk.hub import Hub, _should_send_default_pii
 from sentry_sdk.integrations._wsgi_common import _filter_headers
@@ -163,7 +164,7 @@ async def _run_app(self, scope, callback):
                     ty = scope["type"]
 
                     if ty in ("http", "websocket"):
-                        transaction = Transaction.continue_from_headers(
+                        transaction = continue_trace(
                             self._get_headers(scope),
                             op="{}.server".format(ty),
                         )

@@ -3,10 +3,10 @@
 from datetime import datetime, timedelta
 from os import environ
 
+from sentry_sdk.api import continue_trace
 from sentry_sdk.consts import OP
 from sentry_sdk.hub import Hub, _should_send_default_pii
-from sentry_sdk.tracing import TRANSACTION_SOURCE_COMPONENT, Transaction
-from sentry_sdk._compat import reraise
+from sentry_sdk.tracing import TRANSACTION_SOURCE_COMPONENT
 from sentry_sdk.utils import (
     AnnotatedValue,
     capture_internal_exceptions,
@@ -16,7 +16,7 @@
 )
 from sentry_sdk.integrations import Integration
 from sentry_sdk.integrations._wsgi_common import _filter_headers
-
+from sentry_sdk._compat import reraise
 from sentry_sdk._types import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -140,7 +140,8 @@ def sentry_handler(aws_event, aws_context, *args, **kwargs):
             # AWS Service may set an explicit `{headers: None}`, we can't rely on `.get()`'s default.
             if headers is None:
                 headers = {}
-            transaction = Transaction.continue_from_headers(
+
+            transaction = continue_trace(
                 headers,
                 op=OP.FUNCTION_AWS,
                 name=aws_context.function_name,