feat(ACI): Handle anomaly detection data condition in validator (#93886)

Update the metric issue validator to handle anomaly detection data
condition input - the main difference with these is that `comparison` is
a dictionary rather than a number.

Author: ceorourke

src/sentry/incidents/metric_issue_detector.py

@@ -11,17 +11,17 @@
     BaseDetectorTypeValidator,
 )
 from sentry.workflow_engine.endpoints.validators.base.data_condition import (
-    AbstractDataConditionValidator,
+    BaseDataConditionValidator,
 )
 from sentry.workflow_engine.models import DataSource, Detector
 from sentry.workflow_engine.models.data_condition import Condition
 from sentry.workflow_engine.types import DetectorPriorityLevel, SnubaQueryDataSourceType
 
 
-class MetricIssueComparisonConditionValidator(
-    AbstractDataConditionValidator[float, DetectorPriorityLevel]
-):
-    supported_conditions = frozenset((Condition.GREATER, Condition.LESS))
+class MetricIssueComparisonConditionValidator(BaseDataConditionValidator):
+    supported_conditions = frozenset(
+        (Condition.GREATER, Condition.LESS, Condition.ANOMALY_DETECTION)
+    )
     supported_condition_results = frozenset(
         (DetectorPriorityLevel.HIGH, DetectorPriorityLevel.MEDIUM)
     )
@@ -37,13 +37,19 @@ def validate_type(self, value: str) -> Condition:
 
         return type
 
-    def validate_comparison(self, value: float | int | str) -> float:
-        try:
-            value = float(value)
-        except ValueError:
-            raise serializers.ValidationError("A valid number is required.")
+    def validate_comparison(self, value: dict | float | int | str) -> float | dict:
+        if isinstance(value, (float, int)):
+            try:
+                value = float(value)
+            except ValueError:
+                raise serializers.ValidationError("A valid number is required.")
+            return value
 
-        return value
+        elif isinstance(value, dict):
+            return super().validate_comparison(value)
+
+        else:
+            raise serializers.ValidationError("A valid number or dict is required.")
 
     def validate_condition_result(self, value: str) -> DetectorPriorityLevel:
         try:

src/sentry/workflow_engine/endpoints/validators/base/data_condition.py

@@ -40,27 +40,31 @@ def validate_condition_result(self, value: Any) -> ConditionResult:
 class BaseDataConditionValidator(
     AbstractDataConditionValidator[Any, Any],
 ):
+
+    @property
+    def condition_type(self) -> Condition:
+        if isinstance(self.initial_data, list) and self.initial_data:
+            return self.initial_data[0].get("type")
+
+        return self.initial_data.get("type")
+
     def _get_handler(self) -> type[DataConditionHandler] | None:
         if self._is_operator_condition():
             return None
 
-        condition_type = self.initial_data.get("type")
-
         try:
-            return condition_handler_registry.get(condition_type)
+            return condition_handler_registry.get(self.condition_type)
         except NoRegistrationExistsError:
-            raise serializers.ValidationError(f"Invalid condition type: {condition_type}")
+            raise serializers.ValidationError(f"Invalid condition type: {self.condition_type}")
 
     def _is_operator_condition(self) -> bool:
-        condition_type = self.initial_data.get("type")
-        return condition_type in CONDITION_OPS
+        return self.condition_type in CONDITION_OPS
 
     def validate_comparison(self, value: Any) -> Any:
         """
         Validate the comparison field. Get the schema configuration for the type, if
         there is no schema configuration, then we assume the comparison field is a primitive value.
         """
-
         handler = self._get_handler()
 
         if not handler:

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

@@ -11,6 +11,11 @@
 from sentry.incidents.models.alert_rule import AlertRuleDetectionType
 from sentry.incidents.utils.constants import INCIDENTS_SNUBA_SUBSCRIPTION_TYPE
 from sentry.models.environment import Environment
+from sentry.seer.anomaly_detection.types import (
+    AnomalyDetectionSeasonality,
+    AnomalyDetectionSensitivity,
+    AnomalyDetectionThresholdType,
+)
 from sentry.snuba.dataset import Dataset
 from sentry.snuba.models import (
     QuerySubscription,
@@ -26,15 +31,17 @@
 
 
 class MetricIssueComparisonConditionValidatorTest(BaseValidatorTest):
+    def setUp(self):
+        super().setUp()
+        self.valid_data = {
+            "type": Condition.GREATER,
+            "comparison": 100,
+            "conditionResult": DetectorPriorityLevel.HIGH,
+            "conditionGroupId": self.data_condition_group.id,
+        }
+
     def test(self):
-        validator = MetricIssueComparisonConditionValidator(
-            data={
-                "type": Condition.GREATER,
-                "comparison": 100,
-                "conditionResult": DetectorPriorityLevel.HIGH,
-                "conditionGroupId": self.data_condition_group.id,
-            }
-        )
+        validator = MetricIssueComparisonConditionValidator(data=self.valid_data)
         assert validator.is_valid()
         assert validator.validated_data == {
             "comparison": 100.0,
@@ -46,9 +53,8 @@ def test(self):
     def test_invalid_condition(self):
         unsupported_condition = Condition.EQUAL
         data = {
+            **self.valid_data,
             "type": unsupported_condition,
-            "comparison": 100,
-            "result": DetectorPriorityLevel.HIGH,
         }
         validator = MetricIssueComparisonConditionValidator(data=data)
         assert not validator.is_valid()
@@ -58,7 +64,7 @@ def test_invalid_condition(self):
 
     def test_unregistered_condition(self):
         validator = MetricIssueComparisonConditionValidator(
-            data={"type": "invalid", "comparison": 100, "result": DetectorPriorityLevel.HIGH}
+            data={**self.valid_data, "type": "invalid"}
         )
         assert not validator.is_valid()
         assert validator.errors.get("type") == [
@@ -68,23 +74,36 @@ def test_unregistered_condition(self):
     def test_invalid_comparison(self):
         validator = MetricIssueComparisonConditionValidator(
             data={
-                "type": Condition.GREATER,
+                **self.valid_data,
                 "comparison": "not_a_number",
-                "result": DetectorPriorityLevel.HIGH,
             }
         )
         assert not validator.is_valid()
         assert validator.errors.get("comparison") == [
-            ErrorDetail(string="A valid number is required.", code="invalid")
+            ErrorDetail(string="A valid number or dict is required.", code="invalid")
+        ]
+
+    def test_invalid_comparison_dict(self):
+        comparison = {"foo": "bar"}
+        validator = MetricIssueComparisonConditionValidator(
+            data={
+                **self.valid_data,
+                "comparison": comparison,
+            }
+        )
+        assert not validator.is_valid()
+        assert validator.errors.get("comparison") == [
+            ErrorDetail(
+                string=f"Invalid json primitive value: {comparison}. Must be a string, number, or boolean.",
+                code="invalid",
+            )
         ]
 
     def test_invalid_result(self):
         validator = MetricIssueComparisonConditionValidator(
             data={
-                "type": Condition.GREATER,
-                "comparison": 100,
-                "condition_result": 25,
-                "condition_group_id": self.data_condition_group.id,
+                **self.valid_data,
+                "conditionResult": 25,
             }
         )
         assert not validator.is_valid()
@@ -109,13 +128,13 @@ def setUp(self):
             "name": "Test Detector",
             "type": MetricIssue.slug,
             "dataSource": {
-                "query_type": SnubaQuery.Type.ERROR.value,
+                "queryType": SnubaQuery.Type.ERROR.value,
                 "dataset": Dataset.Events.value,
                 "query": "test query",
                 "aggregate": "count()",
-                "time_window": 3600,
+                "timeWindow": 3600,
                 "environment": self.environment.name,
-                "event_types": [SnubaQueryEventType.EventType.ERROR.name.lower()],
+                "eventTypes": [SnubaQueryEventType.EventType.ERROR.name.lower()],
             },
             "conditionGroup": {
                 "id": self.data_condition_group.id,
@@ -131,23 +150,12 @@ def setUp(self):
                 ],
             },
             "config": {
-                "threshold_period": 1,
-                "detection_type": AlertRuleDetectionType.STATIC.value,
+                "thresholdPeriod": 1,
+                "detectionType": AlertRuleDetectionType.STATIC.value,
             },
         }
 
-    @mock.patch("sentry.workflow_engine.endpoints.validators.base.detector.create_audit_entry")
-    def test_create_with_valid_data(self, mock_audit):
-        validator = MetricIssueDetectorValidator(
-            data=self.valid_data,
-            context=self.context,
-        )
-        assert validator.is_valid(), validator.errors
-
-        with self.tasks():
-            detector = validator.save()
-
-        # Verify detector in DB
+    def assert_validated(self, detector):
         detector = Detector.objects.get(id=detector.id)
         assert detector.name == "Test Detector"
         assert detector.type == MetricIssue.slug
@@ -175,6 +183,19 @@ def test_create_with_valid_data(self, mock_audit):
         assert snuba_query.environment == self.environment
         assert snuba_query.event_types == [SnubaQueryEventType.EventType.ERROR]
 
+    @mock.patch("sentry.workflow_engine.endpoints.validators.base.detector.create_audit_entry")
+    def test_create_with_valid_data(self, mock_audit):
+        validator = MetricIssueDetectorValidator(
+            data=self.valid_data,
+            context=self.context,
+        )
+        assert validator.is_valid(), validator.errors
+
+        with self.tasks():
+            detector = validator.save()
+
+        # Verify detector in DB
+        self.assert_validated(detector)
         # Verify condition group in DB
         condition_group = DataConditionGroup.objects.get(id=detector.workflow_condition_group_id)
         assert condition_group.logic_type == DataConditionGroup.Type.ANY
@@ -197,6 +218,102 @@ def test_create_with_valid_data(self, mock_audit):
             data=detector.get_audit_log_data(),
         )
 
+    @mock.patch("sentry.workflow_engine.endpoints.validators.base.detector.create_audit_entry")
+    def test_anomaly_detection(self, mock_audit):
+        data = {
+            **self.valid_data,
+            "conditionGroup": {
+                "id": self.data_condition_group.id,
+                "organizationId": self.organization.id,
+                "logicType": self.data_condition_group.logic_type,
+                "conditions": [
+                    {
+                        "type": Condition.ANOMALY_DETECTION,
+                        "comparison": {
+                            "sensitivity": AnomalyDetectionSensitivity.HIGH,
+                            "seasonality": AnomalyDetectionSeasonality.AUTO,
+                            "threshold_type": AnomalyDetectionThresholdType.ABOVE_AND_BELOW,
+                        },
+                        "conditionResult": DetectorPriorityLevel.HIGH,
+                        "conditionGroupId": self.data_condition_group.id,
+                    },
+                ],
+            },
+            "config": {
+                "threshold_period": 1,
+                "detection_type": AlertRuleDetectionType.DYNAMIC.value,
+            },
+        }
+        validator = MetricIssueDetectorValidator(
+            data=data,
+            context=self.context,
+        )
+        assert validator.is_valid(), validator.errors
+
+        with self.tasks():
+            detector = validator.save()
+
+        # Verify detector in DB
+        self.assert_validated(detector)
+
+        # Verify condition group in DB
+        condition_group = DataConditionGroup.objects.get(id=detector.workflow_condition_group_id)
+        assert condition_group.logic_type == DataConditionGroup.Type.ANY
+        assert condition_group.organization_id == self.project.organization_id
+
+        # Verify conditions in DB
+        conditions = list(DataCondition.objects.filter(condition_group=condition_group))
+        assert len(conditions) == 1
+
+        condition = conditions[0]
+        assert condition.type == Condition.ANOMALY_DETECTION
+        assert condition.comparison == {
+            "sensitivity": AnomalyDetectionSensitivity.HIGH,
+            "seasonality": AnomalyDetectionSeasonality.AUTO,
+            "threshold_type": AnomalyDetectionThresholdType.ABOVE_AND_BELOW,
+        }
+        assert condition.condition_result == DetectorPriorityLevel.HIGH
+
+        # Verify audit log
+        mock_audit.assert_called_once_with(
+            request=self.context["request"],
+            organization=self.project.organization,
+            target_object=detector.id,
+            event=audit_log.get_event_id("DETECTOR_ADD"),
+            data=detector.get_audit_log_data(),
+        )
+
+    def test_anomaly_detection__invalid_comparison(self):
+        data = {
+            **self.valid_data,
+            "conditionGroup": {
+                "id": self.data_condition_group.id,
+                "organizationId": self.organization.id,
+                "logicType": self.data_condition_group.logic_type,
+                "conditions": [
+                    {
+                        "type": Condition.ANOMALY_DETECTION,
+                        "comparison": {
+                            "sensitivity": "super sensitive",
+                            "seasonality": AnomalyDetectionSeasonality.AUTO,
+                            "threshold_type": AnomalyDetectionThresholdType.ABOVE_AND_BELOW,
+                        },
+                        "conditionResult": DetectorPriorityLevel.HIGH,
+                        "conditionGroupId": self.data_condition_group.id,
+                    },
+                ],
+            },
+            "config": {
+                "threshold_period": 1,
+                "detection_type": AlertRuleDetectionType.DYNAMIC.value,
+            },
+        }
+        validator = MetricIssueDetectorValidator(
+            data=data,
+            context=self.context,
+        )
+        assert not validator.is_valid()
+
     def test_invalid_detector_type(self):
         data = {**self.valid_data, "type": "invalid_type"}
         validator = MetricIssueDetectorValidator(data=data, context=self.context)