Merge branch 'master' into shellmayr/feat/auto-deactivate-lower-level-integartions

Author: alexander-alderman-webb

scripts/populate_tox/package_dependencies.jsonl

@@ -10,6 +10,7 @@
 
 import sentry_sdk
 from sentry_sdk._compat import PY37, check_uwsgi_thread_support
+from sentry_sdk._metrics_batcher import MetricsBatcher
 from sentry_sdk.utils import (
     AnnotatedValue,
     ContextVar,
@@ -26,7 +27,6 @@
     get_before_send_log,
     get_before_send_metric,
     has_logs_enabled,
-    has_metrics_enabled,
 )
 from sentry_sdk.serializer import serialize
 from sentry_sdk.tracing import trace
@@ -374,12 +374,7 @@ def _capture_envelope(envelope):
 
                 self.log_batcher = LogBatcher(capture_func=_capture_envelope)
 
-            self.metrics_batcher = None
-
-            if has_metrics_enabled(self.options):
-                from sentry_sdk._metrics_batcher import MetricsBatcher
-
-                self.metrics_batcher = MetricsBatcher(capture_func=_capture_envelope)
+            self.metrics_batcher = MetricsBatcher(capture_func=_capture_envelope)
 
             max_request_body_size = ("always", "never", "small", "medium")
             if self.options["max_request_body_size"] not in max_request_body_size:
@@ -933,17 +928,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
+        trace_context = current_scope.get_trace_context()
+        trace_id = trace_context.get("trace_id")
+        span_id = trace_context.get("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
+        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:
@@ -979,9 +975,10 @@ def _capture_log(self, log):
 
     def _capture_metric(self, metric):
         # type: (Optional[Metric]) -> None
-        if not has_metrics_enabled(self.options) or metric is None:
+        if 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 +992,13 @@ 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
+        metric["trace_id"] = trace_id or "00000000-0000-0000-0000-000000000000"
+        if span_id is not None:
+            metric["span_id"] = span_id
 
         if isolation_scope._user is not None:
             for metric_attribute, user_attribute in (

scripts/populate_tox/releases.jsonl

@@ -22,9 +22,14 @@
 
 try:
     try:
-        from anthropic import NOT_GIVEN
+        from anthropic import NotGiven
     except ImportError:
-        NOT_GIVEN = None
+        NotGiven = None
+
+    try:
+        from anthropic import Omit
+    except ImportError:
+        Omit = None
 
     from anthropic.resources import AsyncMessages, Messages
 
@@ -168,12 +173,13 @@ def _set_input_data(span, kwargs, integration):
     }
     for key, attribute in kwargs_keys_to_attributes.items():
         value = kwargs.get(key)
-        if value is not NOT_GIVEN and value is not None:
+
+        if value is not None and _is_given(value):
             set_data_normalized(span, attribute, value)
 
     # Input attributes: Tools
     tools = kwargs.get("tools")
-    if tools is not NOT_GIVEN and tools is not None and len(tools) > 0:
+    if tools is not None and _is_given(tools) and len(tools) > 0:
         set_data_normalized(
             span, SPANDATA.GEN_AI_REQUEST_AVAILABLE_TOOLS, safe_serialize(tools)
         )
@@ -419,3 +425,15 @@ async def _sentry_patched_create_async(*args, **kwargs):
                     span.__exit__(None, None, None)
 
     return _sentry_patched_create_async
+
+
+def _is_given(obj):
+    # type: (Any) -> bool
+    """
+    Check for givenness safely across different anthropic versions.
+    """
+    if NotGiven is not None and isinstance(obj, NotGiven):
+        return False
+    if Omit is not None and isinstance(obj, Omit):
+        return False
+    return True

sentry_sdk/client.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,25 @@ 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 remove_external_propagation_context():
+    # type: () -> None
+    global _external_propagation_context_fn
+    _external_propagation_context_fn = None
+
+
+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,21 +585,29 @@ 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()
 
-        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,
-            "dynamic_sampling_context": self.get_dynamic_sampling_context(),
-        }  # type: Dict[str, Any]
+        # 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}
 
-        return trace_context
+        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(),
+        }
 
     def trace_propagation_meta(self, *args, **kwargs):
         # type: (*Any, **Any) -> str
@@ -1438,10 +1469,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

sentry_sdk/integrations/anthropic.py

@@ -2047,14 +2047,6 @@ def get_before_send_log(options):
     )
 
 
-def has_metrics_enabled(options):
-    # type: (Optional[dict[str, Any]]) -> bool
-    if options is None:
-        return False
-
-    return bool(options["_experiments"].get("enable_metrics", False))
-
-
 def get_before_send_metric(options):
     # type: (Optional[dict[str, Any]]) -> Optional[Callable[[Metric, Hint], Optional[Metric]]]
     if options is None:

sentry_sdk/scope.py

@@ -478,6 +478,10 @@ def test_logger_with_all_attributes(sentry_init, capture_envelopes):
 
     assert attributes.pop("sentry.sdk.name").startswith("sentry.python")
 
+    assert "sentry.trace.parent_span_id" in attributes
+    assert isinstance(attributes["sentry.trace.parent_span_id"], str)
+    del attributes["sentry.trace.parent_span_id"]
+
     # Assert on the remaining non-dynamic attributes.
     assert attributes == {
         "foo": "bar",

sentry_sdk/utils.py

@@ -458,6 +458,10 @@ def test_logger_with_all_attributes(
 
     assert attributes.pop("sentry.sdk.name").startswith("sentry.python")
 
+    assert "sentry.trace.parent_span_id" in attributes
+    assert isinstance(attributes["sentry.trace.parent_span_id"], str)
+    del attributes["sentry.trace.parent_span_id"]
+
     # Assert on the remaining non-dynamic attributes.
     assert attributes == {
         "logger.name": "tests.integrations.loguru.test_loguru",

tests/integrations/logging/test_logging.py

@@ -310,7 +310,7 @@ def test_logs_tied_to_transactions(sentry_init, capture_envelopes):
     """
     Log messages are also tied to transactions.
     """
-    sentry_init(enable_logs=True)
+    sentry_init(enable_logs=True, traces_sample_rate=1.0)
     envelopes = capture_envelopes()
 
     with sentry_sdk.start_transaction(name="test-transaction") as trx:
@@ -326,7 +326,7 @@ def test_logs_tied_to_spans(sentry_init, capture_envelopes):
     """
     Log messages are also tied to spans.
     """
-    sentry_init(enable_logs=True)
+    sentry_init(enable_logs=True, traces_sample_rate=1.0)
     envelopes = capture_envelopes()
 
     with sentry_sdk.start_transaction(name="test-transaction"):

tests/integrations/loguru/test_loguru.py

@@ -33,20 +33,8 @@ def envelopes_to_metrics(envelopes):
     return res
 
 
-def test_metrics_disabled_by_default(sentry_init, capture_envelopes):
-    sentry_init()
-
-    envelopes = capture_envelopes()
-
-    sentry_sdk.metrics.count("test.counter", 1)
-    sentry_sdk.metrics.gauge("test.gauge", 42)
-    sentry_sdk.metrics.distribution("test.distribution", 200)
-
-    assert len(envelopes) == 0
-
-
 def test_metrics_basics(sentry_init, capture_envelopes):
-    sentry_init(_experiments={"enable_metrics": True})
+    sentry_init()
     envelopes = capture_envelopes()
 
     sentry_sdk.metrics.count("test.counter", 1)
@@ -77,7 +65,7 @@ def test_metrics_basics(sentry_init, capture_envelopes):
 
 
 def test_metrics_experimental_option(sentry_init, capture_envelopes):
-    sentry_init(_experiments={"enable_metrics": True})
+    sentry_init()
     envelopes = capture_envelopes()
 
     sentry_sdk.metrics.count("test.counter", 5)
@@ -93,9 +81,7 @@ def test_metrics_experimental_option(sentry_init, capture_envelopes):
 
 
 def test_metrics_with_attributes(sentry_init, capture_envelopes):
-    sentry_init(
-        _experiments={"enable_metrics": True}, release="1.0.0", environment="test"
-    )
+    sentry_init(release="1.0.0", environment="test")
     envelopes = capture_envelopes()
 
     sentry_sdk.metrics.count(
@@ -114,7 +100,7 @@ def test_metrics_with_attributes(sentry_init, capture_envelopes):
 
 
 def test_metrics_with_user(sentry_init, capture_envelopes):
-    sentry_init(_experiments={"enable_metrics": True})
+    sentry_init()
     envelopes = capture_envelopes()
 
     sentry_sdk.set_user(
@@ -133,10 +119,10 @@ def test_metrics_with_user(sentry_init, capture_envelopes):
 
 
 def test_metrics_with_span(sentry_init, capture_envelopes):
-    sentry_init(_experiments={"enable_metrics": True}, traces_sample_rate=1.0)
+    sentry_init(traces_sample_rate=1.0)
     envelopes = capture_envelopes()
 
-    with sentry_sdk.start_transaction(op="test", name="test-span"):
+    with sentry_sdk.start_transaction(op="test", name="test-span") as transaction:
         sentry_sdk.metrics.count("test.span.counter", 1)
 
     get_client().flush()
@@ -145,24 +131,26 @@ def test_metrics_with_span(sentry_init, capture_envelopes):
     assert len(metrics) == 1
 
     assert metrics[0]["trace_id"] is not None
-    assert metrics[0]["trace_id"] != "00000000-0000-0000-0000-000000000000"
-    assert metrics[0]["span_id"] is not None
+    assert metrics[0]["trace_id"] == transaction.trace_id
+    assert metrics[0]["span_id"] == transaction.span_id
 
 
 def test_metrics_tracing_without_performance(sentry_init, capture_envelopes):
-    sentry_init(_experiments={"enable_metrics": True})
+    sentry_init()
     envelopes = capture_envelopes()
 
-    sentry_sdk.metrics.count("test.span.counter", 1)
+    with sentry_sdk.isolation_scope() as isolation_scope:
+        sentry_sdk.metrics.count("test.span.counter", 1)
 
     get_client().flush()
 
     metrics = envelopes_to_metrics(envelopes)
     assert len(metrics) == 1
 
-    assert metrics[0]["trace_id"] is not None
-    assert metrics[0]["trace_id"] != "00000000-0000-0000-0000-000000000000"
-    assert metrics[0]["span_id"] is None
+    propagation_context = isolation_scope._propagation_context
+    assert propagation_context is not None
+    assert metrics[0]["trace_id"] == propagation_context.trace_id
+    assert metrics[0]["span_id"] == propagation_context.span_id
 
 
 def test_metrics_before_send(sentry_init, capture_envelopes):
@@ -190,7 +178,6 @@ def _before_metric(record, hint):
 
     sentry_init(
         _experiments={
-            "enable_metrics": True,
             "before_send_metric": _before_metric,
         },
     )