feat(mep): Introduce the count_web_vitals functions to metrics (#32507)

- These are the equivalent metrics function versions of what was added
  in discover

Author: wmak

src/sentry/search/events/builder.py

@@ -1468,7 +1468,7 @@ def column(self, name: str) -> Column:
         try:
             return super().column(name)
         except InvalidSearchQuery:
-            raise IncompatibleMetricsQuery("Column was not found in metrics indexer")
+            raise IncompatibleMetricsQuery(f"Column {name} was not found in metrics indexer")
 
     def aliased_column(self, name: str) -> SelectType:
         try:

src/sentry/search/events/datasets/metrics.py

@@ -126,6 +126,16 @@ def function_converter(self) -> Mapping[str, fields.MetricsFunction]:
                     ),
                     default_result_type="integer",
                 ),
+                fields.MetricsFunction(
+                    "count_web_vitals",
+                    required_args=[
+                        fields.FunctionArg("column"),
+                        fields.SnQLStringArg("quality", allowed_strings=["good", "meh", "poor"]),
+                    ],
+                    calculated_args=[resolve_metric_id],
+                    snql_distribution=self._resolve_web_vital_function,
+                    default_result_type="integer",
+                ),
                 fields.MetricsFunction(
                     "epm",
                     snql_distribution=lambda args, alias: Function(
@@ -223,6 +233,7 @@ def _event_type_converter(self, search_filter: SearchFilter) -> Optional[WhereTy
 
         raise IncompatibleMetricsQuery("Can only filter event.type:transaction")
 
+    # Query Functions
     def _resolve_failure_count(
         self,
         _: Mapping[str, Union[str, Column, SelectType, int, float]],
@@ -276,3 +287,47 @@ def _resolve_percentile(
             ],
             alias,
         )
+
+    def _resolve_web_vital_function(
+        self,
+        args: Mapping[str, Union[str, Column, SelectType, int, float]],
+        alias: str,
+    ) -> SelectType:
+        column = args["column"]
+        metric_id = args["metric_id"]
+        quality = args["quality"].lower()
+
+        if column not in [
+            "measurements.lcp",
+            "measurements.fcp",
+            "measurements.fp",
+            "measurements.fid",
+            "measurements.cls",
+        ]:
+            raise InvalidSearchQuery("count_web_vitals only supports measurements")
+
+        measurement_rating = self.builder.resolve_column("measurement_rating")
+
+        quality_id = indexer.resolve(quality)
+        if quality_id is None:
+            return Function(
+                # This matches the type from doing `select toTypeName(count()) ...` from clickhouse
+                "toUInt64",
+                [0],
+                alias,
+            )
+
+        return Function(
+            "countIf",
+            [
+                Column("value"),
+                Function(
+                    "and",
+                    [
+                        Function("equals", [measurement_rating, quality_id]),
+                        Function("equals", [Column("metric_id"), metric_id]),
+                    ],
+                ),
+            ],
+            alias,
+        )

src/sentry/testutils/cases.py

@@ -1101,6 +1101,7 @@ class MetricsEnhancedPerformanceTestCase(SessionMetricsTestCase, TestCase):
     ENTITY_MAP = {
         "transaction.duration": "metrics_distributions",
         "measurements.lcp": "metrics_distributions",
+        "measurements.fp": "metrics_distributions",
         "measurements.fcp": "metrics_distributions",
         "measurements.fid": "metrics_distributions",
         "measurements.cls": "metrics_distributions",

tests/snuba/api/endpoints/test_organization_events_v2.py

@@ -4951,7 +4951,15 @@ def test_count_web_vitals_invalid_vital(self):
 
 
 class OrganizationEventsMetricsEnhancedPerformanceEndpointTest(MetricsEnhancedPerformanceTestCase):
-    METRIC_STRINGS = ["foo_transaction", "bar_transaction", "staging"]
+    # Poor intentionally omitted for test_measurement_rating_that_does_not_exist
+    METRIC_STRINGS = [
+        "foo_transaction",
+        "bar_transaction",
+        "staging",
+        "measurement_rating",
+        "good",
+        "meh",
+    ]
 
     def setUp(self):
         super().setUp()
@@ -5171,3 +5179,121 @@ def test_performance_homepage_query(self):
         assert data["p75_measurements_fid"] == 3.0
         assert data["p75_measurements_cls"] == 4.0
         assert response.data["meta"]["isMetricsData"]
+
+    def test_measurement_rating(self):
+        self.store_metric(
+            50,
+            metric="measurements.lcp",
+            tags={"measurement_rating": "good", "transaction": "foo_transaction"},
+            timestamp=self.min_ago,
+        )
+        self.store_metric(
+            15,
+            metric="measurements.fp",
+            tags={"measurement_rating": "good", "transaction": "foo_transaction"},
+            timestamp=self.min_ago,
+        )
+        self.store_metric(
+            1500,
+            metric="measurements.fcp",
+            tags={"measurement_rating": "meh", "transaction": "foo_transaction"},
+            timestamp=self.min_ago,
+        )
+        self.store_metric(
+            125,
+            metric="measurements.fid",
+            tags={"measurement_rating": "meh", "transaction": "foo_transaction"},
+            timestamp=self.min_ago,
+        )
+        self.store_metric(
+            0.15,
+            metric="measurements.cls",
+            tags={"measurement_rating": "good", "transaction": "foo_transaction"},
+            timestamp=self.min_ago,
+        )
+
+        response = self.do_request(
+            {
+                "field": [
+                    "transaction",
+                    "count_web_vitals(measurements.lcp, good)",
+                    "count_web_vitals(measurements.fp, good)",
+                    "count_web_vitals(measurements.fcp, meh)",
+                    "count_web_vitals(measurements.fid, meh)",
+                    "count_web_vitals(measurements.cls, good)",
+                ],
+                "query": "event.type:transaction",
+                "metricsEnhanced": "1",
+                "per_page": 50,
+            }
+        )
+        assert response.status_code == 200, response.content
+        assert len(response.data["data"]) == 1
+        assert response.data["meta"]["isMetricsData"]
+        assert response.data["data"][0]["count_web_vitals_measurements_lcp_good"] == 1
+        assert response.data["data"][0]["count_web_vitals_measurements_fp_good"] == 1
+        assert response.data["data"][0]["count_web_vitals_measurements_fcp_meh"] == 1
+        assert response.data["data"][0]["count_web_vitals_measurements_fid_meh"] == 1
+        assert response.data["data"][0]["count_web_vitals_measurements_cls_good"] == 1
+
+    def test_measurement_rating_that_does_not_exist(self):
+        self.store_metric(
+            1,
+            metric="measurements.lcp",
+            tags={"measurement_rating": "good", "transaction": "foo_transaction"},
+            timestamp=self.min_ago,
+        )
+
+        response = self.do_request(
+            {
+                "field": ["transaction", "count_web_vitals(measurements.lcp, poor)"],
+                "query": "event.type:transaction",
+                "metricsEnhanced": "1",
+                "per_page": 50,
+            }
+        )
+        assert response.status_code == 200, response.content
+        assert len(response.data["data"]) == 1
+        assert response.data["meta"]["isMetricsData"]
+        assert response.data["data"][0]["count_web_vitals_measurements_lcp_poor"] == 0
+
+    def test_count_web_vitals_invalid_vital(self):
+        query = {
+            "field": [
+                "count_web_vitals(measurements.foo, poor)",
+            ],
+            "project": [self.project.id],
+            "metricsEnhanced": "1",
+        }
+        response = self.do_request(query)
+        assert response.status_code == 400, response.content
+
+        query = {
+            "field": [
+                "count_web_vitals(tags[lcp], poor)",
+            ],
+            "project": [self.project.id],
+            "metricsEnhanced": "1",
+        }
+        response = self.do_request(query)
+        assert response.status_code == 400, response.content
+
+        query = {
+            "field": [
+                "count_web_vitals(transaction.duration, poor)",
+            ],
+            "project": [self.project.id],
+            "metricsEnhanced": "1",
+        }
+        response = self.do_request(query)
+        assert response.status_code == 400, response.content
+
+        query = {
+            "field": [
+                "count_web_vitals(measurements.lcp, bad)",
+            ],
+            "project": [self.project.id],
+            "metricsEnhanced": "1",
+        }
+        response = self.do_request(query)
+        assert response.status_code == 400, response.content