feat(metrics): Associate trace data with metrics

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/performance.rs

@@ -586,6 +586,15 @@ impl TransactionOrSpan {
             TransactionOrSpan::Span(span) => span.finish(),
         }
     }
+
+    /// Get the span ID of this [`TransactionOrSpan`].
+    #[cfg(all(feature = "metrics", feature = "client"))]
+    pub(crate) fn span_id(&self) -> SpanId {
+        match self {
+            TransactionOrSpan::Transaction(transaction) => transaction.get_trace_context().span_id,
+            TransactionOrSpan::Span(span) => span.get_span_id(),
+        }
+    }
 }
 
 #[derive(Debug)]

sentry-core/src/scope/real.rs

@@ -6,6 +6,8 @@ use std::sync::Mutex;
 use std::sync::{Arc, PoisonError, RwLock};
 
 use crate::performance::TransactionOrSpan;
+#[cfg(feature = "metrics")]
+use crate::protocol::Metric;
 use crate::protocol::{
     Attachment, Breadcrumb, Context, Event, Level, TraceContext, Transaction, User, Value,
 };
@@ -399,6 +401,17 @@ impl Scope {
         }
     }
 
+    /// Applies the contained scoped data to a trace metric, setting the `trace_id` and `span_id`.
+    #[cfg(feature = "metrics")]
+    pub(crate) 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| span.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

@@ -8,7 +8,7 @@ use anyhow::{Context, Result};
 use sentry::protocol::MetricType;
 use sentry_core::protocol::{EnvelopeItem, ItemContainer};
 use sentry_core::test;
-use sentry_core::{ClientOptions, Hub};
+use sentry_core::{ClientOptions, Hub, TransactionContext};
 use sentry_types::protocol::v7::Metric;
 
 /// Test that metrics are sent when metrics are enabled.
@@ -204,6 +204,85 @@ fn test_metrics_batching_over_limit() {
     )
 }
 
+/// Test that metrics in the same scope share the same trace_id when no span is active.
+///
+/// This tests that trace ID is set from the propagation context when there is no active span.
+#[test]
+fn metrics_share_trace_id_without_active_span() {
+    let options = ClientOptions {
+        enable_metrics: true,
+        ..Default::default()
+    };
+
+    let envelopes = test::with_captured_envelopes_options(
+        || {
+            capture_test_metric("test-1");
+            capture_test_metric("test-2");
+        },
+        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 metrics = item.into_metrics().expect("expected metrics item");
+
+    let [metric1, metric2] = metrics.as_slice() else {
+        panic!("expected exactly two metrics");
+    };
+
+    assert_eq!(
+        metric1.trace_id, metric2.trace_id,
+        "metrics in the same scope should share the same trace_id"
+    );
+
+    assert!(metric1.span_id.is_none());
+    assert!(metric2.span_id.is_none());
+}
+
+/// Test that span_id is set from the active span when one is present.
+#[test]
+fn metrics_span_id_from_active_span() {
+    let options = ClientOptions {
+        enable_metrics: true,
+        ..Default::default()
+    };
+
+    let mut expected_span_id = None;
+    let envelopes = test::with_captured_envelopes_options(
+        || {
+            let transaction_ctx = TransactionContext::new("test transaction", "test");
+            expected_span_id = Some(transaction_ctx.span_id());
+            let transaction = sentry_core::start_transaction(transaction_ctx);
+            sentry_core::configure_scope(|scope| scope.set_span(Some(transaction.clone().into())));
+            capture_test_metric("test");
+            transaction.finish();
+        },
+        options,
+    );
+
+    let expected_span_id = expected_span_id.expect("expected_span_id did not get set");
+
+    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_eq!(
+        metric.span_id,
+        Some(expected_span_id),
+        "span_id should be set from the active span"
+    );
+}
+
 /// Returns a [`Metric`] with [type `Counter`](MetricType),
 /// the provided name, and a value of `1.0`.
 fn test_metric<S>(name: S) -> Metric