feat(metrics): Add ability to compute metrics summary and attach it to events

relay-event-schema/src/protocol/metrics_summary.rs

@@ -1,6 +1,7 @@
 #[cfg(feature = "jsonschema")]
 use relay_jsonschema_derive::JsonSchema;
 use relay_protocol::{Annotated, Array, Empty, FromValue, IntoValue, Object};
+use std::collections::BTreeMap;
 
 use crate::processor::ProcessValue;
 
@@ -12,10 +13,39 @@ pub type MetricSummaryMapping = Object<Array<MetricSummary>>;
 pub struct MetricsSummary(pub MetricSummaryMapping);
 
 impl MetricsSummary {
+    /// Returns an empty [`MetricsSummary`].
+    pub fn empty() -> MetricsSummary {
+        MetricsSummary(BTreeMap::new())
+    }
+
     /// Combinator to modify the contained metric summaries.
     pub fn update_value<F: FnOnce(MetricSummaryMapping) -> MetricSummaryMapping>(&mut self, f: F) {
         self.0 = f(std::mem::take(&mut self.0));
     }
+
+    /// Merges a [`MetricsSummary`] into itself.
+    ///
+    /// The merge operation concatenates tags of the same metric even if they are identical for the
+    /// sake of simplicity. This doesn't cause issues for us, under the assumption that the two
+    /// summaries do not have overlapping metric names (which is the case for us since summaries
+    /// computed by the SDKs have metric names that are different from the ones we generate in
+    /// Relay).
+    ///
+    /// Do not use this function to merge any arbitrary [`MetricsSummary`]s.
+    pub fn merge(&mut self, metrics_summary: MetricsSummary) {
+        for (metric_name, metrics) in metrics_summary.0 {
+            let original_metrics = self.0.entry(metric_name).or_insert(Annotated::new(vec![]));
+            match (original_metrics.value_mut(), metrics.0) {
+                (Some(original_metrics), Some(metrics)) => {
+                    original_metrics.extend(metrics);
+                }
+                (None, Some(metrics)) => {
+                    original_metrics.set_value(Some(metrics));
+                }
+                _ => {}
+            }
+        }
+    }
 }
 
 /// The metric summary of a single metric that is emitted by the SDK.

relay-server/src/metrics_extraction/event.rs

@@ -1,10 +1,11 @@
 use relay_common::time::UnixTimestamp;
 use relay_dynamic_config::CombinedMetricExtractionConfig;
-use relay_event_schema::protocol::{Event, Span};
+use relay_event_schema::protocol::{Event, MetricsSummary, Span};
 use relay_metrics::Bucket;
 use relay_quotas::DataCategory;
 
 use crate::metrics_extraction::generic::{self, Extractable};
+use crate::metrics_extraction::metrics_summary;
 use crate::services::processor::extract_transaction_span;
 use crate::statsd::RelayTimers;
 use crate::utils::sample;
@@ -46,7 +47,7 @@ impl Extractable for Span {
 ///
 /// If this is a transaction event with spans, metrics will also be extracted from the spans.
 pub fn extract_metrics(
-    event: &Event,
+    event: &mut Event,
     spans_extracted: bool,
     config: CombinedMetricExtractionConfig<'_>,
     max_tag_value_size: usize,
@@ -64,20 +65,33 @@ pub fn extract_metrics(
 }
 
 fn extract_span_metrics_for_event(
-    event: &Event,
+    event: &mut Event,
     config: CombinedMetricExtractionConfig<'_>,
     max_tag_value_size: usize,
     output: &mut Vec<Bucket>,
 ) {
     relay_statsd::metric!(timer(RelayTimers::EventProcessingSpanMetricsExtraction), {
         if let Some(transaction_span) = extract_transaction_span(event, max_tag_value_size) {
-            output.extend(generic::extract_metrics(&transaction_span, config));
+            let metrics = generic::extract_metrics(&transaction_span, config);
+            if let Some(metrics_summary) = metrics_summary::compute(&metrics) {
+                event
+                    ._metrics_summary
+                    .get_or_insert_with(MetricsSummary::empty)
+                    .merge(metrics_summary);
+            }
+            output.extend(metrics);
         }
 
-        if let Some(spans) = event.spans.value() {
+        if let Some(spans) = event.spans.value_mut() {
             for annotated_span in spans {
-                if let Some(span) = annotated_span.value() {
-                    output.extend(generic::extract_metrics(span, config));
+                if let Some(span) = annotated_span.value_mut() {
+                    let metrics = generic::extract_metrics(span, config);
+                    if let Some(metrics_summary) = metrics_summary::compute(&metrics) {
+                        span._metrics_summary
+                            .get_or_insert_with(MetricsSummary::empty)
+                            .merge(metrics_summary);
+                    }
+                    output.extend(metrics);
                 }
             }
         }
@@ -1181,7 +1195,7 @@ mod tests {
         );
 
         extract_metrics(
-            event.value().unwrap(),
+            event.value_mut().as_mut().unwrap(),
             false,
             combined_config(features).combined(),
             200,
@@ -1383,7 +1397,7 @@ mod tests {
         );
 
         let metrics = extract_metrics(
-            event.value().unwrap(),
+            event.value_mut().as_mut().unwrap(),
             false,
             combined_config([Feature::ExtractCommonSpanMetricsFromEvent]).combined(),
             200,
@@ -1437,10 +1451,10 @@ mod tests {
             ]
         }
         "#;
-        let event = Annotated::from_json(json).unwrap();
+        let mut event = Annotated::from_json(json).unwrap();
 
         let metrics = extract_metrics(
-            event.value().unwrap(),
+            event.value_mut().as_mut().unwrap(),
             false,
             combined_config([Feature::ExtractCommonSpanMetricsFromEvent]).combined(),
             200,
@@ -1472,7 +1486,7 @@ mod tests {
         );
 
         let metrics = extract_metrics(
-            event.value().unwrap(),
+            event.value_mut().as_mut().unwrap(),
             false,
             combined_config([Feature::ExtractCommonSpanMetricsFromEvent]).combined(),
             200,
@@ -1692,10 +1706,10 @@ mod tests {
                 }
             }
             "#;
-        let event = Annotated::<Event>::from_json(event).unwrap();
+        let mut event = Annotated::<Event>::from_json(event).unwrap();
 
         let metrics = extract_metrics(
-            event.value().unwrap(),
+            event.value_mut().as_mut().unwrap(),
             false,
             combined_config([Feature::ExtractCommonSpanMetricsFromEvent]).combined(),
             200,
@@ -1722,4 +1736,117 @@ mod tests {
 
         assert_eq!(&*metrics[3].name, "d:spans/duration@millisecond");
     }
+
+    #[test]
+    fn test_metrics_summaries_on_transaction_and_spans() {
+        let mut event = Annotated::from_json(
+            r#"
+        {
+            "type": "transaction",
+            "sdk": {"name": "sentry.javascript.react-native"},
+            "start_timestamp": "2021-04-26T07:59:01+0100",
+            "timestamp": "2021-04-26T08:00:00+0100",
+            "release": "1.2.3",
+            "transaction": "gEt /api/:version/users/",
+            "transaction_info": {"source": "custom"},
+            "platform": "cocoa",
+            "contexts": {
+                "trace": {
+                    "trace_id": "ff62a8b040f340bda5d830223def1d81",
+                    "span_id": "bd429c44b67a3eb4",
+                    "op": "ui.load"
+                },
+                "device": {
+                    "family": "iOS",
+                    "model": "iPhone1,1"
+                },
+                "app": {
+                    "app_identifier": "org.reactjs.native.example.RnDiffApp",
+                    "app_name": "RnDiffApp"
+                },
+                "os": {
+                    "name": "iOS",
+                    "version": "16.2"
+                }
+            },
+            "measurements": {
+                "app_start_warm": {
+                    "value": 1.0,
+                    "unit": "millisecond"
+                }
+            },
+            "spans": [
+                {
+                    "op": "ui.load.initial_display",
+                    "span_id": "bd429c44b67a3eb2",
+                    "start_timestamp": 1597976300.0000000,
+                    "timestamp": 1597976303.0000000,
+                    "trace_id": "ff62a8b040f340bda5d830223def1d81",
+                    "data": {
+                        "frames.slow": 1,
+                        "frames.frozen": 2,
+                        "frames.total": 9,
+                        "frames.delay": 0.1
+                    },
+                    "_metrics_summary": {
+                        "d:spans/duration@millisecond": [
+                            {
+                                "min": 50.0,
+                                "max": 60.0,
+                                "sum": 100.0,
+                                "count": 2,
+                                "tags": {
+                                    "app_start_type": "warm",
+                                    "device.class": "1"
+                                }
+                            }
+                        ]
+                    }
+                }
+            ],
+            "_metrics_summary": {
+                "d:spans/duration@millisecond": [
+                    {
+                        "min": 50.0,
+                        "max": 100.0,
+                        "sum": 150.0,
+                        "count": 2,
+                        "tags": {
+                            "app_start_type": "warm",
+                            "device.class": "1"
+                        }
+                    }
+                ]
+            }
+        }
+        "#,
+        )
+        .unwrap();
+
+        // Normalize first, to make sure that all things are correct as in the real pipeline:
+        normalize_event(
+            &mut event,
+            &NormalizationConfig {
+                enrich_spans: true,
+                device_class_synthesis_config: true,
+                ..Default::default()
+            },
+        );
+
+        let _ = extract_metrics(
+            event.value_mut().as_mut().unwrap(),
+            false,
+            combined_config([Feature::ExtractCommonSpanMetricsFromEvent]).combined(),
+            200,
+            None,
+        );
+
+        insta::assert_debug_snapshot!(&event.value().unwrap()._metrics_summary);
+        insta::assert_debug_snapshot!(
+            &event.value().unwrap().spans.value().unwrap()[0]
+                .value()
+                .unwrap()
+                ._metrics_summary
+        );
+    }
 }