feat(aci milestone 3): issue priority de-escalation condition handler (#89832)

We need this condition handler to fire actions when a metric issue's
priority de-escalates. For example, if we go from MEDIUM to HIGH and
then back to MEDIUM, we also want to fire the HIGH actions informing
users of the status de-escalation.

To do so, pass in a comparison priority and the highest-seen priority.
The condition evaluates to TRUE if A) the current priority is < the
comparison priority and B) the comparison priority is <= the
highest-seen priority, so we've fired the action.

If we decide to change the behavior of alert firing in the future (if we
decide not to fire warning actions when going straight to high), then
this logic could break. It could also break if we decide to add in
another priority level, like low (because then if we go from high -> low
-> medium, the condition evaluates to TRUE on the last transition but we
aren't de-escalating).

Author: mifu67

src/sentry/workflow_engine/handlers/condition/__init__.py

@@ -12,6 +12,7 @@
     "IssueOccurrencesConditionHandler",
     "IssuePriorityCondition",
     "IssuePriorityGreaterOrEqualConditionHandler",
+    "IssuePriorityDeescalatingConditionHandler",
     "IssueResolutionConditionHandler",
     "LatestAdoptedReleaseConditionHandler",
     "LatestReleaseConditionHandler",
@@ -34,6 +35,7 @@
 from .first_seen_event_handler import FirstSeenEventConditionHandler
 from .issue_category_handler import IssueCategoryConditionHandler
 from .issue_occurrences_handler import IssueOccurrencesConditionHandler
+from .issue_priority_deescalating_handler import IssuePriorityDeescalatingConditionHandler
 from .issue_priority_equals import IssuePriorityCondition
 from .issue_priority_greater_or_equal_handler import IssuePriorityGreaterOrEqualConditionHandler
 from .issue_resolution_condition_handler import IssueResolutionConditionHandler

src/sentry/workflow_engine/handlers/condition/issue_priority_deescalating_handler.py

@@ -0,0 +1,40 @@
+from typing import Any
+
+from sentry.models.group import GroupStatus
+from sentry.models.groupopenperiod import GroupOpenPeriod
+from sentry.workflow_engine.models.data_condition import Condition
+from sentry.workflow_engine.registry import condition_handler_registry
+from sentry.workflow_engine.types import DataConditionHandler, WorkflowEventData
+
+
+@condition_handler_registry.register(Condition.ISSUE_PRIORITY_DEESCALATING)
+class IssuePriorityDeescalatingConditionHandler(DataConditionHandler[WorkflowEventData]):
+    group = DataConditionHandler.Group.ACTION_FILTER
+    subgroup = DataConditionHandler.Subgroup.ISSUE_ATTRIBUTES
+
+    comparison_json_schema = {
+        "type": "object",
+        "properties": {
+            "priority": {"type": "integer", "minimum": 0},
+        },
+        "required": ["priority"],
+        "additionalProperties": False,
+    }
+
+    @staticmethod
+    def evaluate_value(event_data: WorkflowEventData, comparison: Any) -> bool:
+        group = event_data.event.group
+
+        # we will fire actions on de-escalation if the priority seen is >= the threshold
+        # priority specified in the comparison
+        comparison_priority = comparison.get("priority")
+        current_priority = group.priority
+        open_period = GroupOpenPeriod.objects.filter(group=group).order_by("-date_started").first()
+        if open_period is None:
+            raise Exception("No open period found")
+        # use this to determine if we've breached the comparison priority before
+        highest_seen_priority = open_period.data.get("highest_seen_priority", current_priority)
+
+        return comparison_priority <= highest_seen_priority and (
+            current_priority < comparison_priority or group.status == GroupStatus.RESOLVED
+        )

src/sentry/workflow_engine/models/data_condition.py

@@ -48,6 +48,7 @@ class Condition(StrEnum):
     TAGGED_EVENT = "tagged_event"
     ISSUE_PRIORITY_EQUALS = "issue_priority_equals"
     ISSUE_PRIORITY_GREATER_OR_EQUAL = "issue_priority_greater_or_equal"
+    ISSUE_PRIORITY_DEESCALATING = "issue_priority_deescalating"
     ISSUE_RESOLUTION_CHANGE = "issue_resolution_change"
 
     # Event frequency conditions

tests/sentry/workflow_engine/handlers/condition/test_issue_priority_deescalating_handler.py

@@ -0,0 +1,94 @@
+from sentry.models.group import GroupStatus
+from sentry.models.groupopenperiod import GroupOpenPeriod
+from sentry.types.group import PriorityLevel
+from sentry.users.services.user.service import user_service
+from sentry.workflow_engine.migration_helpers.alert_rule import (
+    migrate_alert_rule,
+    migrate_metric_data_conditions,
+)
+from sentry.workflow_engine.models.data_condition import Condition
+from sentry.workflow_engine.types import DetectorPriorityLevel, WorkflowEventData
+from tests.sentry.workflow_engine.handlers.condition.test_base import ConditionTestCase
+
+
+class TestIssuePriorityGreaterOrEqualCondition(ConditionTestCase):
+    condition = Condition.ISSUE_PRIORITY_DEESCALATING
+
+    def setUp(self):
+        super().setUp()
+        self.event_data = WorkflowEventData(event=self.group_event)
+        self.metric_alert = self.create_alert_rule()
+        self.alert_rule_trigger_warning = self.create_alert_rule_trigger(
+            alert_rule=self.metric_alert, label="warning"
+        )
+        self.alert_rule_trigger_critical = self.create_alert_rule_trigger(
+            alert_rule=self.metric_alert, label="critical"
+        )
+        self.rpc_user = user_service.get_user(user_id=self.user.id)
+        migrate_alert_rule(self.metric_alert, self.rpc_user)
+
+        data_condition_warning_tuple = migrate_metric_data_conditions(
+            self.alert_rule_trigger_warning
+        )
+        data_condition_critical_tuple = migrate_metric_data_conditions(
+            self.alert_rule_trigger_critical
+        )
+
+        assert data_condition_warning_tuple is not None
+        assert data_condition_critical_tuple is not None
+        dc_warning = data_condition_warning_tuple[1]
+        dc_critical = data_condition_critical_tuple[1]
+
+        self.deescalating_dc_warning = self.create_data_condition(
+            comparison={"priority": DetectorPriorityLevel.MEDIUM.value},
+            type=self.condition,
+            condition_result=True,
+            condition_group=dc_warning.condition_group,
+        )
+
+        self.deescalating_dc_critical = self.create_data_condition(
+            comparison={"priority": DetectorPriorityLevel.HIGH.value},
+            type=self.condition,
+            condition_result=True,
+            condition_group=dc_critical.condition_group,
+        )
+
+    def update_group_and_open_period(self, priority: PriorityLevel) -> None:
+        self.group.update(priority=priority)
+        open_period = (
+            GroupOpenPeriod.objects.filter(group=self.group).order_by("-date_started").first()
+        )
+        assert open_period is not None
+        highest_seen_priority = open_period.data.get("highest_seen_priority", priority)
+        open_period.data["highest_seen_priority"] = max(highest_seen_priority, priority)
+        open_period.save()
+
+    def test_warning(self):
+        self.update_group_and_open_period(priority=PriorityLevel.MEDIUM)
+        self.assert_does_not_pass(self.deescalating_dc_warning, self.event_data)
+
+        self.update_group_and_open_period(priority=PriorityLevel.HIGH)
+        self.assert_does_not_pass(self.deescalating_dc_warning, self.event_data)
+
+        self.group.update(status=GroupStatus.RESOLVED)
+        self.assert_passes(self.deescalating_dc_warning, self.event_data)
+
+    def test_critical_threshold_not_breached(self):
+        self.update_group_and_open_period(priority=PriorityLevel.MEDIUM)
+        self.assert_does_not_pass(self.deescalating_dc_critical, self.event_data)
+
+        self.group.update(status=GroupStatus.RESOLVED)
+        self.assert_does_not_pass(self.deescalating_dc_critical, self.event_data)
+
+    def test_critical(self):
+        self.update_group_and_open_period(priority=PriorityLevel.MEDIUM)
+        self.assert_does_not_pass(self.deescalating_dc_critical, self.event_data)
+
+        self.update_group_and_open_period(priority=PriorityLevel.HIGH)
+        self.assert_does_not_pass(self.deescalating_dc_critical, self.event_data)
+
+        self.update_group_and_open_period(priority=PriorityLevel.MEDIUM)
+        self.assert_passes(self.deescalating_dc_critical, self.event_data)
+
+        self.group.update(status=GroupStatus.RESOLVED)
+        self.assert_passes(self.deescalating_dc_critical, self.event_data)