feat(metrics): Associate trace data with metrics (RUST-186)

Prepare metrics through scope trace association before enqueueing them so metric capture inherits the current tracing context.

Set metric trace_id from the active span when present and otherwise from the propagation context, and set span_id from the active span. Keep the matching no-op scope API and the propagation-context metric test, while excluding the default attribute, user enrichment, and callback changes from [#1031](#1031).

Co-authored-by: Joris Bayer <joris.bayer@sentry.io>
Closes #1058
Closes [RUST-186](https://linear.app/getsentry/issue/RUST-186/add-trace-metric-tracing-association-in-sentry-core)

Author: szokeasaurusrex

sentry-core/src/client.rs

@@ -524,16 +524,25 @@ impl Client {
 
     /// Captures a metric and sends it to Sentry.
     #[cfg(feature = "metrics")]
-    pub fn capture_metric(&self, metric: Metric, _: &Scope) {
-        if let Some(batcher) = self
-            .metrics_batcher
-            .read()
-            .expect("metrics batcher lock could not be acquired")
-            .as_ref()
-        {
-            batcher.enqueue(metric);
+    pub fn capture_metric(&self, metric: Metric, scope: &Scope) {
+        if let Some(metric) = self.prepare_metric(metric, scope) {
+            if let Some(batcher) = self
+                .metrics_batcher
+                .read()
+                .expect("metrics batcher lock could not be acquired")
+                .as_ref()
+            {
+                batcher.enqueue(metric);
+            }
         }
     }
+
+    /// Prepares a metric to be sent, setting trace association data from the scope.
+    #[cfg(feature = "metrics")]
+    fn prepare_metric(&self, mut metric: Metric, scope: &Scope) -> Option<Metric> {
+        scope.apply_to_metric(&mut metric);
+        Some(metric)
+    }
 }
 
 // Make this unwind safe. It's not out of the box because of the

sentry-core/src/scope/noop.rs

@@ -2,6 +2,8 @@ use std::fmt;
 
 #[cfg(feature = "logs")]
 use crate::protocol::Log;
+#[cfg(feature = "metrics")]
+use crate::protocol::Metric;
 use crate::protocol::{Context, Event, Level, User, Value};
 use crate::TransactionOrSpan;
 
@@ -119,6 +121,13 @@ impl Scope {
         minimal_unreachable!();
     }
 
+    /// Applies the contained scoped data to fill a trace metric.
+    #[cfg(feature = "metrics")]
+    pub fn apply_to_metric(&self, metric: &mut Metric) {
+        let _metric = metric;
+        minimal_unreachable!();
+    }
+
     /// Set the given [`TransactionOrSpan`] as the active span for this scope.
     pub fn set_span(&mut self, span: Option<TransactionOrSpan>) {
         let _ = span;

sentry-core/src/scope/real.rs

@@ -11,6 +11,8 @@ use crate::protocol::{
 };
 #[cfg(feature = "logs")]
 use crate::protocol::{Log, LogAttribute};
+#[cfg(feature = "metrics")]
+use crate::protocol::Metric;
 #[cfg(feature = "release-health")]
 use crate::session::Session;
 use crate::{Client, SentryTrace, TraceHeader, TraceHeadersIter};
@@ -399,6 +401,20 @@ impl Scope {
         }
     }
 
+    /// Applies the contained scoped data to a trace metric, setting the `trace_id` and `span_id`.
+    #[cfg(feature = "metrics")]
+    pub fn apply_to_metric(&self, metric: &mut Metric) {
+        metric.trace_id = self
+            .get_span()
+            .map(|span| span.get_trace_context().trace_id)
+            .unwrap_or(self.propagation_context.trace_id);
+
+        metric.span_id = self.get_span().map(|span| match span {
+            crate::TransactionOrSpan::Transaction(transaction) => transaction.get_trace_context().span_id,
+            crate::TransactionOrSpan::Span(span) => span.get_span_id(),
+        });
+    }
+
     /// Set the given [`TransactionOrSpan`] as the active span for this scope.
     pub fn set_span(&mut self, span: Option<TransactionOrSpan>) {
         self.span = Arc::new(span);

sentry-core/tests/metrics.rs

@@ -204,6 +204,32 @@ fn test_metrics_batching_over_limit() {
     )
 }
 
+/// Test that trace_id is set from the propagation context when no span is active.
+#[test]
+fn metrics_trace_id_from_propagation_context() {
+    let options = ClientOptions {
+        enable_metrics: true,
+        ..Default::default()
+    };
+
+    let envelopes = test::with_captured_envelopes_options(|| capture_test_metric("test"), options);
+    let envelope = envelopes
+        .try_into_only_item()
+        .expect("expected one envelope");
+    let item = envelope
+        .into_items()
+        .try_into_only_item()
+        .expect("expected one item");
+    let mut metrics = item.into_metrics().expect("expected metrics item");
+    let metric = metrics.pop().expect("expected one metric");
+
+    assert_ne!(
+        metric.trace_id,
+        Default::default(),
+        "trace_id should be set from propagation context"
+    );
+}
+
 /// Returns a [`Metric`] with [type `Counter`](MetricType),
 /// the provided name, and a value of `1.0`.
 fn test_metric<S>(name: S) -> Metric