introduce a continue_from_span method

Author: Swatinem

sentry-core/src/performance.rs

@@ -91,6 +91,40 @@ impl TransactionContext {
         }
     }
 
+    /// Creates a new Transaction Context based on an existing Span.
+    ///
+    /// This should be used when an independent computation is spawned on another
+    /// thread and should be connected to the calling thread via a distributed
+    /// tracing transaction.
+    pub fn continue_from_span(name: &str, op: &str, span: Option<TransactionOrSpan>) -> Self {
+        let span = match span {
+            Some(span) => span,
+            None => return Self::new(name, op),
+        };
+
+        let (trace_id, parent_span_id, sampled) = match span {
+            TransactionOrSpan::Transaction(transaction) => {
+                let inner = transaction.inner.lock().unwrap();
+                (
+                    inner.context.trace_id,
+                    inner.context.span_id,
+                    Some(inner.sampled),
+                )
+            }
+            TransactionOrSpan::Span(span) => {
+                (span.span.trace_id, span.span.span_id, Some(span.sampled))
+            }
+        };
+
+        Self {
+            name: name.into(),
+            op: op.into(),
+            trace_id,
+            parent_span_id: Some(parent_span_id),
+            sampled,
+        }
+    }
+
     /// Set the sampling decision for this Transaction.
     ///
     /// This can be either an explicit boolean flag, or [`None`], which will fall

sentry/examples/performance-demo.rs

@@ -26,17 +26,13 @@ fn main_span1() {
     wrap_in_span("span1", "", || {
         thread::sleep(Duration::from_millis(50));
 
-        let headers = match sentry::configure_scope(|scope| scope.get_span()) {
-            Some(span) => vec![span.iter_headers().next().unwrap()],
-            None => vec![],
-        };
+        let transaction_ctx = sentry::TransactionContext::continue_from_span(
+            "background transaction",
+            "root span",
+            sentry::configure_scope(|scope| scope.get_span()),
+        );
         thread::spawn(move || {
-            let transaction =
-                sentry::start_transaction(sentry::TransactionContext::continue_from_headers(
-                    "background transaction",
-                    "root span",
-                    headers.iter().map(|(k, v)| (*k, v.as_str())),
-                ));
+            let transaction = sentry::start_transaction(transaction_ctx);
             sentry::configure_scope(|scope| scope.set_span(Some(transaction.clone().into())));
 
             thread::sleep(Duration::from_millis(50));