sentry_core/performance/

mod.rs

use std::borrow::Cow;
use std::collections::BTreeMap;
use std::ops::{Deref, DerefMut};
use std::sync::{Arc, Mutex, MutexGuard};
use std::time::SystemTime;

#[cfg(feature = "client")]
use sentry_types::protocol::v7::client_report::Reason as ClientReportReason;
#[cfg(feature = "client")]
use sentry_types::protocol::v7::OrganizationId;
use sentry_types::protocol::v7::SpanId;

#[cfg(feature = "client")]
use self::sampling::FinishAction;
use self::sampling::TracingState;
#[cfg(feature = "client")]
use crate::clientoptions::TracesSamplingStrategy;
use crate::{protocol, Hub};

#[cfg(feature = "client")]
use crate::Client;

#[expect(deprecated, reason = "backwards-compatibility re-export")]
pub use self::headers::{parse_sentry_trace_header as parse_headers, SentryTrace};
pub use self::headers::{HeaderParseError, TracePropagationContext};

mod headers;
mod sampling;

#[cfg(feature = "client")]
const MAX_SPANS: usize = 1_000;

// global API:

/// Start a new Performance Monitoring Transaction.
///
/// The transaction needs to be explicitly finished via [`Transaction::finish`],
/// otherwise it will be discarded.
/// The transaction itself also represents the root span in the span hierarchy.
/// Child spans can be started with the [`Transaction::start_child`] method.
pub fn start_transaction(ctx: TransactionContext) -> Transaction {
    #[cfg(feature = "client")]
    {
        let client = Hub::with_active(|hub| hub.client());
        Transaction::new(client, ctx)
    }
    #[cfg(not(feature = "client"))]
    {
        Transaction::new_noop(ctx)
    }
}

/// Start a new Performance Monitoring Transaction with the provided start timestamp.
///
/// The transaction needs to be explicitly finished via [`Transaction::finish`],
/// otherwise it will be discarded.
/// The transaction itself also represents the root span in the span hierarchy.
/// Child spans can be started with the [`Transaction::start_child`] method.
pub fn start_transaction_with_timestamp(
    ctx: TransactionContext,
    timestamp: SystemTime,
) -> Transaction {
    let transaction = start_transaction(ctx);
    if let Some(tx) = transaction.inner.lock().unwrap().transaction.as_mut() {
        tx.start_timestamp = timestamp;
    }
    transaction
}

// Hub API:

impl Hub {
    /// Start a new Performance Monitoring Transaction.
    ///
    /// See the global [`start_transaction`] for more documentation.
    pub fn start_transaction(&self, ctx: TransactionContext) -> Transaction {
        #[cfg(feature = "client")]
        {
            Transaction::new(self.client(), ctx)
        }
        #[cfg(not(feature = "client"))]
        {
            Transaction::new_noop(ctx)
        }
    }

    /// Start a new Performance Monitoring Transaction with the provided start timestamp.
    ///
    /// See the global [`start_transaction_with_timestamp`] for more documentation.
    pub fn start_transaction_with_timestamp(
        &self,
        ctx: TransactionContext,
        timestamp: SystemTime,
    ) -> Transaction {
        let transaction = start_transaction(ctx);
        if let Some(tx) = transaction.inner.lock().unwrap().transaction.as_mut() {
            tx.start_timestamp = timestamp;
        }
        transaction
    }
}

// "Context" Types:

/// Arbitrary data passed by the caller, when starting a transaction.
///
/// May be inspected by the user in the `traces_sampler` callback, if set.
///
/// Represents arbitrary JSON data, the top level of which must be a map.
pub type CustomTransactionContext = serde_json::Map<String, serde_json::Value>;

/// Information from an incoming trace.
///
/// Currently this just contains the org ID supplied by the incoming trace.
#[cfg(feature = "client")]
#[derive(Debug, Clone, Copy)]
struct IncomingTrace {
    org_id: Option<OrganizationId>,
}

/// The Transaction Context used to start a new Performance Monitoring Transaction.
///
/// The Transaction Context defines the metadata for a Performance Monitoring
/// Transaction, and also the connection point for distributed tracing.
#[derive(Debug, Clone)]
pub struct TransactionContext {
    #[cfg_attr(not(feature = "client"), allow(dead_code))]
    name: String,
    op: String,
    trace_id: protocol::TraceId,
    parent_span_id: Option<protocol::SpanId>,
    span_id: protocol::SpanId,
    sampled: Option<bool>,
    #[cfg(feature = "client")]
    incoming_trace: Option<IncomingTrace>,
    custom: Option<CustomTransactionContext>,
}

impl TransactionContext {
    /// Creates a new Transaction Context with the given `name` and `op`. A random
    /// `trace_id` is assigned. Use [`TransactionContext::new_with_trace_id`] to
    /// specify a custom trace ID.
    ///
    /// See <https://docs.sentry.io/platforms/native/enriching-events/transaction-name/>
    /// for an explanation of a Transaction's `name`, and
    /// <https://develop.sentry.dev/sdk/performance/span-operations/> for conventions
    /// around an `operation`'s value.
    ///
    /// See also the [`TransactionContext::continue_from_headers`] function that
    /// can be used for distributed tracing.
    #[must_use = "this must be used with `start_transaction`"]
    pub fn new(name: &str, op: &str) -> Self {
        Self::new_with_trace_id(name, op, protocol::TraceId::default())
    }

    /// Creates a new Transaction Context with the given `name`, `op`, and `trace_id`.
    ///
    /// See <https://docs.sentry.io/platforms/native/enriching-events/transaction-name/>
    /// for an explanation of a Transaction's `name`, and
    /// <https://develop.sentry.dev/sdk/performance/span-operations/> for conventions
    /// around an `operation`'s value.
    #[must_use = "this must be used with `start_transaction`"]
    pub fn new_with_trace_id(name: &str, op: &str, trace_id: protocol::TraceId) -> Self {
        Self {
            name: name.into(),
            op: op.into(),
            trace_id,
            parent_span_id: None,
            span_id: Default::default(),
            sampled: None,
            #[cfg(feature = "client")]
            incoming_trace: None,
            custom: None,
        }
    }

    /// Creates a new Transaction Context with the given `name`, `op`, `trace_id`, and
    /// possibly the given `span_id` and `parent_span_id`.
    ///
    /// See <https://docs.sentry.io/platforms/native/enriching-events/transaction-name/>
    /// for an explanation of a Transaction's `name`, and
    /// <https://develop.sentry.dev/sdk/performance/span-operations/> for conventions
    /// around an `operation`'s value.
    #[must_use = "this must be used with `start_transaction`"]
    pub fn new_with_details(
        name: &str,
        op: &str,
        trace_id: protocol::TraceId,
        span_id: Option<protocol::SpanId>,
        parent_span_id: Option<protocol::SpanId>,
    ) -> Self {
        let mut slf = Self::new_with_trace_id(name, op, trace_id);
        if let Some(span_id) = span_id {
            slf.span_id = span_id;
        }
        slf.parent_span_id = parent_span_id;
        slf
    }

    /// Creates a new Transaction Context based on the distributed tracing `headers`.
    ///
    /// The `headers` in particular need to include the `sentry-trace` header,
    /// which is used to associate the transaction with a distributed trace.
    #[must_use = "this must be used with `start_transaction`"]
    pub fn continue_from_headers<'a, I: IntoIterator<Item = (&'a str, &'a str)>>(
        name: &str,
        op: &str,
        headers: I,
    ) -> Self {
        TracePropagationContext::try_from_headers(headers)
            .map(|context| Self::continue_from_trace_propagation_context(name, op, &context, None))
            .unwrap_or_else(|_| Self {
                name: name.into(),
                op: op.into(),
                trace_id: Default::default(),
                parent_span_id: None,
                span_id: Default::default(),
                sampled: None,
                #[cfg(feature = "client")]
                incoming_trace: None,
                custom: None,
            })
    }

    /// Creates a new Transaction Context based on the provided distributed tracing data,
    /// optionally creating the `TransactionContext` with the provided `span_id`.
    #[deprecated = "use `TransactionContext::continue_from_trace_propagation_context` instead"]
    #[expect(deprecated, reason = "backwards-compatible method")]
    pub fn continue_from_sentry_trace(
        name: &str,
        op: &str,
        sentry_trace: &SentryTrace,
        span_id: Option<SpanId>,
    ) -> Self {
        let context = (*sentry_trace).into();
        Self::continue_from_trace_propagation_context(name, op, &context, span_id)
    }

    /// Creates a new Transaction Context based on the provided trace propagation context,
    /// optionally creating the `TransactionContext` with the provided `span_id`.
    pub fn continue_from_trace_propagation_context(
        name: &str,
        op: &str,
        context: &TracePropagationContext,
        span_id: Option<SpanId>,
    ) -> Self {
        let &TracePropagationContext {
            trace_id,
            span_id: context_span_id,
            sampled,
            #[cfg(feature = "client")]
            org_id,
        } = context;

        Self {
            name: name.into(),
            op: op.into(),
            trace_id,
            parent_span_id: Some(context_span_id),
            sampled,
            #[cfg(feature = "client")]
            incoming_trace: Some(IncomingTrace { org_id }),
            span_id: span_id.unwrap_or_default(),
            custom: None,
        }
    }

    /// 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,
                    inner.tracing_state.trace_sampled(),
                )
            }
            TransactionOrSpan::Span(span) => {
                let trace_sampled = span.tracing_state.trace_sampled();
                let span = span.span.lock().unwrap();
                (span.trace_id, span.span_id, trace_sampled)
            }
        };

        Self {
            name: name.into(),
            op: op.into(),
            trace_id,
            parent_span_id: Some(parent_span_id),
            span_id: protocol::SpanId::default(),
            sampled,
            #[cfg(feature = "client")]
            incoming_trace: None,
            custom: None,
        }
    }

    /// Set the sampling decision for this Transaction.
    ///
    /// This can be either an explicit boolean flag, or [`None`], which leaves
    /// the decision to the configured traces sampling strategy.
    #[expect(clippy::impl_trait_in_params, reason = "existed before lint enabled")]
    pub fn set_sampled(&mut self, sampled: impl Into<Option<bool>>) {
        self.sampled = sampled.into();
    }

    /// Get the sampling decision for this Transaction.
    pub fn sampled(&self) -> Option<bool> {
        self.sampled
    }

    /// Get the name of this Transaction.
    pub fn name(&self) -> &str {
        &self.name
    }

    /// Get the operation of this Transaction.
    pub fn operation(&self) -> &str {
        &self.op
    }

    /// Get the Trace ID of this Transaction.
    pub fn trace_id(&self) -> protocol::TraceId {
        self.trace_id
    }

    /// Get the Span ID of this Transaction.
    pub fn span_id(&self) -> protocol::SpanId {
        self.span_id
    }

    /// Get the custom context of this Transaction.
    pub fn custom(&self) -> Option<&CustomTransactionContext> {
        self.custom.as_ref()
    }

    /// Update the custom context of this Transaction.
    ///
    /// For simply adding a key, use the `custom_insert` method.
    pub fn custom_mut(&mut self) -> &mut Option<CustomTransactionContext> {
        &mut self.custom
    }

    /// Inserts a key-value pair into the custom context.
    ///
    /// If the context did not have this key present, None is returned.
    ///
    /// If the context did have this key present, the value is updated, and the old value is
    /// returned.
    pub fn custom_insert(
        &mut self,
        key: String,
        value: serde_json::Value,
    ) -> Option<serde_json::Value> {
        // Get the custom context
        let mut custom = None;
        std::mem::swap(&mut self.custom, &mut custom);

        // Initialise the context, if not used yet
        let mut custom = custom.unwrap_or_default();

        // And set our key
        let existing_value = custom.insert(key, value);
        self.custom = Some(custom);
        existing_value
    }

    /// Creates a transaction context builder initialized with the given `name` and `op`.
    ///
    /// See <https://docs.sentry.io/platforms/native/enriching-events/transaction-name/>
    /// for an explanation of a Transaction's `name`, and
    /// <https://develop.sentry.dev/sdk/performance/span-operations/> for conventions
    /// around an `operation`'s value.
    #[must_use]
    pub fn builder(name: &str, op: &str) -> TransactionContextBuilder {
        TransactionContextBuilder {
            ctx: TransactionContext::new(name, op),
        }
    }

    /// Clears incoming trace state so the transaction starts a new trace.
    #[cfg(feature = "client")]
    fn reject_incoming_trace(&mut self) {
        (
            self.trace_id,
            self.parent_span_id,
            self.sampled,
            self.incoming_trace,
        ) = Default::default();
    }
}

/// A transaction context builder created by [`TransactionContext::builder`].
pub struct TransactionContextBuilder {
    ctx: TransactionContext,
}

impl TransactionContextBuilder {
    /// Defines the name of the transaction.
    #[must_use]
    pub fn with_name(mut self, name: String) -> Self {
        self.ctx.name = name;
        self
    }

    /// Defines the operation of the transaction.
    #[must_use]
    pub fn with_op(mut self, op: String) -> Self {
        self.ctx.op = op;
        self
    }

    /// Defines the trace ID.
    #[must_use]
    pub fn with_trace_id(mut self, trace_id: protocol::TraceId) -> Self {
        self.ctx.trace_id = trace_id;
        self
    }

    /// Defines a parent span ID for the created transaction.
    #[must_use]
    pub fn with_parent_span_id(mut self, parent_span_id: Option<protocol::SpanId>) -> Self {
        self.ctx.parent_span_id = parent_span_id;
        self
    }

    /// Defines the span ID to be used when creating the transaction.
    #[must_use]
    pub fn with_span_id(mut self, span_id: protocol::SpanId) -> Self {
        self.ctx.span_id = span_id;
        self
    }

    /// Defines whether the transaction will be sampled.
    #[must_use]
    pub fn with_sampled(mut self, sampled: Option<bool>) -> Self {
        self.ctx.sampled = sampled;
        self
    }

    /// Adds a custom key and value to the transaction context.
    #[must_use]
    pub fn with_custom(mut self, key: String, value: serde_json::Value) -> Self {
        self.ctx.custom_insert(key, value);
        self
    }

    /// Finishes building a transaction.
    pub fn finish(self) -> TransactionContext {
        self.ctx
    }
}

/// A function to be run for each new transaction, to determine the rate at which
/// it should be sampled.
///
/// This function may choose to respect the sampling of the parent transaction (`ctx.sampled`)
/// or ignore it.
pub type TracesSampler = dyn Fn(&TransactionContext) -> f32 + Send + Sync;

// global API types:

/// A wrapper that groups a [`Transaction`] and a [`Span`] together.
#[derive(Clone, Debug, PartialEq)]
pub enum TransactionOrSpan {
    /// A [`Transaction`].
    Transaction(Transaction),
    /// A [`Span`].
    Span(Span),
}

impl From<Transaction> for TransactionOrSpan {
    fn from(transaction: Transaction) -> Self {
        Self::Transaction(transaction)
    }
}

impl From<Span> for TransactionOrSpan {
    fn from(span: Span) -> Self {
        Self::Span(span)
    }
}

impl TransactionOrSpan {
    /// Set some extra information to be sent with this Transaction/Span.
    pub fn set_data(&self, key: &str, value: protocol::Value) {
        match self {
            TransactionOrSpan::Transaction(transaction) => transaction.set_data(key, value),
            TransactionOrSpan::Span(span) => span.set_data(key, value),
        }
    }

    /// Sets a tag to a specific value.
    pub fn set_tag<V: ToString>(&self, key: &str, value: V) {
        match self {
            TransactionOrSpan::Transaction(transaction) => transaction.set_tag(key, value),
            TransactionOrSpan::Span(span) => span.set_tag(key, value),
        }
    }

    /// Get the TransactionContext of the Transaction/Span.
    ///
    /// Note that this clones the underlying value.
    pub fn get_trace_context(&self) -> protocol::TraceContext {
        match self {
            TransactionOrSpan::Transaction(transaction) => transaction.get_trace_context(),
            TransactionOrSpan::Span(span) => span.get_trace_context(),
        }
    }

    /// Set the status of the Transaction/Span.
    pub fn get_status(&self) -> Option<protocol::SpanStatus> {
        match self {
            TransactionOrSpan::Transaction(transaction) => transaction.get_status(),
            TransactionOrSpan::Span(span) => span.get_status(),
        }
    }

    /// Set the status of the Transaction/Span.
    pub fn set_status(&self, status: protocol::SpanStatus) {
        match self {
            TransactionOrSpan::Transaction(transaction) => transaction.set_status(status),
            TransactionOrSpan::Span(span) => span.set_status(status),
        }
    }

    /// Set the operation for this Transaction/Span.
    pub fn set_op(&self, op: &str) {
        match self {
            TransactionOrSpan::Transaction(transaction) => transaction.set_op(op),
            TransactionOrSpan::Span(span) => span.set_op(op),
        }
    }

    /// Set the name (description) for this Transaction/Span.
    pub fn set_name(&self, name: &str) {
        match self {
            TransactionOrSpan::Transaction(transaction) => transaction.set_name(name),
            TransactionOrSpan::Span(span) => span.set_name(name),
        }
    }

    /// Set the HTTP request information for this Transaction/Span.
    pub fn set_request(&self, request: protocol::Request) {
        match self {
            TransactionOrSpan::Transaction(transaction) => transaction.set_request(request),
            TransactionOrSpan::Span(span) => span.set_request(request),
        }
    }

    /// Returns the headers needed for distributed tracing.
    /// Use [`crate::Scope::iter_trace_propagation_headers`] to obtain the active
    /// trace's distributed tracing headers.
    pub fn iter_headers(&self) -> TraceHeadersIter {
        match self {
            TransactionOrSpan::Transaction(transaction) => transaction.iter_headers(),
            TransactionOrSpan::Span(span) => span.iter_headers(),
        }
    }

    /// Get the sampling decision for this Transaction/Span.
    ///
    /// The returned `bool` does not fully represent the sampling state of this
    /// Transaction/Span. Although `true` reliably indicates that the
    /// Transaction/Span is sampled, a value of `false` can mean either that the
    /// Transaction/Span is not sampled, or that tracing is disabled and the
    /// sampling decision is deferred. This method therefore should no longer be
    /// used, especially not for trace continuation purposes.
    ///
    /// For trace propagation, use [`Self::iter_headers`] or
    /// [`crate::Scope::iter_trace_propagation_headers`] instead, to ensure
    /// correct results.
    #[deprecated = "the returned value may not accurately represent the sampling decision"]
    pub fn is_sampled(&self) -> bool {
        match self {
            TransactionOrSpan::Transaction(transaction) =>
            {
                #[expect(deprecated)]
                transaction.is_sampled()
            }
            TransactionOrSpan::Span(span) =>
            {
                #[expect(deprecated)]
                span.is_sampled()
            }
        }
    }

    /// Starts a new child Span with the given `op` and `description`.
    ///
    /// The span must be explicitly finished via [`Span::finish`], as it will
    /// otherwise not be sent to Sentry.
    #[must_use = "a span must be explicitly closed via `finish()`"]
    pub fn start_child(&self, op: &str, description: &str) -> Span {
        match self {
            TransactionOrSpan::Transaction(transaction) => transaction.start_child(op, description),
            TransactionOrSpan::Span(span) => span.start_child(op, description),
        }
    }

    /// Starts a new child Span with the given `op`, `description` and `id`.
    ///
    /// The span must be explicitly finished via [`Span::finish`], as it will
    /// otherwise not be sent to Sentry.
    #[must_use = "a span must be explicitly closed via `finish()`"]
    pub fn start_child_with_details(
        &self,
        op: &str,
        description: &str,
        id: SpanId,
        timestamp: SystemTime,
    ) -> Span {
        match self {
            TransactionOrSpan::Transaction(transaction) => {
                transaction.start_child_with_details(op, description, id, timestamp)
            }
            TransactionOrSpan::Span(span) => {
                span.start_child_with_details(op, description, id, timestamp)
            }
        }
    }

    #[cfg(feature = "client")]
    pub(crate) fn apply_to_event(&self, event: &mut protocol::Event<'_>) {
        if event.contexts.contains_key("trace") {
            return;
        }

        let context = match self {
            TransactionOrSpan::Transaction(transaction) => {
                transaction.inner.lock().unwrap().context.clone()
            }
            TransactionOrSpan::Span(span) => {
                let span = span.span.lock().unwrap();
                protocol::TraceContext {
                    span_id: span.span_id,
                    trace_id: span.trace_id,
                    ..Default::default()
                }
            }
        };
        event.contexts.insert("trace".into(), context.into());
    }

    /// Finishes the Transaction/Span with the provided end timestamp.
    ///
    /// This records the end timestamp and either sends the inner [`Transaction`]
    /// directly to Sentry, or adds the [`Span`] to its transaction.
    pub fn finish_with_timestamp(self, timestamp: SystemTime) {
        match self {
            TransactionOrSpan::Transaction(transaction) => {
                transaction.finish_with_timestamp(timestamp)
            }
            TransactionOrSpan::Span(span) => span.finish_with_timestamp(timestamp),
        }
    }

    /// Finishes the Transaction/Span.
    ///
    /// This records the current timestamp as the end timestamp and either sends the inner [`Transaction`]
    /// directly to Sentry, or adds the [`Span`] to its transaction.
    pub fn finish(self) {
        match self {
            TransactionOrSpan::Transaction(transaction) => transaction.finish(),
            TransactionOrSpan::Span(span) => span.finish(),
        }
    }
}

#[derive(Debug)]
pub(crate) struct TransactionInner {
    #[cfg(feature = "client")]
    client: Option<Arc<Client>>,
    tracing_state: TracingState,
    pub(crate) context: protocol::TraceContext,
    pub(crate) transaction: Option<protocol::Transaction<'static>>,
}

type TransactionArc = Arc<Mutex<TransactionInner>>;

/// Functional implementation of how a new transaction's sample rate is chosen.
///
/// Returns `None` when tracing is disabled.
#[cfg(feature = "client")]
fn transaction_sample_rate(
    traces_sampling_strategy: &TracesSamplingStrategy,
    ctx: &TransactionContext,
) -> Option<f32> {
    match traces_sampling_strategy {
        &TracesSamplingStrategy::FixedRate(rate) => Some(ctx.sampled.map_or(rate, f32::from)),
        TracesSamplingStrategy::Function(traces_sampler) => Some(traces_sampler(ctx)),
        TracesSamplingStrategy::Disabled => None,
    }
}

#[cfg(feature = "client")]
fn should_continue_trace(
    incoming: Option<OrganizationId>,
    sdk: Option<OrganizationId>,
    strict: bool,
) -> bool {
    match (incoming, sdk) {
        (Some(incoming), Some(sdk)) => incoming == sdk,
        (Some(_), None) | (None, Some(_)) => !strict,
        (None, None) => true,
    }
}

/// Determine whether the new transaction should be sampled.
#[cfg(feature = "client")]
impl Client {
    /// Determines the [`TracingState`] based on the provided [`TransactionContext`].
    ///
    /// This function performs random sampling according to the appropriate sample rate as needed.
    fn determine_tracing_state(&self, ctx: &TransactionContext) -> TracingState {
        let client_options = self.options();
        match transaction_sample_rate(&client_options.traces_sampling_strategy, ctx) {
            // A return value of Some(_) indicates tracing is enabled.
            Some(sample_rate) => {
                let sampled = self.sample_should_send(sample_rate);
                TracingState::new_enabled(sampled, sample_rate)
            }
            // A return value of None indicates tracing is disabled.
            None => TracingState::new_disabled(ctx.sampled),
        }
    }
}

/// A running Performance Monitoring Transaction.
///
/// The transaction needs to be explicitly finished via [`Transaction::finish`],
/// otherwise neither the transaction nor any of its child spans will be sent
/// to Sentry.
#[derive(Clone, Debug)]
pub struct Transaction {
    pub(crate) inner: TransactionArc,
}

/// Iterable for a transaction's [data attributes](protocol::TraceContext::data).
pub struct TransactionData<'a>(MutexGuard<'a, TransactionInner>);

impl<'a> TransactionData<'a> {
    /// Iterate over the [data attributes](protocol::TraceContext::data)
    /// associated with this [transaction][protocol::Transaction].
    ///
    /// If the transaction is not sampled for sending,
    /// the metadata will not be populated at all,
    /// so the produced iterator is empty.
    pub fn iter(&self) -> Box<dyn Iterator<Item = (&String, &protocol::Value)> + '_> {
        if self.0.transaction.is_some() {
            Box::new(self.0.context.data.iter())
        } else {
            Box::new(std::iter::empty())
        }
    }

    /// Set a data attribute to be sent with this Transaction.
    pub fn set_data(&mut self, key: Cow<'a, str>, value: protocol::Value) {
        if self.0.transaction.is_some() {
            self.0.context.data.insert(key.into(), value);
        }
    }

    /// Set a tag to be sent with this Transaction.
    pub fn set_tag(&mut self, key: Cow<'_, str>, value: String) {
        if let Some(transaction) = self.0.transaction.as_mut() {
            transaction.tags.insert(key.into(), value);
        }
    }
}

impl Transaction {
    #[cfg(feature = "client")]
    fn new(client: Option<Arc<Client>>, mut ctx: TransactionContext) -> Self {
        let (tracing_state, transaction) = match client.as_ref() {
            Some(client) => {
                let options = client.options();
                let sdk_org_id = options.org_id.or_else(|| options.dsn.as_ref()?.org_id());

                if ctx.incoming_trace.is_some_and(
                    |IncomingTrace {
                         org_id: incoming_org_id,
                     }| {
                        !should_continue_trace(
                            incoming_org_id,
                            sdk_org_id,
                            options.strict_trace_continuation,
                        )
                    },
                ) {
                    ctx.reject_incoming_trace();
                }

                (
                    client.determine_tracing_state(&ctx),
                    Some(protocol::Transaction {
                        name: Some(ctx.name),
                        ..Default::default()
                    }),
                )
            }
            None => (TracingState::new_disabled(ctx.sampled), None),
        };

        let context = protocol::TraceContext {
            trace_id: ctx.trace_id,
            parent_span_id: ctx.parent_span_id,
            span_id: ctx.span_id,
            op: Some(ctx.op),
            ..Default::default()
        };

        Self {
            inner: Arc::new(Mutex::new(TransactionInner {
                client,
                tracing_state,
                context,
                transaction,
            })),
        }
    }

    #[cfg(not(feature = "client"))]
    fn new_noop(ctx: TransactionContext) -> Self {
        let context = protocol::TraceContext {
            trace_id: ctx.trace_id,
            parent_span_id: ctx.parent_span_id,
            op: Some(ctx.op),
            ..Default::default()
        };
        let tracing_state = TracingState::new_disabled(ctx.sampled);

        Self {
            inner: Arc::new(Mutex::new(TransactionInner {
                tracing_state,
                context,
                transaction: None,
            })),
        }
    }

    /// Set a data attribute to be sent with this Transaction.
    pub fn set_data(&self, key: &str, value: protocol::Value) {
        let mut inner = self.inner.lock().unwrap();
        if inner.transaction.is_some() {
            inner.context.data.insert(key.into(), value);
        }
    }

    /// Set some extra information to be sent with this Transaction.
    pub fn set_extra(&self, key: &str, value: protocol::Value) {
        let mut inner = self.inner.lock().unwrap();
        if let Some(transaction) = inner.transaction.as_mut() {
            transaction.extra.insert(key.into(), value);
        }
    }

    /// Sets a tag to a specific value.
    pub fn set_tag<V: ToString>(&self, key: &str, value: V) {
        let mut inner = self.inner.lock().unwrap();
        if let Some(transaction) = inner.transaction.as_mut() {
            transaction.tags.insert(key.into(), value.to_string());
        }
    }

    /// Returns an iterating accessor to the transaction's
    /// [data attributes](protocol::TraceContext::data).
    ///
    /// # Concurrency
    /// In order to obtain any kind of reference to the `TraceContext::data` field,
    /// a `Mutex` needs to be locked. The returned `TransactionData` holds on to this lock
    /// for as long as it lives. Therefore you must take care not to keep the returned
    /// `TransactionData` around too long or it will never relinquish the lock and you may run into
    /// a deadlock.
    pub fn data(&self) -> TransactionData<'_> {
        TransactionData(self.inner.lock().unwrap())
    }

    /// Get the TransactionContext of the Transaction.
    ///
    /// Note that this clones the underlying value.
    pub fn get_trace_context(&self) -> protocol::TraceContext {
        let inner = self.inner.lock().unwrap();
        inner.context.clone()
    }

    /// Get the status of the Transaction.
    pub fn get_status(&self) -> Option<protocol::SpanStatus> {
        let inner = self.inner.lock().unwrap();
        inner.context.status
    }

    /// Set the status of the Transaction.
    pub fn set_status(&self, status: protocol::SpanStatus) {
        let mut inner = self.inner.lock().unwrap();
        inner.context.status = Some(status);
    }

    /// Set the operation of the Transaction.
    pub fn set_op(&self, op: &str) {
        let mut inner = self.inner.lock().unwrap();
        inner.context.op = Some(op.to_string());
    }

    /// Set the name of the Transaction.
    pub fn set_name(&self, name: &str) {
        let mut inner = self.inner.lock().unwrap();
        if let Some(transaction) = inner.transaction.as_mut() {
            transaction.name = Some(name.to_string());
        }
    }

    /// Set the HTTP request information for this Transaction.
    pub fn set_request(&self, request: protocol::Request) {
        let mut inner = self.inner.lock().unwrap();
        if let Some(transaction) = inner.transaction.as_mut() {
            transaction.request = Some(request);
        }
    }

    /// Sets the origin for this transaction, indicating what created it.
    pub fn set_origin(&self, origin: &str) {
        let mut inner = self.inner.lock().unwrap();
        inner.context.origin = Some(origin.to_owned());
    }

    /// Returns the headers needed for distributed tracing.
    /// Use [`crate::Scope::iter_trace_propagation_headers`] to obtain the active
    /// trace's distributed tracing headers.
    pub fn iter_headers(&self) -> TraceHeadersIter {
        let inner = self.inner.lock().unwrap();
        let trace = TracePropagationContext::new(inner.context.trace_id, inner.context.span_id)
            .with_maybe_sampled(inner.tracing_state.trace_sampled());
        TraceHeadersIter {
            sentry_trace: Some(trace.sentry_trace_header()),
        }
    }

    /// Get the sampling decision for this Transaction.
    ///
    /// The returned `bool` does not fully represent the Transaction's sampling
    /// state. Although `true` reliably indicates that the Transaction is
    /// sampled, a value of `false` can mean either that the Transaction is not
    /// sampled, or that tracing is disabled and the sampling decision is
    /// deferred. This method therefore should no longer be used, especially not
    /// for trace continuation purposes.
    ///
    /// For trace propagation, use [`Self::iter_headers`] or
    /// [`crate::Scope::iter_trace_propagation_headers`] instead, to ensure
    /// correct results.
    #[deprecated = "the returned value may not accurately represent the sampling decision"]
    pub fn is_sampled(&self) -> bool {
        // Checking that we have a `Send` finish action should at least roughly match the old
        // behavior of this function: we only return true for sampled spans when tracing is
        // enabled, and false otherwise.
        #[cfg(feature = "client")]
        {
            matches!(
                self.inner.lock().unwrap().tracing_state.finish_action(),
                FinishAction::Send { .. }
            )
        }

        #[cfg(not(feature = "client"))]
        false
    }

    /// Finishes the Transaction with the provided end timestamp.
    ///
    /// This records the end timestamp and sends the transaction together with
    /// all finished child spans to Sentry.
    pub fn finish_with_timestamp(self, _timestamp: SystemTime) {
        with_client_impl! {{
            let mut inner = self.inner.lock().unwrap();

            if let (Some(mut transaction), Some(client)) = (inner.transaction.take(), inner.client.take()) {
                match inner.tracing_state.finish_action() {
                    FinishAction::Send { sample_rate } => {
                        transaction.finish_with_timestamp(_timestamp);
                        transaction
                            .contexts
                            .insert("trace".into(), inner.context.clone().into());

                        Hub::current().with_current_scope(|scope| scope.apply_to_transaction(&mut transaction));
                        let opts = client.options();
                        transaction.release.clone_from(&opts.release);
                        transaction.environment.clone_from(&opts.environment);
                        transaction.sdk = Some(std::borrow::Cow::Owned(client.sdk_info.clone()));
                        transaction.server_name.clone_from(&opts.server_name);

                        let mut dsc = protocol::DynamicSamplingContext::new()
                            .with_trace_id(inner.context.trace_id)
                            .with_sample_rate(sample_rate)
                            .with_sampled(true);
                        if let Some(public_key) = client.dsn().map(|dsn| dsn.public_key()) {
                            dsc = dsc.with_public_key(public_key.to_owned());
                        }

                        drop(inner);

                        let mut envelope = protocol::Envelope::new().with_headers(
                            protocol::EnvelopeHeaders::new().with_trace(dsc)
                        );
                        envelope.add_item(transaction);

                        client.send_envelope(envelope);
                    },
                    FinishAction::Discard => {
                        client.record_lost_data(&transaction, ClientReportReason::SampleRate);
                    },
                    FinishAction::Ignore => (),
                }
            }
        }}
    }

    /// Finishes the Transaction.
    ///
    /// This records the current timestamp as the end timestamp and sends the transaction together with
    /// all finished child spans to Sentry.
    pub fn finish(self) {
        self.finish_with_timestamp(SystemTime::now());
    }

    /// Starts a new child Span with the given `op` and `description`.
    ///
    /// The span must be explicitly finished via [`Span::finish`].
    #[must_use = "a span must be explicitly closed via `finish()`"]
    pub fn start_child(&self, op: &str, description: &str) -> Span {
        let inner = self.inner.lock().unwrap();
        let span = protocol::Span {
            trace_id: inner.context.trace_id,
            parent_span_id: Some(inner.context.span_id),
            op: Some(op.into()),
            description: if description.is_empty() {
                None
            } else {
                Some(description.into())
            },
            ..Default::default()
        };
        Span {
            transaction: Arc::clone(&self.inner),
            tracing_state: inner.tracing_state,
            span: Arc::new(Mutex::new(span)),
        }
    }

    /// Starts a new child Span with the given `op` and `description`.
    ///
    /// The span must be explicitly finished via [`Span::finish`].
    #[must_use = "a span must be explicitly closed via `finish()`"]
    pub fn start_child_with_details(
        &self,
        op: &str,
        description: &str,
        id: SpanId,
        timestamp: SystemTime,
    ) -> Span {
        let inner = self.inner.lock().unwrap();
        let span = protocol::Span {
            trace_id: inner.context.trace_id,
            parent_span_id: Some(inner.context.span_id),
            op: Some(op.into()),
            description: if description.is_empty() {
                None
            } else {
                Some(description.into())
            },
            span_id: id,
            start_timestamp: timestamp,
            ..Default::default()
        };
        Span {
            transaction: Arc::clone(&self.inner),
            tracing_state: inner.tracing_state,
            span: Arc::new(Mutex::new(span)),
        }
    }
}

impl PartialEq for Transaction {
    fn eq(&self, other: &Self) -> bool {
        Arc::ptr_eq(&self.inner, &other.inner)
    }
}

/// A smart pointer to a span's [`data` field](protocol::Span::data).
pub struct Data<'a>(MutexGuard<'a, protocol::Span>);

impl Data<'_> {
    /// Set some extra information to be sent with this Span.
    pub fn set_data(&mut self, key: String, value: protocol::Value) {
        self.0.data.insert(key, value);
    }

    /// Set some tag to be sent with this Span.
    pub fn set_tag(&mut self, key: String, value: String) {
        self.0.tags.insert(key, value);
    }
}

impl Deref for Data<'_> {
    type Target = BTreeMap<String, protocol::Value>;

    fn deref(&self) -> &Self::Target {
        &self.0.data
    }
}

impl DerefMut for Data<'_> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0.data
    }
}

/// A running Performance Monitoring Span.
///
/// The span needs to be explicitly finished via [`Span::finish`], otherwise it
/// will not be sent to Sentry.
#[derive(Clone, Debug)]
pub struct Span {
    pub(crate) transaction: TransactionArc,
    tracing_state: TracingState,
    span: SpanArc,
}

type SpanArc = Arc<Mutex<protocol::Span>>;

impl Span {
    /// Set some extra information to be sent with this Transaction.
    pub fn set_data(&self, key: &str, value: protocol::Value) {
        let mut span = self.span.lock().unwrap();
        span.data.insert(key.into(), value);
    }

    /// Sets a tag to a specific value.
    pub fn set_tag<V: ToString>(&self, key: &str, value: V) {
        let mut span = self.span.lock().unwrap();
        span.tags.insert(key.into(), value.to_string());
    }

    /// Returns a smart pointer to the span's [`data` field](protocol::Span::data).
    ///
    /// Since [`Data`] implements `Deref` and `DerefMut`, this can be used to read and mutate
    /// the span data.
    ///
    /// # Concurrency
    /// In order to obtain any kind of reference to the `data` field,
    /// a `Mutex` needs to be locked. The returned `Data` holds on to this lock
    /// for as long as it lives. Therefore you must take care not to keep the returned
    /// `Data` around too long or it will never relinquish the lock and you may run into
    /// a deadlock.
    pub fn data(&self) -> Data<'_> {
        Data(self.span.lock().unwrap())
    }

    /// Get the TransactionContext of the Span.
    ///
    /// Note that this clones the underlying value.
    pub fn get_trace_context(&self) -> protocol::TraceContext {
        let transaction = self.transaction.lock().unwrap();
        transaction.context.clone()
    }

    /// Get the current span ID.
    pub fn get_span_id(&self) -> protocol::SpanId {
        let span = self.span.lock().unwrap();
        span.span_id
    }

    /// Get the status of the Span.
    pub fn get_status(&self) -> Option<protocol::SpanStatus> {
        let span = self.span.lock().unwrap();
        span.status
    }

    /// Set the status of the Span.
    pub fn set_status(&self, status: protocol::SpanStatus) {
        let mut span = self.span.lock().unwrap();
        span.status = Some(status);
    }

    /// Set the operation of the Span.
    pub fn set_op(&self, op: &str) {
        let mut span = self.span.lock().unwrap();
        span.op = Some(op.to_string());
    }

    /// Set the name (description) of the Span.
    pub fn set_name(&self, name: &str) {
        let mut span = self.span.lock().unwrap();
        span.description = Some(name.to_string());
    }

    /// Set the HTTP request information for this Span.
    pub fn set_request(&self, request: protocol::Request) {
        let mut span = self.span.lock().unwrap();
        // Extract values from the request to be used as data in the span.
        if let Some(method) = request.method {
            span.data.insert("method".into(), method.into());
        }
        if let Some(url) = request.url {
            span.data.insert("url".into(), url.to_string().into());
        }
        if let Some(data) = request.data {
            if let Ok(data) = serde_json::from_str::<serde_json::Value>(&data) {
                span.data.insert("data".into(), data);
            } else {
                span.data.insert("data".into(), data.into());
            }
        }
        if let Some(query_string) = request.query_string {
            span.data.insert("query_string".into(), query_string.into());
        }
        if let Some(cookies) = request.cookies {
            span.data.insert("cookies".into(), cookies.into());
        }
        if !request.headers.is_empty() {
            if let Ok(headers) = serde_json::to_value(request.headers) {
                span.data.insert("headers".into(), headers);
            }
        }
        if !request.env.is_empty() {
            if let Ok(env) = serde_json::to_value(request.env) {
                span.data.insert("env".into(), env);
            }
        }
    }

    /// Returns the headers needed for distributed tracing.
    /// Use [`crate::Scope::iter_trace_propagation_headers`] to obtain the active
    /// trace's distributed tracing headers.
    pub fn iter_headers(&self) -> TraceHeadersIter {
        let span = self.span.lock().unwrap();
        let trace = TracePropagationContext::new(span.trace_id, span.span_id)
            .with_maybe_sampled(self.tracing_state.trace_sampled());

        TraceHeadersIter {
            sentry_trace: Some(trace.sentry_trace_header()),
        }
    }

    /// Get the sampling decision for this Span.
    ///
    /// The returned `bool` does not fully represent the Span's sampling state.
    /// Although `true` reliably indicates that the Span is sampled, a value of
    /// `false` can mean either that the Span is not sampled, or that tracing is
    /// disabled and the sampling decision is deferred. This method therefore
    /// should no longer be used, especially not for trace continuation purposes.
    ///
    /// For trace propagation, use [`Self::iter_headers`] or
    /// [`crate::Scope::iter_trace_propagation_headers`] instead, to ensure
    /// correct results.
    #[deprecated = "the returned value may not accurately represent the sampling decision"]
    pub fn is_sampled(&self) -> bool {
        // Checking that we have a `Send` finish action should at least roughly match the old
        // behavior of this function: we only return true for sampled spans when tracing is
        // enabled, and false otherwise.
        #[cfg(feature = "client")]
        {
            matches!(
                self.tracing_state.finish_action(),
                FinishAction::Send { .. }
            )
        }

        #[cfg(not(feature = "client"))]
        false
    }

    /// Finishes the Span with the provided end timestamp.
    ///
    /// This will record the end timestamp and add the span to the transaction
    /// in which it was started.
    pub fn finish_with_timestamp(self, _timestamp: SystemTime) {
        with_client_impl! {{
            let mut span = self.span.lock().unwrap();
            if span.timestamp.is_some() {
                // the span was already finished
                return;
            }
            span.finish_with_timestamp(_timestamp);
            let mut inner = self.transaction.lock().unwrap();
            // Disabled traces do not retain finished spans or report span losses.
            if matches!(inner.tracing_state.finish_action(), FinishAction::Ignore) {
                return;
            }
            if let Some(transaction) = inner.transaction.as_mut() {
                if transaction.spans.len() <= MAX_SPANS {
                    transaction.spans.push(span.clone());
                } else if let Some(client) = inner.client.as_ref() {
                    client.record_lost_data(&*span, ClientReportReason::BufferOverflow);
                }
            }
        }}
    }

    /// Finishes the Span.
    ///
    /// This will record the current timestamp as the end timestamp and add the span to the
    /// transaction in which it was started.
    pub fn finish(self) {
        self.finish_with_timestamp(SystemTime::now());
    }

    /// Starts a new child Span with the given `op` and `description`.
    ///
    /// The span must be explicitly finished via [`Span::finish`].
    #[must_use = "a span must be explicitly closed via `finish()`"]
    pub fn start_child(&self, op: &str, description: &str) -> Span {
        let span = self.span.lock().unwrap();
        let span = protocol::Span {
            trace_id: span.trace_id,
            parent_span_id: Some(span.span_id),
            op: Some(op.into()),
            description: if description.is_empty() {
                None
            } else {
                Some(description.into())
            },
            ..Default::default()
        };
        Span {
            transaction: self.transaction.clone(),
            tracing_state: self.tracing_state,
            span: Arc::new(Mutex::new(span)),
        }
    }

    /// Starts a new child Span with the given `op` and `description`.
    ///
    /// The span must be explicitly finished via [`Span::finish`].
    #[must_use = "a span must be explicitly closed via `finish()`"]
    fn start_child_with_details(
        &self,
        op: &str,
        description: &str,
        id: SpanId,
        timestamp: SystemTime,
    ) -> Span {
        let span = self.span.lock().unwrap();
        let span = protocol::Span {
            trace_id: span.trace_id,
            parent_span_id: Some(span.span_id),
            op: Some(op.into()),
            description: if description.is_empty() {
                None
            } else {
                Some(description.into())
            },
            span_id: id,
            start_timestamp: timestamp,
            ..Default::default()
        };
        Span {
            transaction: self.transaction.clone(),
            tracing_state: self.tracing_state,
            span: Arc::new(Mutex::new(span)),
        }
    }
}

impl PartialEq for Span {
    fn eq(&self, other: &Self) -> bool {
        Arc::ptr_eq(&self.span, &other.span)
    }
}

/// Represents a key-value pair such as an HTTP header.
pub type TraceHeader = (&'static str, String);

/// An Iterator over HTTP header names and values needed for distributed tracing.
///
/// This currently only yields the `sentry-trace` header, but other headers
/// may be added in the future.
pub struct TraceHeadersIter {
    sentry_trace: Option<String>,
}

impl TraceHeadersIter {
    #[cfg(feature = "client")]
    pub(crate) fn new(sentry_trace: String) -> Self {
        Self {
            sentry_trace: Some(sentry_trace),
        }
    }
}

impl Iterator for TraceHeadersIter {
    type Item = (&'static str, String);

    fn next(&mut self) -> Option<Self::Item> {
        self.sentry_trace.take().map(|st| ("sentry-trace", st))
    }
}

#[cfg(test)]
mod tests {
    use std::sync::Arc;

    use super::*;

    #[test]
    fn disabled_forwards_trace_id() {
        let headers = [(
            "SenTrY-TRAce",
            "09e04486820349518ac7b5d2adbf6ba5-9cf635fa5b870b3a-1",
        )];
        let ctx = TransactionContext::continue_from_headers("noop", "noop", headers);
        let trx = start_transaction(ctx);

        let span = trx.start_child("noop", "noop");

        let header = span.iter_headers().next().unwrap().1;
        let parsed =
            TracePropagationContext::try_from_headers([("sentry-trace", header.as_str())]).unwrap();

        assert_eq!(
            &parsed.trace_id.to_string(),
            "09e04486820349518ac7b5d2adbf6ba5"
        );
        assert_eq!(parsed.sampled, Some(true));
    }

    #[test]
    fn transaction_context_public_getters() {
        let mut ctx = TransactionContext::new("test-name", "test-operation");
        assert_eq!(ctx.name(), "test-name");
        assert_eq!(ctx.operation(), "test-operation");
        assert_eq!(ctx.sampled(), None);

        ctx.set_sampled(true);
        assert_eq!(ctx.sampled(), Some(true));
    }

    #[test]
    fn continue_from_headers_stores_incoming_org_id() {
        let ctx = TransactionContext::continue_from_headers(
            "noop",
            "noop",
            [
                (
                    "sentry-trace",
                    "09e04486820349518ac7b5d2adbf6ba5-9cf635fa5b870b3a-1",
                ),
                ("baggage", "sentry-org_id=123"),
            ],
        );

        assert_eq!(
            ctx.incoming_trace.map(|incoming| incoming.org_id),
            Some(Some("123".parse().unwrap()))
        );
    }

    #[test]
    fn continue_from_headers_does_not_keep_org_id_without_sentry_trace() {
        let ctx = TransactionContext::continue_from_headers(
            "noop",
            "noop",
            [("baggage", "sentry-org_id=123")],
        );

        assert!(ctx.incoming_trace.is_none());
        assert_eq!(ctx.parent_span_id, None);
    }

    #[cfg(feature = "client")]
    #[test]
    fn compute_transaction_sample_rate() {
        let ctx = TransactionContext::new("noop", "noop");
        assert_eq!(
            transaction_sample_rate(&TracesSamplingStrategy::FixedRate(0.3), &ctx),
            Some(0.3)
        );
        assert_eq!(
            transaction_sample_rate(&TracesSamplingStrategy::FixedRate(0.7), &ctx),
            Some(0.7)
        );

        let mut ctx = TransactionContext::new("noop", "noop");
        ctx.set_sampled(true);
        assert_eq!(
            transaction_sample_rate(&TracesSamplingStrategy::FixedRate(0.3), &ctx),
            Some(1.0)
        );
        ctx.set_sampled(false);
        assert_eq!(
            transaction_sample_rate(&TracesSamplingStrategy::FixedRate(0.3), &ctx),
            Some(0.0)
        );

        let ctx = TransactionContext::new("noop", "noop");
        assert_eq!(
            transaction_sample_rate(&TracesSamplingStrategy::Disabled, &ctx),
            None
        );
        let mut ctx = TransactionContext::new("noop", "noop");
        ctx.set_sampled(true);
        assert_eq!(
            transaction_sample_rate(&TracesSamplingStrategy::Disabled, &ctx),
            None
        );
        ctx.set_sampled(false);
        assert_eq!(
            transaction_sample_rate(&TracesSamplingStrategy::Disabled, &ctx),
            None
        );

        // Function and FixedRate are mutually exclusive strategy variants. A function
        // strategy can ignore parent sampling or choose to inspect it.
        let mut ctx = TransactionContext::new("noop", "noop");
        let sampler = |_: &TransactionContext| 0.7_f32;
        let strategy = TracesSamplingStrategy::Function(Arc::new(sampler) as Arc<TracesSampler>);
        assert_eq!(transaction_sample_rate(&strategy, &ctx), Some(0.7));
        ctx.set_sampled(false);
        assert_eq!(transaction_sample_rate(&strategy, &ctx), Some(0.7));

        let sampler = |ctx: &TransactionContext| match ctx.sampled() {
            Some(true) => 0.8_f32,
            Some(false) => 0.4_f32,
            None => 0.6_f32,
        };
        let strategy = TracesSamplingStrategy::Function(Arc::new(sampler) as Arc<TracesSampler>);
        ctx.set_sampled(true);
        assert_eq!(transaction_sample_rate(&strategy, &ctx), Some(0.8));
        ctx.set_sampled(None);
        assert_eq!(transaction_sample_rate(&strategy, &ctx), Some(0.6));

        let sampler = |ctx: &TransactionContext| {
            if ctx.name() == "must-name" || ctx.operation() == "must-operation" {
                return 1.0;
            }

            if let Some(custom) = ctx.custom() {
                if let Some(rate) = custom.get("rate") {
                    if let Some(rate) = rate.as_f64() {
                        return rate as f32;
                    }
                }
            }

            0.1
        };
        let strategy = TracesSamplingStrategy::Function(Arc::new(sampler) as Arc<TracesSampler>);
        let ctx = TransactionContext::new("noop", "must-operation");
        assert_eq!(transaction_sample_rate(&strategy, &ctx), Some(1.0));
        let ctx = TransactionContext::new("must-name", "noop");
        assert_eq!(transaction_sample_rate(&strategy, &ctx), Some(1.0));
        let mut ctx = TransactionContext::new("noop", "noop");
        ctx.custom_insert("rate".to_owned(), serde_json::json!(0.7));
        assert_eq!(transaction_sample_rate(&strategy, &ctx), Some(0.7));
    }
}