ref(eap-spans): add granularity to SnubaParams (#88081)

1. Add `granularity_secs` to `SnubaParams` and replace `rollup`
parameter in several functions.
2. Add `timeseries_granularity_secs` to `SnubaParams` which is used to
prevent checking `granularity_secs is not None` everywhere
3. Add `is_timeseries_request` to `SnubaParams` which is used within the
`epm` function to either divide by the overall query interval or the
granularity

Note: There is still a **ton** of usage for `rollup`, so we still have
`get_rollup` in `src/sentry/api/bases/organization_events.py`. But in an
effort to save time I tried to make the changes exclusively to the rpc
related files.

Author: DominikB2014

src/sentry/api/bases/organization_events.py

@@ -427,6 +427,7 @@ def handle_readable_device(
     def get_rollup(
         self, request: Request, snuba_params: SnubaParams, top_events: int, use_rpc: bool
     ) -> int:
+        """TODO: we should eventually rely on `SnubaParams.granularity_secs` instead"""
         try:
             rollup = get_rollup_from_request(
                 request,
@@ -497,6 +498,7 @@ def get_event_stats_data(
                         return {"data": []}
 
                 rollup = self.get_rollup(request, snuba_params, top_events, use_rpc)
+                snuba_params.granularity_secs = rollup
                 self.validate_comparison_delta(comparison_delta, snuba_params, organization)
 
                 query_columns = get_query_columns(columns, rollup)

src/sentry/api/endpoints/organization_events_stats.py

@@ -301,7 +301,6 @@ def _get_event_stats(
                         orderby=self.get_orderby(request),
                         limit=top_events,
                         referrer=referrer,
-                        granularity_secs=rollup,
                         config=SearchResolverConfig(
                             auto_fields=False,
                             use_aggregate_conditions=True,
@@ -337,7 +336,6 @@ def _get_event_stats(
                     params=snuba_params,
                     query_string=query,
                     y_axes=query_columns,
-                    granularity_secs=rollup,
                     referrer=referrer,
                     config=SearchResolverConfig(
                         auto_fields=False,

src/sentry/api/endpoints/organization_events_timeseries.py

@@ -176,6 +176,7 @@ def get(self, request: Request, organization: Organization) -> Response:
 
         self.validate_comparison_delta(comparison_delta, snuba_params, organization)
         rollup = self.get_rollup(request, snuba_params, top_events, use_rpc)
+        snuba_params.granularity_secs = rollup
         axes = request.GET.getlist("yAxis", ["count()"])
 
         with handle_query_errors():
@@ -241,7 +242,6 @@ def get_event_stats(
                     orderby=self.get_orderby(request),
                     limit=top_events,
                     referrer=referrer,
-                    granularity_secs=rollup,
                     config=SearchResolverConfig(
                         auto_fields=False,
                         use_aggregate_conditions=True,
@@ -275,7 +275,6 @@ def get_event_stats(
                 params=snuba_params,
                 query_string=query,
                 y_axes=query_columns,
-                granularity_secs=rollup,
                 referrer=referrer,
                 config=SearchResolverConfig(
                     auto_fields=False,

src/sentry/discover/compare_timeseries.py

@@ -33,7 +33,6 @@ class TSResultForComparison(TypedDict):
 def make_rpc_request(
     query: str,
     aggregate: str,
-    time_window: int,
     snuba_params: SnubaParams,
 ) -> TSResultForComparison:
     query = apply_dataset_query_conditions(SnubaQuery.Type.PERFORMANCE, query, None)
@@ -46,7 +45,6 @@ def make_rpc_request(
         query_string=query_parts["query"],
         y_axes=query_parts["selected_columns"],
         referrer=Referrer.JOB_COMPARE_TIMESERIES.value,
-        granularity_secs=time_window,
         config=SearchResolverConfig(),
     )
 
@@ -181,12 +179,12 @@ def compare_timeseries_for_alert_rule(alert_rule: AlertRule):
         organization=organization,
         start=now - timedelta(days=1),
         end=now,
+        granularity_secs=snuba_query.time_window,
     )
 
     rpc_result = make_rpc_request(
         snuba_query.query,
         snuba_query.aggregate,
-        time_window=snuba_query.time_window,
         snuba_params=snuba_params,
     )
 

src/sentry/search/eap/columns.py

@@ -26,14 +26,9 @@
 ResolvedArguments: TypeAlias = list[ResolvedArgument]
 
 
-class QuerySettings(TypedDict):
-    snuba_params: SnubaParams
-    granularity_secs: int | None
-
-
 class ResolverSettings(TypedDict):
     extrapolation_mode: ExtrapolationMode.ValueType
-    query_settings: QuerySettings
+    snuba_params: SnubaParams
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -250,7 +245,7 @@ def resolve(
         alias: str,
         search_type: constants.SearchType,
         resolved_arguments: ResolvedArguments,
-        query_settings: QuerySettings,
+        snuba_params: SnubaParams,
     ) -> ResolvedFormula | ResolvedAggregate | ResolvedConditionalAggregate:
         raise NotImplementedError()
 
@@ -269,7 +264,7 @@ def resolve(
         alias: str,
         search_type: constants.SearchType,
         resolved_arguments: ResolvedArguments,
-        query_settings: QuerySettings,
+        snuba_params: SnubaParams,
     ) -> ResolvedAggregate:
         if len(resolved_arguments) > 1:
             raise InvalidSearchQuery(
@@ -315,7 +310,7 @@ def resolve(
         alias: str,
         search_type: constants.SearchType,
         resolved_arguments: ResolvedArguments,
-        query_settings: QuerySettings,
+        snuba_params: SnubaParams,
     ) -> ResolvedConditionalAggregate:
         key, filter = self.aggregate_resolver(resolved_arguments)
         return ResolvedConditionalAggregate(
@@ -345,15 +340,15 @@ def resolve(
         alias: str,
         search_type: constants.SearchType,
         resolved_arguments: list[AttributeKey | Any],
-        query_settings: QuerySettings,
+        snuba_params: SnubaParams,
     ) -> ResolvedFormula:
         resolver_settings = ResolverSettings(
             extrapolation_mode=(
                 ExtrapolationMode.EXTRAPOLATION_MODE_SAMPLE_WEIGHTED
                 if self.extrapolation
                 else ExtrapolationMode.EXTRAPOLATION_MODE_NONE
             ),
-            query_settings=query_settings,
+            snuba_params=snuba_params,
         )
 
         return ResolvedFormula(

src/sentry/search/eap/resolver.py

@@ -40,7 +40,6 @@
     ColumnDefinitions,
     ConditionalAggregateDefinition,
     FormulaDefinition,
-    QuerySettings,
     ResolvedAggregate,
     ResolvedAttribute,
     ResolvedConditionalAggregate,
@@ -797,13 +796,10 @@ def resolve_function(self, column: str, match: Match | None = None) -> tuple[
             )
 
         resolved_function = function_definition.resolve(
-            alias,
-            search_type,
-            resolved_arguments,
-            QuerySettings(
-                snuba_params=self.params,
-                granularity_secs=self.granularity_secs,
-            ),
+            alias=alias,
+            search_type=search_type,
+            resolved_arguments=resolved_arguments,
+            snuba_params=self.params,
         )
 
         resolved_context = None

src/sentry/search/eap/spans/formulas.py

@@ -392,11 +392,13 @@ def time_spent_percentage(
 
 def epm(_: ResolvedArguments, settings: ResolverSettings) -> Column.BinaryFormula:
     extrapolation_mode = settings["extrapolation_mode"]
-    interval = settings["query_settings"]["snuba_params"].interval
-    granularity_secs = settings["query_settings"]["granularity_secs"]
+    is_timeseries_request = settings["snuba_params"].is_timeseries_request
 
-    # having a granularity_secs implies that the request is for a time series, and each datapoint should be divided by it
-    divisor = granularity_secs if granularity_secs else interval
+    divisor = (
+        settings["snuba_params"].timeseries_granularity_secs
+        if is_timeseries_request
+        else settings["snuba_params"].interval
+    )
 
     return Column.BinaryFormula(
         left=Column(

src/sentry/search/events/types.py

@@ -85,6 +85,8 @@ class SnubaParams:
     start: datetime | None = None
     end: datetime | None = None
     stats_period: str | None = None
+    # granularity is used with timeseries requests to specifiy bucket size
+    granularity_secs: int | None = None
     # The None value in this sequence is because the filter params could include that
     environments: Sequence[Environment | None] = field(default_factory=list)
     projects: Sequence[Project] = field(default_factory=list)
@@ -140,6 +142,16 @@ def rpc_end_date(self) -> Timestamp:
         timestamp.FromDatetime(self.end_date)
         return timestamp
 
+    @property
+    def timeseries_granularity_secs(self) -> int:
+        if self.granularity_secs is None:
+            raise InvalidSearchQuery("granularity is required")
+        return self.granularity_secs
+
+    @property
+    def is_timeseries_request(self) -> bool:
+        return self.granularity_secs is not None
+
     @property
     def date_range(self) -> timedelta:
         return self.end_date - self.start_date

src/sentry/seer/anomaly_detection/utils.py

@@ -269,6 +269,7 @@ def fetch_historical_data(
         end=end,
         stats_period=None,
         environments=environments,
+        granularity_secs=granularity,
     )
 
     if dataset == metrics_performance:
@@ -278,7 +279,6 @@ def fetch_historical_data(
             params=snuba_params,
             query_string=snuba_query.query,
             y_axes=query_columns,
-            granularity_secs=granularity,
             referrer=(
                 Referrer.ANOMALY_DETECTION_HISTORICAL_DATA_QUERY.value
                 if is_store_data_request

src/sentry/snuba/entity_subscription.py

@@ -271,6 +271,7 @@ def build_rpc_request(
             organization=Organization.objects.get_from_cache(id=self.org_id),
             start=now - timedelta(days=1),
             end=now,
+            granularity_secs=self.time_window,
         )
 
         rpc_request, _, _ = get_timeseries_query(
@@ -280,7 +281,6 @@ def build_rpc_request(
             groupby=[],
             referrer=referrer,
             config=SearchResolverConfig(),
-            granularity_secs=self.time_window,
         )
 
         return rpc_request