feat: add span / transaction collection to sentry-tracing

Author: leops

Diff for: sentry-core/src/client.rs

@@ -337,6 +337,17 @@ impl Client {
             random::<f32>() <= rate
         }
     }
+
+    /// Returns a random boolean with a probability defined
+    /// by the [`ClientOptions`]'s `traces_sample_rate`
+    pub fn sample_traces_should_send(&self) -> bool {
+        let rate = self.options.traces_sample_rate;
+        if rate >= 1.0 {
+            true
+        } else {
+            random::<f32>() <= rate
+        }
+    }
 }
 
 // Make this unwind safe. It's not out of the box because of the

Diff for: sentry-core/src/clientoptions.rs

@@ -72,6 +72,8 @@ pub struct ClientOptions {
     pub environment: Option<Cow<'static, str>>,
     /// The sample rate for event submission. (0.0 - 1.0, defaults to 1.0)
     pub sample_rate: f32,
+    /// The sample rate for tracing transactions. (0.0 - 1.0, defaults to 0.0)
+    pub traces_sample_rate: f32,
     /// Maximum number of breadcrumbs. (defaults to 100)
     pub max_breadcrumbs: usize,
     /// Attaches stacktraces to messages.
@@ -179,6 +181,7 @@ impl fmt::Debug for ClientOptions {
             .field("release", &self.release)
             .field("environment", &self.environment)
             .field("sample_rate", &self.sample_rate)
+            .field("traces_sample_rate", &self.traces_sample_rate)
             .field("max_breadcrumbs", &self.max_breadcrumbs)
             .field("attach_stacktrace", &self.attach_stacktrace)
             .field("send_default_pii", &self.send_default_pii)
@@ -210,6 +213,7 @@ impl Default for ClientOptions {
             release: None,
             environment: None,
             sample_rate: 1.0,
+            traces_sample_rate: 0.0,
             max_breadcrumbs: 100,
             attach_stacktrace: false,
             send_default_pii: false,

Diff for: sentry-tracing/src/converters.rs

@@ -1,8 +1,15 @@
 use std::collections::BTreeMap;
 
-use sentry_core::protocol::{Event, Value};
+use sentry_core::protocol::{self, Event, TraceContext, Value};
 use sentry_core::{Breadcrumb, Level};
-use tracing_core::field::{Field, Visit};
+use tracing_core::{
+    field::{Field, Visit},
+    span, Subscriber,
+};
+use tracing_subscriber::layer::Context;
+use tracing_subscriber::registry::LookupSpan;
+
+use crate::Trace;
 
 /// Converts a [`tracing_core::Level`] to a Sentry [`Level`]
 pub fn convert_tracing_level(level: &tracing_core::Level) -> Level {
@@ -15,7 +22,9 @@ pub fn convert_tracing_level(level: &tracing_core::Level) -> Level {
 }
 
 /// Extracts the message and metadata from an event
-pub fn extract_data(event: &tracing_core::Event) -> (Option<String>, BTreeMap<String, Value>) {
+pub fn extract_event_data(
+    event: &tracing_core::Event,
+) -> (Option<String>, BTreeMap<String, Value>) {
     // Find message of the event, if any
     let mut data = BTreeMapRecorder::default();
     event.record(&mut data);
@@ -28,6 +37,21 @@ pub fn extract_data(event: &tracing_core::Event) -> (Option<String>, BTreeMap<St
     (message, data.0)
 }
 
+/// Extracts the message and metadata from a span
+pub fn extract_span_data(attrs: &span::Attributes) -> (Option<String>, BTreeMap<String, Value>) {
+    let mut data = BTreeMapRecorder::default();
+    attrs.record(&mut data);
+
+    // Find message of the span, if any
+    let message = data
+        .0
+        .remove("message")
+        .map(|v| v.as_str().map(|s| s.to_owned()))
+        .flatten();
+
+    (message, data.0)
+}
+
 #[derive(Default)]
 /// Records all fields of [`tracing_core::Event`] for easy access
 struct BTreeMapRecorder(pub BTreeMap<String, Value>);
@@ -58,7 +82,7 @@ impl Visit for BTreeMapRecorder {
 
 /// Creates a [`Breadcrumb`] from a given [`tracing_core::Event`]
 pub fn breadcrumb_from_event(event: &tracing_core::Event) -> Breadcrumb {
-    let (message, data) = extract_data(event);
+    let (message, data) = extract_event_data(event);
     Breadcrumb {
         category: Some(event.metadata().target().to_owned()),
         ty: "log".into(),
@@ -70,22 +94,55 @@ pub fn breadcrumb_from_event(event: &tracing_core::Event) -> Breadcrumb {
 }
 
 /// Creates an [`Event`] from a given [`tracing_core::Event`]
-pub fn event_from_event(event: &tracing_core::Event) -> Event<'static> {
-    let (message, extra) = extract_data(event);
-    Event {
+pub fn event_from_event<S>(event: &tracing_core::Event, ctx: Context<S>) -> Event<'static>
+where
+    S: Subscriber + for<'a> LookupSpan<'a>,
+{
+    let (message, extra) = extract_event_data(event);
+
+    let mut result = Event {
         logger: Some(event.metadata().target().to_owned()),
         level: convert_tracing_level(event.metadata().level()),
         message,
         extra,
         ..Default::default()
+    };
+
+    let parent = event
+        .parent()
+        .and_then(|id| ctx.span(id))
+        .or_else(|| ctx.lookup_current());
+
+    if let Some(parent) = parent {
+        let extensions = parent.extensions();
+        if let Some(trace) = extensions.get::<Trace>() {
+            let context = protocol::Context::from(TraceContext {
+                span_id: trace.span.span_id,
+                trace_id: trace.span.trace_id,
+                ..TraceContext::default()
+            });
+
+            result.contexts.insert(context.type_name().into(), context);
+            result.transaction = parent
+                .parent()
+                .into_iter()
+                .flat_map(|span| span.scope())
+                .last()
+                .map(|root| root.name().into());
+        }
     }
+
+    result
 }
 
 /// Creates an exception [`Event`] from a given [`tracing_core::Event`]
-pub fn exception_from_event(event: &tracing_core::Event) -> Event<'static> {
+pub fn exception_from_event<S>(event: &tracing_core::Event, ctx: Context<S>) -> Event<'static>
+where
+    S: Subscriber + for<'a> LookupSpan<'a>,
+{
     // TODO: Exception records in Sentry need a valid type, value and full stack trace to support
     // proper grouping and issue metadata generation. tracing_core::Record does not contain sufficient
     // information for this. However, it may contain a serialized error which we can parse to emit
     // an exception record.
-    event_from_event(event)
+    event_from_event(event, ctx)
 }