Add external_propagation_context support

If we are on an external tracing system like otel, we allow
registering a new source of `trace_id/span_id` that takes precedence
over the scope's propagation_context.

* Also reworked logs and metrics to use `get_trace_context`
* Cleaned up handling of `get_trace_context` that is still messy but a
  bit more clearer now regarding which underlying `propagation_context`
  is used

Author: sl0thentr0py

sentry_sdk/client.py

@@ -933,17 +933,18 @@ def _capture_log(self, log):
         if release is not None and "sentry.release" not in log["attributes"]:
             log["attributes"]["sentry.release"] = release
 
-        span = current_scope.span
-        if span is not None and "sentry.trace.parent_span_id" not in log["attributes"]:
-            log["attributes"]["sentry.trace.parent_span_id"] = span.span_id
-
-        if log.get("trace_id") is None:
-            transaction = current_scope.transaction
-            propagation_context = isolation_scope.get_active_propagation_context()
-            if transaction is not None:
-                log["trace_id"] = transaction.trace_id
-            elif propagation_context is not None:
-                log["trace_id"] = propagation_context.trace_id
+        trace_context = current_scope.get_trace_context()
+        trace_id = trace_context.get("trace_id")
+        span_id = trace_context.get("span_id")
+
+        if trace_id is not None and log.get("trace_id") is None:
+            log["trace_id"] = trace_id
+
+        if (
+            span_id is not None
+            and "sentry.trace.parent_span_id" not in log["attributes"]
+        ):
+            log["attributes"]["sentry.trace.parent_span_id"] = span_id
 
         # The user, if present, is always set on the isolation scope.
         if isolation_scope._user is not None:
@@ -982,6 +983,7 @@ def _capture_metric(self, metric):
         if not has_metrics_enabled(self.options) or metric is None:
             return
 
+        current_scope = sentry_sdk.get_current_scope()
         isolation_scope = sentry_sdk.get_isolation_scope()
 
         metric["attributes"]["sentry.sdk.name"] = SDK_INFO["name"]
@@ -995,16 +997,14 @@ def _capture_metric(self, metric):
         if release is not None and "sentry.release" not in metric["attributes"]:
             metric["attributes"]["sentry.release"] = release
 
-        span = sentry_sdk.get_current_span()
-        metric["trace_id"] = "00000000-0000-0000-0000-000000000000"
+        trace_context = current_scope.get_trace_context()
+        trace_id = trace_context.get("trace_id")
+        span_id = trace_context.get("span_id")
 
-        if span:
-            metric["trace_id"] = span.trace_id
-            metric["span_id"] = span.span_id
-        else:
-            propagation_context = isolation_scope.get_active_propagation_context()
-            if propagation_context and propagation_context.trace_id:
-                metric["trace_id"] = propagation_context.trace_id
+        if trace_id is not None:
+            metric["trace_id"] = trace_id
+        if span_id is not None:
+            metric["span_id"] = span_id
 
         if isolation_scope._user is not None:
             for metric_attribute, user_attribute in (

sentry_sdk/scope.py

@@ -107,6 +107,10 @@
 
 global_event_processors = []  # type: List[EventProcessor]
 
+# A function returning a (trace_id, span_id) tuple
+# from an external tracing source (such as otel)
+_external_propagation_context_fn = None  # type: Optional[Callable[[], Optional[Tuple[str, str]]]]
+
 
 class ScopeType(Enum):
     CURRENT = "current"
@@ -142,6 +146,19 @@ def add_global_event_processor(processor):
     global_event_processors.append(processor)
 
 
+def register_external_propagation_context(fn):
+    # type: (Callable[[], Optional[Tuple[str, str]]]) -> None
+    global _external_propagation_context_fn
+    _external_propagation_context_fn = fn
+
+
+def get_external_propagation_context():
+    # type: () -> Optional[Tuple[str, str]]
+    return (
+        _external_propagation_context_fn() if _external_propagation_context_fn else None
+    )
+
+
 def _attr_setter(fn):
     # type: (Any) -> Any
     return property(fset=fn, doc=fn.__doc__)
@@ -562,22 +579,30 @@ def get_baggage(self, *args, **kwargs):
         return self.get_isolation_scope().get_baggage()
 
     def get_trace_context(self):
-        # type: () -> Any
+        # type: () -> Dict[str, Any]
         """
         Returns the Sentry "trace" context from the Propagation Context.
         """
-        if self._propagation_context is None:
-            return None
+        if has_tracing_enabled(self.get_client().options) and self._span is not None:
+            return self._span.get_trace_context()
+
+        # if we are tracing externally (otel), those values take precedence
+        external_propagation_context = get_external_propagation_context()
+        if external_propagation_context:
+            trace_id, span_id = external_propagation_context
+            return {"trace_id": trace_id, "span_id": span_id}
 
-        trace_context = {
-            "trace_id": self._propagation_context.trace_id,
-            "span_id": self._propagation_context.span_id,
-            "parent_span_id": self._propagation_context.parent_span_id,
+        propagation_context = self.get_active_propagation_context()
+        if propagation_context is None:
+            return {}
+
+        return {
+            "trace_id": propagation_context.trace_id,
+            "span_id": propagation_context.span_id,
+            "parent_span_id": propagation_context.parent_span_id,
             "dynamic_sampling_context": self.get_dynamic_sampling_context(),
         }  # type: Dict[str, Any]
 
-        return trace_context
-
     def trace_propagation_meta(self, *args, **kwargs):
         # type: (*Any, **Any) -> str
         """
@@ -1438,10 +1463,7 @@ def _apply_contexts_to_event(self, event, hint, options):
 
         # Add "trace" context
         if contexts.get("trace") is None:
-            if has_tracing_enabled(options) and self._span is not None:
-                contexts["trace"] = self._span.get_trace_context()
-            else:
-                contexts["trace"] = self.get_trace_context()
+            contexts["trace"] = self.get_trace_context()
 
     def _apply_flags_to_event(self, event, hint, options):
         # type: (Event, Hint, Optional[Dict[str, Any]]) -> None