feat(metric-stats): Add additional tags to metric stats metrics

Author: Dav1dde

relay-cardinality/src/config.rs

@@ -77,6 +77,19 @@ pub enum CardinalityScope {
     Unknown,
 }
 
+impl CardinalityScope {
+    /// Returns the string representation of this scope.
+    pub fn as_str(self) -> &'static str {
+        match self {
+            CardinalityScope::Organization => "organization",
+            CardinalityScope::Project => "project",
+            CardinalityScope::Type => "type",
+            CardinalityScope::Name => "name",
+            CardinalityScope::Unknown => "unknown",
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

relay-server/src/metric_stats.rs

@@ -129,6 +129,7 @@ impl MetricStats {
 
         let mut tags = BTreeMap::from([
             ("mri".to_owned(), bucket.name.to_string()),
+            ("mri.type".to_owned(), bucket.value.ty().to_string()),
             ("mri.namespace".to_owned(), namespace.to_string()),
             (
                 "outcome.id".to_owned(),
@@ -160,22 +161,30 @@ impl MetricStats {
             return None;
         }
 
-        let name = report.metric_name.as_ref()?;
-        let namespace = name.namespace();
-
-        if !namespace.has_metric_stats() {
-            return None;
-        }
-
-        let tags = BTreeMap::from([
-            ("mri".to_owned(), name.to_string()),
-            ("mri.namespace".to_owned(), namespace.to_string()),
+        let mut tags = BTreeMap::from([
+            ("cardinality.limit".to_owned(), limit.id.clone()),
+            (
+                "cardinality.scope".to_owned(),
+                limit.scope.as_str().to_owned(),
+            ),
             (
                 "cardinality.window".to_owned(),
                 limit.window.window_seconds.to_string(),
             ),
         ]);
 
+        if let Some(ref name) = report.metric_name {
+            tags.insert("mri".to_owned(), name.to_string());
+            tags.insert("mri.namespace".to_owned(), name.namespace().to_string());
+            if let Some(t) = name.try_type() {
+                tags.insert("mri.type".to_owned(), t.to_string());
+            }
+        }
+
+        if let Some(t) = report.metric_type {
+            tags.insert("mri.type".to_owned(), t.to_string());
+        }
+
         Some(Bucket {
             timestamp: UnixTimestamp::now(),
             width: 0,
@@ -190,7 +199,9 @@ impl MetricStats {
 #[cfg(test)]
 mod tests {
     use relay_base_schema::project::{ProjectId, ProjectKey};
+    use relay_cardinality::{CardinalityScope, SlidingWindow};
     use relay_dynamic_config::GlobalConfig;
+    use relay_metrics::MetricType;
     use relay_quotas::ReasonCode;
     use tokio::sync::mpsc::UnboundedReceiver;
 
@@ -265,6 +276,7 @@ mod tests {
             bucket.tags,
             tags!(
                 ("mri", "d:custom/rt@millisecond"),
+                ("mri.type", "d"),
                 ("mri.namespace", "custom"),
                 ("outcome.id", "0"),
             )
@@ -285,6 +297,7 @@ mod tests {
             bucket.tags,
             tags!(
                 ("mri", "d:custom/rt@millisecond"),
+                ("mri.type", "d"),
                 ("mri.namespace", "custom"),
                 ("outcome.id", "2"),
                 ("outcome.reason", "foobar"),
@@ -294,6 +307,132 @@ mod tests {
         assert!(receiver.blocking_recv().is_none());
     }
 
+    #[test]
+    fn test_metric_stats_cardinality_name() {
+        let (ms, mut receiver) = create_metric_stats(1.0);
+
+        let scoping = scoping();
+        let limit = CardinalityLimit {
+            id: "test".to_owned(),
+            passive: false,
+            report: true,
+            window: SlidingWindow {
+                window_seconds: 246,
+                granularity_seconds: 123,
+            },
+            limit: 99,
+            scope: CardinalityScope::Name,
+            namespace: None,
+        };
+        let report = CardinalityReport {
+            organization_id: Some(scoping.organization_id),
+            project_id: Some(scoping.project_id),
+            metric_type: None,
+            metric_name: Some(MetricName::from("d:custom/rt@millisecond")),
+            cardinality: 12,
+        };
+
+        ms.track_cardinality(scoping, &limit, &report);
+
+        drop(ms);
+
+        let Aggregator::MergeBuckets(mb) = receiver.blocking_recv().unwrap() else {
+            panic!();
+        };
+        assert_eq!(mb.project_key(), scoping.project_key);
+
+        let mut buckets = mb.buckets();
+        assert_eq!(buckets.len(), 1);
+        let bucket = buckets.pop().unwrap();
+
+        assert_eq!(&*bucket.name, "g:metric_stats/cardinality@none");
+        assert_eq!(
+            bucket.value,
+            BucketValue::Gauge(GaugeValue {
+                last: 12.into(),
+                min: 12.into(),
+                max: 12.into(),
+                sum: 12.into(),
+                count: 1,
+            })
+        );
+        assert_eq!(
+            bucket.tags,
+            tags!(
+                ("mri", "d:custom/rt@millisecond"),
+                ("mri.type", "d"),
+                ("mri.namespace", "custom"),
+                ("cardinality.limit", "test"),
+                ("cardinality.scope", "name"),
+                ("cardinality.window", "246"),
+            )
+        );
+
+        assert!(receiver.blocking_recv().is_none());
+    }
+
+    #[test]
+    fn test_metric_stats_cardinality_type() {
+        let (ms, mut receiver) = create_metric_stats(1.0);
+
+        let scoping = scoping();
+        let limit = CardinalityLimit {
+            id: "test".to_owned(),
+            passive: false,
+            report: true,
+            window: SlidingWindow {
+                window_seconds: 246,
+                granularity_seconds: 123,
+            },
+            limit: 99,
+            scope: CardinalityScope::Type,
+            namespace: None,
+        };
+        let report = CardinalityReport {
+            organization_id: Some(scoping.organization_id),
+            project_id: Some(scoping.project_id),
+            metric_type: Some(MetricType::Distribution),
+            metric_name: None,
+            cardinality: 12,
+        };
+
+        ms.track_cardinality(scoping, &limit, &report);
+
+        drop(ms);
+
+        let Aggregator::MergeBuckets(mb) = receiver.blocking_recv().unwrap() else {
+            panic!();
+        };
+        assert_eq!(mb.project_key(), scoping.project_key);
+
+        let mut buckets = mb.buckets();
+        assert_eq!(buckets.len(), 1);
+        let bucket = buckets.pop().unwrap();
+
+        assert_eq!(&*bucket.name, "g:metric_stats/cardinality@none");
+        assert_eq!(
+            bucket.value,
+            BucketValue::Gauge(GaugeValue {
+                last: 12.into(),
+                min: 12.into(),
+                max: 12.into(),
+                sum: 12.into(),
+                count: 1,
+            })
+        );
+        assert_eq!(
+            bucket.tags,
+            tags!(
+                ("mri.type", "d"),
+                ("cardinality.limit", "test"),
+                ("cardinality.scope", "type"),
+                ("cardinality.window", "246"),
+            )
+        );
+
+        assert!(receiver.blocking_recv().is_none());
+    }
+
     #[test]
     fn test_metric_stats_rollout_rate_disabled() {
         let (ms, mut receiver) = create_metric_stats(0.0);