fix: Everything

Author: jan-auer

relay-server/src/actors/processor.rs

@@ -32,7 +32,7 @@ use relay_log::LogError;
 use relay_metrics::{Bucket, Metric};
 use relay_quotas::{DataCategory, RateLimits, ReasonCode};
 use relay_redis::RedisPool;
-use relay_sampling::RuleId;
+use relay_sampling::{DynamicSamplingContext, RuleId};
 use relay_statsd::metric;
 
 use crate::actors::envelopes::{EnvelopeManager, SendEnvelope, SendEnvelopeError, SubmitEnvelope};
@@ -344,6 +344,30 @@ fn outcome_from_profile_error(err: relay_profiling::ProfileError) -> Outcome {
     Outcome::Invalid(discard_reason)
 }
 
+fn track_sampling_metrics(
+    project_state: &ProjectState,
+    context: &DynamicSamplingContext,
+    event: &Event,
+) {
+    // We only collect this metric for the root transaction event, so ignore secondary projects.
+    if !project_state.is_matching_key(context.public_key) {
+        return;
+    }
+
+    let is_unstable = event.transaction.value() != context.transaction.as_ref();
+    let in_dsc = context.transaction.is_some();
+    let in_payload = event.transaction.value().is_some();
+
+    metric!(
+        counter(RelayCounters::DynamicSamplingRootTransaction) += 1,
+        match = if is_unstable { "mismatch" } else { "match" },
+        dsc = if in_dsc { "some" } else { "none" },
+        payload = if in_payload { "some" } else { "none" },
+        source = &event.get_transaction_source().to_string(),
+        platform = event.platform.as_str().unwrap_or("other"),
+    );
+}
+
 /// Synchronous service for processing envelopes.
 pub struct EnvelopeProcessor {
     config: Arc<Config>,
@@ -1599,6 +1623,10 @@ impl EnvelopeProcessor {
                 }
             );
             state.transaction_metrics_extracted = true;
+
+            if let Some(context) = state.envelope.sampling_context() {
+                track_sampling_metrics(&state.project_state, context, event);
+            }
         }
         Ok(())
     }

relay-server/src/utils/dynamic_sampling.rs

@@ -7,27 +7,19 @@ use relay_general::protocol::Event;
 use relay_sampling::{
     pseudo_random_from_uuid, DynamicSamplingContext, RuleId, SamplingConfig, SamplingRule,
 };
-use relay_statsd::metric;
 
 use crate::actors::project::ProjectState;
 use crate::envelope::{Envelope, ItemType};
-use crate::statsd::{RelayCounters, RelayTimers};
 
-macro_rules! some_or {
-    ($e:expr, $fallback:expr) => {
+macro_rules! or_ok_none {
+    ($e:expr) => {
         match $e {
             Some(x) => x,
-            None => $fallback,
+            None => return Ok(None),
         }
     };
 }
 
-macro_rules! or_ok_none {
-    ($e:expr) => {
-        some_or!($e, return Ok(None))
-    };
-}
-
 /// The result of a sampling operation.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum SamplingResult {
@@ -133,32 +125,6 @@ pub fn should_keep_event(
     SamplingResult::Keep
 }
 
-fn track_sampling_metrics(
-    sampling_context: Option<&DynamicSamplingContext>,
-    event: Option<&Event>,
-    project_state: &ProjectState,
-    sampling_project_state: Option<&ProjectState>,
-) {
-    let sampling_context = some_or!(sampling_context, return);
-    let event = some_or!(event, return);
-    let sampling_project_state = some_or!(sampling_project_state, return);
-
-    if sampling_project_state.project_id != project_state.project_id {
-        return;
-    }
-
-    let is_unstable_transaction_name = event.transaction.value() != sampling_context.transaction;
-    let dsc_has_transaction_name = sampling_context.transaction.is_some();
-    let event_has_transaction_name = event.transaction.value().is_some();
-
-    metric!(
-        counter(RelayCounters::DynamicSamplingRootTransaction) += 1,
-        is_unstable_transaction_name = is_unstable_transaction_name,
-        dsc_has_transaction_name = dsc_has_transaction_name,
-        event_has_transaction_name = event_has_transaction_name,
-    );
-}
-
 /// Returns the project key defined in the `trace` header of the envelope, if defined.
 /// If there are no transactions in the envelope, we return None here, because there is nothing
 /// to sample by trace.