feat(errors): Events API backend - Add error upsampling aggregation functions (#95940)

Events API now supports new sample_count(), sample_eps() and sample_epm() function columns in Discover for error upsampling projects, which return the original non extrapolated versions of these functions.

Author: yuvmen

src/sentry/api/bases/organization_events.py

@@ -18,7 +18,10 @@
 from sentry.api.base import CURSOR_LINK_HEADER
 from sentry.api.bases import NoProjects
 from sentry.api.bases.organization import FilterParamsDateNotNull, OrganizationEndpoint
-from sentry.api.helpers.error_upsampling import are_any_projects_error_upsampled
+from sentry.api.helpers.error_upsampling import (
+    are_any_projects_error_upsampled,
+    convert_fields_for_upsampling,
+)
 from sentry.api.helpers.mobile import get_readable_device_name
 from sentry.api.helpers.teams import get_teams
 from sentry.api.serializers.snuba import SnubaTSResultSerializer
@@ -425,30 +428,14 @@ def handle_data(
 
     def handle_error_upsampling(self, project_ids: Sequence[int], results: dict[str, Any]):
         """
-        If the query is for error upsampled projects, we need to rename the fields to include the ()
-        and update the data and meta fields to reflect the new field names. This works around a limitation in
-        how aliases are handled in the SnQL parser.
+        If the query is for error upsampled projects, we convert various functions under the hood.
+        We need to rename these fields before returning the results to the client, to hide the conversion.
+        This is done here to work around a limitation in how aliases are handled in the SnQL parser.
         """
         if are_any_projects_error_upsampled(project_ids):
             data = results.get("data", [])
             fields_meta = results.get("meta", {}).get("fields", {})
-
-            function_conversions = {
-                "upsampled_count()": "count()",
-                "upsampled_eps()": "eps()",
-                "upsampled_epm()": "epm()",
-            }
-
-            # Go over each both data and meta, and convert function names to the non-upsampled version
-            for upsampled_function, count_function in function_conversions.items():
-                for result in data:
-                    if upsampled_function in result:
-                        result[count_function] = result[upsampled_function]
-                        del result[upsampled_function]
-
-                if upsampled_function in fields_meta:
-                    fields_meta[count_function] = fields_meta[upsampled_function]
-                    del fields_meta[upsampled_function]
+            convert_fields_for_upsampling(data, fields_meta)
 
     def handle_issues(
         self, results: Sequence[Any], project_ids: Sequence[int], organization: Organization

src/sentry/api/helpers/error_upsampling.py

@@ -10,6 +10,57 @@
 
 UPSAMPLED_ERROR_AGGREGATION = "upsampled_count"
 
+# Function key conversions for error upsampling results
+_FUNCTION_KEY_CONVERSIONS = {
+    "count()": "sample_count()",
+    "eps()": "sample_eps()",
+    "epm()": "sample_epm()",
+    "upsampled_count()": "count()",
+    "upsampled_eps()": "eps()",
+    "upsampled_epm()": "epm()",
+}
+
+# Pre-computed ordered keys to handle conversion conflicts
+# Keys that are targets of other conversions must be processed first
+_conversion_targets = set(_FUNCTION_KEY_CONVERSIONS.values())
+_ORDERED_CONVERSION_KEYS = sorted(
+    _FUNCTION_KEY_CONVERSIONS.keys(), key=lambda k: k not in _conversion_targets
+)
+
+
+def convert_fields_for_upsampling(data: list[dict[str, Any]], fields_meta: dict[str, str]) -> None:
+    """
+    Convert field names in query results for error upsampled projects.
+    This renames upsampled_* functions to their standard names and standard functions
+    to sample_* equivalents to hide the conversion from the client.
+
+    Args:
+        data: List of result dictionaries to modify in-place
+        fields_meta: Meta fields dictionary to modify in-place
+    """
+    # Collect keys that need conversion and exist in data
+    all_present_keys: set[str] = set()
+    for result in data:
+        all_present_keys.update(result.keys())
+
+    # Filter the pre-ordered list to only include keys actually present
+    keys_to_convert = [key for key in _ORDERED_CONVERSION_KEYS if key in all_present_keys]
+
+    # Apply conversions to data
+    for result in data:
+        for original_key in keys_to_convert:
+            if original_key in result:
+                converted_key = _FUNCTION_KEY_CONVERSIONS[original_key]
+                result[converted_key] = result[original_key]
+                del result[original_key]
+
+    # Apply conversions to fields_meta
+    for original_key in keys_to_convert:
+        if original_key in fields_meta:
+            converted_key = _FUNCTION_KEY_CONVERSIONS[original_key]
+            fields_meta[converted_key] = fields_meta[original_key]
+            del fields_meta[original_key]
+
 
 def is_errors_query_for_error_upsampled_projects(
     snuba_params: SnubaParams,
@@ -55,6 +106,9 @@ def transform_query_columns_for_error_upsampling(
         "count()": "upsampled_count()",
         "eps()": "upsampled_eps()",
         "epm()": "upsampled_epm()",
+        "sample_count()": "count()",
+        "sample_eps()": "eps()",
+        "sample_epm()": "epm()",
     }
 
     transformed_columns = []

tests/snuba/api/endpoints/test_organization_events.py

@@ -6822,6 +6822,161 @@ def test_error_upsampling_with_partial_allowlist(self):
             # Expect upsampling since any project is allowlisted (both events upsampled: 10 + 10 = 20)
             assert response.data["data"][0]["count()"] == 20
 
+    def test_sample_count_with_allowlisted_project(self):
+        """Test that sample_count() returns raw sample count (not upsampled) for allowlisted projects."""
+        # Set up allowlisted project
+        with self.options({"issues.client_error_sampling.project_allowlist": [self.project.id]}):
+            # Store error event with error_sampling context
+            self.store_event(
+                data={
+                    "event_id": "a" * 32,
+                    "message": "Error event for sample_count",
+                    "type": "error",
+                    "exception": [{"type": "ValueError", "value": "Something went wrong"}],
+                    "timestamp": self.ten_mins_ago_iso,
+                    "fingerprint": ["group1"],
+                    "contexts": {"error_sampling": {"client_sample_rate": 0.1}},
+                },
+                project_id=self.project.id,
+            )
+
+            # Store error event without error_sampling context (sample_weight = null should count as 1)
+            self.store_event(
+                data={
+                    "event_id": "a1" * 16,
+                    "message": "Error event without sampling",
+                    "type": "error",
+                    "exception": [{"type": "ValueError", "value": "Something else went wrong"}],
+                    "timestamp": self.ten_mins_ago_iso,
+                    "fingerprint": ["group1_no_sampling"],
+                },
+                project_id=self.project.id,
+            )
+
+            # Test with errors dataset - sample_count() should return raw count, not upsampled
+            query = {
+                "field": ["sample_count()"],
+                "statsPeriod": "2h",
+                "query": "event.type:error",
+                "dataset": "errors",
+            }
+            response = self.do_request(query)
+            assert response.status_code == 200, response.content
+            # Expect sample_count to return raw count: 2 events (not upsampled 11)
+            assert response.data["data"][0]["sample_count()"] == 2
+
+            # Check meta information
+            meta = response.data["meta"]
+            assert "fields" in meta
+            assert "sample_count()" in meta["fields"]
+            assert meta["fields"]["sample_count()"] == "integer"
+
+    def test_sample_eps_with_allowlisted_project(self):
+        """Test that sample_eps() returns raw sample rate (not upsampled) for allowlisted projects."""
+        # Set up allowlisted project
+        with self.options({"issues.client_error_sampling.project_allowlist": [self.project.id]}):
+            # Store error event with error_sampling context
+            self.store_event(
+                data={
+                    "event_id": "b" * 32,
+                    "message": "Error event for sample_eps",
+                    "type": "error",
+                    "exception": [{"type": "ValueError", "value": "Something went wrong"}],
+                    "timestamp": self.ten_mins_ago_iso,
+                    "fingerprint": ["group2"],
+                    "contexts": {"error_sampling": {"client_sample_rate": 0.1}},
+                },
+                project_id=self.project.id,
+            )
+
+            # Store error event without error_sampling context (sample_weight = null should count as 1)
+            self.store_event(
+                data={
+                    "event_id": "b1" * 16,
+                    "message": "Error event without sampling for sample_eps",
+                    "type": "error",
+                    "exception": [{"type": "ValueError", "value": "Something else went wrong"}],
+                    "timestamp": self.ten_mins_ago_iso,
+                    "fingerprint": ["group2_no_sampling"],
+                },
+                project_id=self.project.id,
+            )
+
+            # Test with errors dataset - sample_eps() should return raw rate, not upsampled
+            query = {
+                "field": ["sample_eps()"],
+                "statsPeriod": "2h",
+                "query": "event.type:error",
+                "dataset": "errors",
+            }
+            response = self.do_request(query)
+            assert response.status_code == 200, response.content
+            # Expect sample_eps to return raw rate: 2 events / 7200 seconds = 2/7200
+            expected_sample_eps = 2 / 7200
+            actual_sample_eps = response.data["data"][0]["sample_eps()"]
+            assert (
+                abs(actual_sample_eps - expected_sample_eps) < 0.0001
+            )  # Allow small rounding differences
+
+            # Check meta information
+            meta = response.data["meta"]
+            assert "fields" in meta
+            assert "sample_eps()" in meta["fields"]
+            assert meta["fields"]["sample_eps()"] == "rate"
+
+    def test_sample_epm_with_allowlisted_project(self):
+        """Test that sample_epm() returns raw sample rate (not upsampled) for allowlisted projects."""
+        # Set up allowlisted project
+        with self.options({"issues.client_error_sampling.project_allowlist": [self.project.id]}):
+            # Store error event with error_sampling context
+            self.store_event(
+                data={
+                    "event_id": "c" * 32,
+                    "message": "Error event for sample_epm",
+                    "type": "error",
+                    "exception": [{"type": "ValueError", "value": "Something went wrong"}],
+                    "timestamp": self.ten_mins_ago_iso,
+                    "fingerprint": ["group3"],
+                    "contexts": {"error_sampling": {"client_sample_rate": 0.1}},
+                },
+                project_id=self.project.id,
+            )
+
+            # Store error event without error_sampling context (sample_weight = null should count as 1)
+            self.store_event(
+                data={
+                    "event_id": "c1" * 16,
+                    "message": "Error event without sampling for sample_epm",
+                    "type": "error",
+                    "exception": [{"type": "ValueError", "value": "Something else went wrong"}],
+                    "timestamp": self.ten_mins_ago_iso,
+                    "fingerprint": ["group3_no_sampling"],
+                },
+                project_id=self.project.id,
+            )
+
+            # Test with errors dataset - sample_epm() should return raw rate, not upsampled
+            query = {
+                "field": ["sample_epm()"],
+                "statsPeriod": "2h",
+                "query": "event.type:error",
+                "dataset": "errors",
+            }
+            response = self.do_request(query)
+            assert response.status_code == 200, response.content
+            # Expect sample_epm to return raw rate: 2 events / 120 minutes = 2/120
+            expected_sample_epm = 2 / 120
+            actual_sample_epm = response.data["data"][0]["sample_epm()"]
+            assert (
+                abs(actual_sample_epm - expected_sample_epm) < 0.001
+            )  # Allow small rounding differences
+
+            # Check meta information
+            meta = response.data["meta"]
+            assert "fields" in meta
+            assert "sample_epm()" in meta["fields"]
+            assert meta["fields"]["sample_epm()"] == "rate"
+
     def test_is_status(self):
         self.store_event(
             data={