fix(aci): accept str instead of int for extrapolation mode in validator

src/sentry/incidents/endpoints/organization_alert_rule_details.py

@@ -125,7 +125,10 @@ def update_alert_rule(
         partial=True,
     )
     if validator.is_valid():
-        if data.get("dataset") == Dataset.EventsAnalyticsPlatform.value:
+        if (
+            data.get("dataset", alert_rule.snuba_query.dataset)
+            == Dataset.EventsAnalyticsPlatform.value
+        ):
             if data.get("extrapolation_mode"):
                 old_extrapolation_mode = ExtrapolationMode(
                     alert_rule.snuba_query.extrapolation_mode

src/sentry/incidents/metric_issue_detector.py

@@ -161,6 +161,8 @@ def is_invalid_extrapolation_mode(old_extrapolation_mode, new_extrapolation_mode
         new_extrapolation_mode = ExtrapolationMode(new_extrapolation_mode).name.lower()
     if type(old_extrapolation_mode) is int:
         old_extrapolation_mode = ExtrapolationMode(old_extrapolation_mode).name.lower()
+    if new_extrapolation_mode not in [name for name, value in ExtrapolationMode.as_text_choices()]:
+        return True
     if (
         new_extrapolation_mode == ExtrapolationMode.SERVER_WEIGHTED.name.lower()
         and old_extrapolation_mode != ExtrapolationMode.SERVER_WEIGHTED.name.lower()
@@ -169,6 +171,20 @@ def is_invalid_extrapolation_mode(old_extrapolation_mode, new_extrapolation_mode
     return False
 
 
+def format_extrapolation_mode(extrapolation_mode) -> ExtrapolationMode:
+    if type(extrapolation_mode) is int:
+        return extrapolation_mode
+    extrapolation_mode_options = ExtrapolationMode.as_text_choices()
+    numerical_extrapolation_mode = None
+    for name, value in extrapolation_mode_options:
+        if name == extrapolation_mode:
+            numerical_extrapolation_mode = value
+            break
+    if type(numerical_extrapolation_mode) is not int:
+        return None
+    return numerical_extrapolation_mode
+
+
 class MetricIssueDetectorValidator(BaseDetectorTypeValidator):
     data_sources = serializers.ListField(
         child=SnubaQueryValidator(timeWindowSeconds=True), required=False
@@ -197,7 +213,11 @@ def _validate_transaction_dataset_deprecation(self, dataset: Dataset) -> None:
                 )
 
     def _validate_extrapolation_mode(self, extrapolation_mode: str) -> None:
-        if extrapolation_mode == ExtrapolationMode.SERVER_WEIGHTED.value:
+        if extrapolation_mode is not None and extrapolation_mode not in [
+            name for name, value in ExtrapolationMode.as_text_choices()
+        ]:
+            raise serializers.ValidationError(f"Invalid extrapolation mode: {extrapolation_mode}")
+        if extrapolation_mode == ExtrapolationMode.SERVER_WEIGHTED.name.lower():
             raise serializers.ValidationError(
                 "server_weighted extrapolation mode is not supported for new detectors."
             )
@@ -288,6 +308,10 @@ def update_data_source(
                     "Failed to send data to Seer, cannot update detector"
                 )
 
+        numerical_extrapolation_mode = format_extrapolation_mode(
+            data_source.get("extrapolation_mode", snuba_query.extrapolation_mode)
+        )
+
         update_snuba_query(
             snuba_query=snuba_query,
             query_type=data_source.get("query_type", snuba_query.type),
@@ -298,9 +322,7 @@ def update_data_source(
             resolution=timedelta(seconds=data_source.get("resolution", snuba_query.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=data_source.get(
-                "extrapolation_mode", snuba_query.extrapolation_mode
-            ),
+            extrapolation_mode=numerical_extrapolation_mode,
         )
 
     def update_anomaly_detection(self, instance: Detector, validated_data: dict[str, Any]) -> bool:

src/sentry/snuba/snuba_query_validator.py

@@ -87,7 +87,7 @@ class SnubaQueryValidator(BaseDataSourceValidator[QuerySubscription]):
         required=False,
         allow_empty=False,
     )
-    extrapolation_mode = serializers.IntegerField(required=False, allow_null=True)
+    extrapolation_mode = serializers.CharField(required=False, allow_null=True)
 
     class Meta:
         model = QuerySubscription
@@ -408,7 +408,15 @@ def _validate_group_by(self, value: Sequence[str] | None) -> Sequence[str] | Non
     def create_source(self, validated_data) -> QuerySubscription:
         extrapolation_mode = validated_data.get("extrapolation_mode")
         if extrapolation_mode is not None:
-            extrapolation_mode = ExtrapolationMode(extrapolation_mode)
+            extrapolation_mode_options = ExtrapolationMode.as_text_choices()
+            for name, value in extrapolation_mode_options:
+                if name == extrapolation_mode:
+                    extrapolation_mode = ExtrapolationMode(value)
+                    break
+            if type(extrapolation_mode) is not ExtrapolationMode:
+                raise serializers.ValidationError(
+                    f"Invalid extrapolation mode: {extrapolation_mode}"
+                )
         snuba_query = create_snuba_query(
             query_type=validated_data["query_type"],
             dataset=validated_data["dataset"],

src/sentry/snuba/subscriptions.py

@@ -133,7 +133,7 @@ def update_snuba_query(
             extrapolation_mode=(
                 extrapolation_mode
                 if extrapolation_mode is not None
-                else ExtrapolationMode.UNKNOWN.value
+                else snuba_query.extrapolation_mode
             ),
         )
         if new_event_types:

tests/sentry/incidents/endpoints/validators/test_validators.py

@@ -1238,7 +1238,7 @@ def test_invalid_extrapolation_mode_create(self) -> None:
                     "timeWindow": 3600,
                     "environment": self.environment.name,
                     "eventTypes": [SnubaQueryEventType.EventType.TRACE_ITEM_SPAN.name.lower()],
-                    "extrapolation_mode": ExtrapolationMode.SERVER_WEIGHTED.value,
+                    "extrapolation_mode": ExtrapolationMode.SERVER_WEIGHTED.name.lower(),
                 },
             ],
         }
@@ -1263,7 +1263,7 @@ def test_invalid_extrapolation_mode_update(self) -> None:
                     "timeWindow": 3600,
                     "environment": self.environment.name,
                     "eventTypes": [SnubaQueryEventType.EventType.TRACE_ITEM_SPAN.name.lower()],
-                    "extrapolation_mode": ExtrapolationMode.CLIENT_AND_SERVER_WEIGHTED.value,
+                    "extrapolation_mode": ExtrapolationMode.CLIENT_AND_SERVER_WEIGHTED.name.lower(),
                 },
             ],
         }
@@ -1283,7 +1283,78 @@ def test_invalid_extrapolation_mode_update(self) -> None:
                     "timeWindow": 3600,
                     "environment": self.environment.name,
                     "eventTypes": [SnubaQueryEventType.EventType.TRACE_ITEM_SPAN.name.lower()],
-                    "extrapolation_mode": ExtrapolationMode.SERVER_WEIGHTED.value,
+                    "extrapolation_mode": ExtrapolationMode.SERVER_WEIGHTED.name.lower(),
+                }
+            ],
+        }
+        update_validator = MetricIssueDetectorValidator(
+            instance=detector, data=update_data, context=self.context, partial=True
+        )
+        assert update_validator.is_valid(), update_validator.errors
+        with self.assertRaisesMessage(
+            ValidationError,
+            expected_message="Invalid extrapolation mode for this detector type.",
+        ):
+            update_validator.save()
+
+    def test_nonexistent_extrapolation_mode_create(self) -> None:
+        data = {
+            **self.valid_data,
+            "dataSources": [
+                {
+                    "queryType": SnubaQuery.Type.PERFORMANCE.value,
+                    "dataset": Dataset.EventsAnalyticsPlatform.value,
+                    "query": "test query",
+                    "aggregate": "count()",
+                    "timeWindow": 3600,
+                    "environment": self.environment.name,
+                    "eventTypes": [SnubaQueryEventType.EventType.TRACE_ITEM_SPAN.name.lower()],
+                    "extrapolation_mode": "blah",
+                },
+            ],
+        }
+
+        validator = MetricIssueDetectorValidator(data=data, context=self.context)
+        assert validator.is_valid(), validator.errors
+        with self.assertRaisesMessage(
+            ValidationError,
+            expected_message="Invalid extrapolation mode: blah",
+        ):
+            validator.save()
+
+    def test_nonexistent_extrapolation_mode_update(self) -> None:
+        data = {
+            **self.valid_data,
+            "dataSources": [
+                {
+                    "queryType": SnubaQuery.Type.PERFORMANCE.value,
+                    "dataset": Dataset.EventsAnalyticsPlatform.value,
+                    "query": "test query",
+                    "aggregate": "count()",
+                    "timeWindow": 3600,
+                    "environment": self.environment.name,
+                    "eventTypes": [SnubaQueryEventType.EventType.TRACE_ITEM_SPAN.name.lower()],
+                    "extrapolation_mode": ExtrapolationMode.CLIENT_AND_SERVER_WEIGHTED.name.lower(),
+                },
+            ],
+        }
+
+        validator = MetricIssueDetectorValidator(data=data, context=self.context)
+        assert validator.is_valid(), validator.errors
+
+        detector = validator.save()
+
+        update_data = {
+            "dataSources": [
+                {
+                    "queryType": SnubaQuery.Type.PERFORMANCE.value,
+                    "dataset": Dataset.EventsAnalyticsPlatform.value,
+                    "query": "updated query",
+                    "aggregate": "count()",
+                    "timeWindow": 3600,
+                    "environment": self.environment.name,
+                    "eventTypes": [SnubaQueryEventType.EventType.TRACE_ITEM_SPAN.name.lower()],
+                    "extrapolation_mode": "blah",
                 }
             ],
         }