timedelta

Author: kcons

src/sentry/incidents/logic.py

@@ -482,6 +482,8 @@ class AlertRuleNameAlreadyUsedError(Exception):
 
 # Default values for `SnubaQuery.resolution`, in minutes.
 DEFAULT_ALERT_RULE_RESOLUTION = 1
+# Comparison alerts query twice (current + comparison window), so we scale
+# resolution down to compensate for the increased query load.
 DEFAULT_CMP_ALERT_RULE_RESOLUTION_MULTIPLIER = 2
 DEFAULT_ALERT_RULE_WINDOW_TO_RESOLUTION = {
     30: 2,
@@ -505,13 +507,25 @@ class AlertRuleNameAlreadyUsedError(Exception):
 }
 
 
-def get_alert_resolution(time_window: int, organization: Organization) -> int:
+def get_alert_resolution(time_window: int, organization: Organization) -> timedelta:
+    """
+    Return the Snuba subscription evaluation interval for a given alert time window.
+
+    Larger time windows don't need fine-grained resolution, so we map them to
+    coarser buckets to reduce query load. See DEFAULT_ALERT_RULE_WINDOW_TO_RESOLUTION.
+
+    :param time_window: The alert's aggregation window, in minutes.
+    :param organization: The organization (reserved for future per-org overrides).
+    :return: The evaluation interval as a timedelta.
+    """
     index = bisect.bisect_right(SORTED_TIMEWINDOWS, time_window)
 
     if index == 0:
-        return DEFAULT_ALERT_RULE_RESOLUTION
+        minutes = DEFAULT_ALERT_RULE_RESOLUTION
+    else:
+        minutes = DEFAULT_ALERT_RULE_WINDOW_TO_RESOLUTION[SORTED_TIMEWINDOWS[index - 1]]
 
-    return DEFAULT_ALERT_RULE_WINDOW_TO_RESOLUTION[SORTED_TIMEWINDOWS[index - 1]]
+    return timedelta(minutes=minutes)
 
 
 class _OwnerKwargs(TypedDict):
@@ -585,7 +599,7 @@ def create_alert_rule(
         raise ResourceDoesNotExist("Your organization does not have access to this feature.")
 
     if detection_type == AlertRuleDetectionType.DYNAMIC:
-        resolution = time_window
+        resolution = timedelta(minutes=time_window)
         # NOTE: we hardcode seasonality for EA
         seasonality = AlertRuleSeasonality.AUTO
         if not sensitivity:
@@ -617,8 +631,7 @@ def create_alert_rule(
                 raise ValidationError("Comparison delta is not a valid field for this alert type")
 
     if comparison_delta is not None:
-        # Since comparison alerts make twice as many queries, run the queries less frequently.
-        resolution = resolution * DEFAULT_CMP_ALERT_RULE_RESOLUTION_MULTIPLIER
+        resolution *= DEFAULT_CMP_ALERT_RULE_RESOLUTION_MULTIPLIER
         comparison_delta = int(timedelta(minutes=comparison_delta).total_seconds())
 
     with transaction.atomic(router.db_for_write(SnubaQuery)):
@@ -629,7 +642,7 @@ def create_alert_rule(
             query=query,
             aggregate=aggregate,
             time_window=timedelta(minutes=time_window),
-            resolution=timedelta(minutes=resolution),
+            resolution=resolution,
             environment=environment,
             event_types=event_types,
             extrapolation_mode=extrapolation_mode,
@@ -900,11 +913,9 @@ def update_alert_rule(
         )
 
         if resolution_comparison_delta is not None:
-            updated_query_fields["resolution"] = timedelta(
-                minutes=(resolution * DEFAULT_CMP_ALERT_RULE_RESOLUTION_MULTIPLIER)
-            )
-        else:
-            updated_query_fields["resolution"] = timedelta(minutes=resolution)
+            resolution *= DEFAULT_CMP_ALERT_RULE_RESOLUTION_MULTIPLIER
+
+        updated_query_fields["resolution"] = resolution
 
     if detection_type:
         updated_fields["detection_type"] = detection_type
@@ -918,8 +929,10 @@ def update_alert_rule(
             updated_fields["seasonality"] = None
         elif detection_type == AlertRuleDetectionType.DYNAMIC:
             # NOTE: we set seasonality for EA
-            updated_query_fields["resolution"] = timedelta(
-                minutes=time_window if time_window is not None else snuba_query.time_window
+            updated_query_fields["resolution"] = (
+                timedelta(minutes=time_window)
+                if time_window is not None
+                else timedelta(seconds=snuba_query.time_window)
             )
             updated_fields["seasonality"] = AlertRuleSeasonality.AUTO
             updated_fields["comparison_delta"] = None

src/sentry/incidents/metric_issue_detector.py

@@ -8,7 +8,11 @@
 
 from sentry import features, quotas
 from sentry.constants import ObjectStatus
-from sentry.incidents.logic import enable_disable_subscriptions
+from sentry.incidents.logic import (
+    DEFAULT_CMP_ALERT_RULE_RESOLUTION_MULTIPLIER,
+    enable_disable_subscriptions,
+    get_alert_resolution,
+)
 from sentry.incidents.models.alert_rule import AlertRuleDetectionType
 from sentry.relay.config.metric_extraction import on_demand_metrics_feature_flags
 from sentry.search.eap.trace_metrics.validator import validate_trace_metrics_aggregate
@@ -239,6 +243,24 @@ def _validate_extrapolation_mode(self, extrapolation_mode: ExtrapolationMode) ->
                 f"{extrapolation_mode.name.lower()} extrapolation mode is not supported for new detectors. Allowed modes are: client_and_server_weighted, unknown."
             )
 
+    def _get_resolution_for_window(
+        self, time_window_seconds: int, detection_type: str | None, comparison_delta: int | None
+    ) -> timedelta:
+        """
+        Compute the appropriate SnubaQuery resolution for a given time window,
+        mirroring the logic in create_alert_rule / update_alert_rule.
+        """
+        organization = self.context["organization"]
+
+        if detection_type == AlertRuleDetectionType.DYNAMIC:
+            resolution = timedelta(seconds=time_window_seconds)
+        else:
+            resolution = get_alert_resolution(time_window_seconds // 60, organization)
+            if comparison_delta is not None:
+                resolution *= DEFAULT_CMP_ALERT_RULE_RESOLUTION_MULTIPLIER
+
+        return resolution
+
     def get_quota(self) -> DetectorQuota:
         organization = self.context.get("organization")
         request = self.context.get("request")
@@ -336,14 +358,21 @@ def update_data_source(
             data_source.get("extrapolation_mode", snuba_query.extrapolation_mode)
         )
 
+        new_time_window = data_source.get("time_window", snuba_query.time_window)
+        resolution = self._get_resolution_for_window(
+            new_time_window,
+            instance.config.get("detection_type"),
+            instance.config.get("comparison_delta"),
+        )
+
         update_snuba_query(
             snuba_query=snuba_query,
             query_type=data_source.get("query_type", snuba_query.type),
             dataset=data_source.get("dataset", snuba_query.dataset),
             query=data_source.get("query", snuba_query.query),
             aggregate=data_source.get("aggregate", snuba_query.aggregate),
-            time_window=timedelta(seconds=data_source.get("time_window", snuba_query.time_window)),
-            resolution=timedelta(seconds=data_source.get("resolution", snuba_query.resolution)),
+            time_window=timedelta(seconds=new_time_window),
+            resolution=resolution,
             environment=data_source.get("environment", snuba_query.environment),
             event_types=data_source.get("event_types", [event_type for event_type in event_types]),
             extrapolation_mode=extrapolation_mode,
@@ -407,6 +436,10 @@ def update(self, instance: Detector, validated_data: dict[str, Any]):
 
         if data_source is not None:
             self.update_data_source(instance, data_source, seer_updated)
+        elif "config" in validated_data:
+            # Config changed (e.g. detection_type or comparison_delta) without a
+            # data_source update — recalculate resolution to match the new config.
+            self.update_data_source(instance, {}, seer_updated)
 
         instance.save()
 
@@ -415,10 +448,20 @@ def update(self, instance: Detector, validated_data: dict[str, Any]):
 
     def create(self, validated_data: dict[str, Any]):
         if "data_sources" in validated_data:
+            config = validated_data.get("config", {})
+            detection_type = config.get("detection_type")
+            comparison_delta = config.get("comparison_delta")
+
             for validated_data_source in validated_data["data_sources"]:
                 self._validate_transaction_dataset_deprecation(validated_data_source.get("dataset"))
                 self._validate_extrapolation_mode(validated_data_source.get("extrapolation_mode"))
 
+                time_window = validated_data_source.get("time_window")
+                if time_window is not None:
+                    validated_data_source["resolution"] = self._get_resolution_for_window(
+                        time_window, detection_type, comparison_delta
+                    )
+
         detector = super().create(validated_data)
 
         if detector.config.get("detection_type") == AlertRuleDetectionType.DYNAMIC.value:

src/sentry/snuba/models.py

@@ -72,7 +72,10 @@ class Type(Enum):
         size=100,
     )
     aggregate = models.TextField()
+    # The aggregation window for the query, in seconds.
     time_window = models.IntegerField()
+    # How often the subscription query is evaluated, in seconds. Scaled up for
+    # larger time windows and comparison alerts to reduce query load.
     resolution = models.IntegerField()
     extrapolation_mode = models.IntegerField(
         choices=ExtrapolationMode.as_choices(),

src/sentry/snuba/snuba_query_validator.py

@@ -483,7 +483,7 @@ def create_source(self, validated_data: dict[str, Any]) -> QuerySubscription:
             query=validated_data["query"],
             aggregate=validated_data["aggregate"],
             time_window=timedelta(seconds=validated_data["time_window"]),
-            resolution=timedelta(minutes=1),
+            resolution=validated_data.get("resolution", timedelta(minutes=1)),
             environment=validated_data["environment"],
             event_types=validated_data["event_types"],
             group_by=validated_data.get("group_by"),