feat(aci): registry for dual writing conditions

src/sentry/workflow_engine/conditions/dual_write.py

@@ -0,0 +1,54 @@
+from collections.abc import Callable
+from typing import Any
+
+from sentry.rules.conditions.every_event import EveryEventCondition
+from sentry.rules.conditions.reappeared_event import ReappearedEventCondition
+from sentry.rules.conditions.regression_event import RegressionEventCondition
+from sentry.utils.registry import Registry
+from sentry.workflow_engine.models.data_condition import Condition, DataCondition
+from sentry.workflow_engine.models.data_condition_group import DataConditionGroup
+
+data_condition_translator_registry = Registry[
+    Callable[[dict[str, Any], DataConditionGroup], DataCondition]
+]()
+
+
+def translate_to_data_condition(data: dict[str, Any], dcg: DataConditionGroup):
+    translator = data_condition_translator_registry.get(data["id"])
+    return translator(data, dcg)
+
+
+@data_condition_translator_registry.register(EveryEventCondition.id)
+def create_every_event_condition(data: dict[str, Any], dcg: DataConditionGroup) -> DataCondition:
+    return DataCondition.objects.create(
+        condition=Condition.TRUTH,
+        comparison=True,
+        condition_result=True,
+        condition_group=dcg,
+    )
+
+
+@data_condition_translator_registry.register(ReappearedEventCondition.id)
+def create_group_comparison_reappeared_condition(
+    data: dict[str, Any], dcg: DataConditionGroup
+) -> DataCondition:
+    return DataCondition.objects.create(
+        type=Condition.GROUP_EVENT_ATTR_COMPARISON,
+        condition="state.has_reappeared",
+        comparison=True,
+        condition_result=True,
+        condition_group=dcg,
+    )
+
+
+@data_condition_translator_registry.register(RegressionEventCondition.id)
+def create_group_comparison_regression_condition(
+    data: dict[str, Any], dcg: DataConditionGroup
+) -> DataCondition:
+    return DataCondition.objects.create(
+        type=Condition.GROUP_EVENT_ATTR_COMPARISON,
+        condition="state.is_regression",
+        comparison=True,
+        condition_result=True,
+        condition_group=dcg,
+    )

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

@@ -3,7 +3,7 @@
 from sentry.eventstore.models import GroupEvent
 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
+from sentry.workflow_engine.types import DataConditionHandler, DetectorPriorityLevel
 
 
 def get_nested_value(data: Any, path: str, default: Any = None) -> Any | None:
@@ -24,6 +24,14 @@ def get_nested_value(data: Any, path: str, default: Any = None) -> Any | None:
 @condition_handler_registry.register(Condition.GROUP_EVENT_ATTR_COMPARISON)
 class GroupEventConditionHandler(DataConditionHandler[GroupEvent]):
     @staticmethod
-    def evaluate_value(data: GroupEvent, comparison: Any, data_filter: str) -> bool:
-        event_value = get_nested_value(data, data_filter)
+    def evaluate_value(
+        value: GroupEvent, comparison: Any, condition: str, **kwargs: Any
+    ) -> DetectorPriorityLevel | int | float | bool | None:
+        # conditions stores the path to the attribute in the event
+        event_value = get_nested_value(value, condition)
+        if event_value is None:
+            event_value = get_nested_value(
+                kwargs, condition
+            )  # TODO: remove when GroupEvent contains EventState
+
         return event_value == comparison

src/sentry/workflow_engine/models/data_condition.py

@@ -2,6 +2,7 @@
 import operator
 from collections.abc import Callable
 from enum import StrEnum
+from inspect import signature
 from typing import Any, TypeVar, cast
 
 from django.db import models
@@ -27,15 +28,17 @@ class Condition(StrEnum):
     LESS = "lt"
     NOT_EQUAL = "ne"
     GROUP_EVENT_ATTR_COMPARISON = "group_event_attr_comparison"
+    TRUTH = "truth"
 
 
-condition_ops = {
+condition_ops: dict[Condition, Callable] = {
     Condition.EQUAL: operator.eq,
     Condition.GREATER_OR_EQUAL: operator.ge,
     Condition.GREATER: operator.gt,
     Condition.LESS_OR_EQUAL: operator.le,
     Condition.LESS: operator.lt,
     Condition.NOT_EQUAL: operator.ne,
+    Condition.TRUTH: operator.truth,
 }
 
 T = TypeVar("T")
@@ -94,7 +97,7 @@ def get_condition_handler(self) -> DataConditionHandler[T] | None:
 
         return condition_handler_registry.get(condition_type)
 
-    def evaluate_value(self, value: T) -> DataConditionResult:
+    def evaluate_value(self, value: T, **kwargs) -> DataConditionResult:
         condition_handler: DataConditionHandler[T] | None = None
         op: Callable | None = None
 
@@ -107,9 +110,14 @@ def evaluate_value(self, value: T) -> DataConditionResult:
             op = condition_ops.get(condition, None)
 
         if condition_handler is not None:
-            result = condition_handler.evaluate_value(value, self.comparison, self.condition)
+            result = condition_handler.evaluate_value(
+                value, self.comparison, self.condition, **kwargs
+            )
         elif op is not None:
-            result = op(cast(Any, value), self.comparison)
+            if len(signature(op).parameters) == 1:
+                result = op(cast(Any, value)) == self.comparison
+            else:
+                result = op(cast(Any, value), self.comparison)
         else:
             logger.error(
                 "Invalid Data Condition Evaluation",

src/sentry/workflow_engine/types.py

@@ -42,7 +42,7 @@ def bulk_get_query_object(data_sources) -> dict[int, T | None]:
 
 class DataConditionHandler(Generic[T]):
     @staticmethod
-    def evaluate_value(value: T, comparison: Any, condition: str) -> DataConditionResult:
+    def evaluate_value(value: T, comparison: Any, condition: str, **kwargs) -> DataConditionResult:
         raise NotImplementedError
 
 

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

@@ -0,0 +1,42 @@
+from typing import Any
+
+from sentry.rules.base import RuleBase
+from sentry.testutils.cases import TestCase
+from sentry.workflow_engine.conditions.dual_write import (
+    translate_to_data_condition as dual_write_condition,
+)
+from sentry.workflow_engine.models.data_condition import Condition, DataCondition
+from sentry.workflow_engine.models.data_condition_group import DataConditionGroup
+
+
+class ConditionTestCase(TestCase):
+    @property
+    def condition(self) -> Condition:
+        raise NotImplementedError
+
+    @property
+    def rule_cls(self) -> type[RuleBase]:
+        # for mapping purposes, can delete later
+        raise NotImplementedError
+
+    @property
+    def payload(self) -> dict[str, Any]:
+        # for dual write, can delete later
+        raise NotImplementedError
+
+    def translate_to_data_condition(
+        self, data: dict[str, Any], dcg: DataConditionGroup
+    ) -> DataCondition:
+        return dual_write_condition(data, dcg)
+
+    def assert_passes(self, data_condition: DataCondition, value, **kwargs) -> None:
+        assert (
+            data_condition.evaluate_value(value, **kwargs) == data_condition.get_condition_result()
+        )
+
+    def assert_does_not_pass(self, data_condition: DataCondition, value, **kwargs) -> None:
+        assert (
+            data_condition.evaluate_value(value, **kwargs) != data_condition.get_condition_result()
+        )
+
+    # TODO: activity

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

@@ -0,0 +1,25 @@
+from sentry.rules.conditions.every_event import EveryEventCondition
+from sentry.workflow_engine.models.data_condition import Condition
+from tests.sentry.workflow_engine.handlers.condition.test_base import ConditionTestCase
+
+
+class EveryEventOperatorTest(ConditionTestCase):
+    condition = Condition.TRUTH
+    rule_cls = EveryEventCondition
+    payload = {"id": EveryEventCondition.id}
+
+    def test(self):
+        dc = self.create_data_condition(
+            comparison=True, condition_result=True, condition=self.condition
+        )
+
+        self.assert_passes(dc, self.event)
+
+    def test_dual_write(self):
+        dcg = self.create_data_condition_group()
+        dc = self.translate_to_data_condition(self.payload, dcg)
+
+        assert dc.condition == self.condition
+        assert dc.comparison is True
+        assert dc.condition_result is True
+        assert dc.condition_group == dcg

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

@@ -0,0 +1,77 @@
+from sentry.rules.base import EventState
+from sentry.rules.conditions.reappeared_event import ReappearedEventCondition
+from sentry.rules.conditions.regression_event import RegressionEventCondition
+from sentry.workflow_engine.models.data_condition import Condition
+from tests.sentry.workflow_engine.handlers.condition.test_base import ConditionTestCase
+
+
+class TestReappearedEventCondition(ConditionTestCase):
+    condition = Condition.GROUP_EVENT_ATTR_COMPARISON
+    rule_cls = ReappearedEventCondition
+    payload = {"id": ReappearedEventCondition.id}
+
+    def test(self):
+        state = EventState(
+            is_new=False,
+            is_regression=False,
+            is_new_group_environment=False,
+            has_reappeared=True,
+            has_escalated=False,
+        )
+        dc = self.create_data_condition(
+            type=Condition.GROUP_EVENT_ATTR_COMPARISON,
+            condition="state.has_reappeared",
+            comparison=True,
+            condition_result=True,
+        )
+
+        self.assert_passes(dc, self.event, state=state)
+
+        state.has_reappeared = False
+        self.assert_does_not_pass(dc, self.event, state=state)
+
+    def test_dual_write(self):
+        dcg = self.create_data_condition_group()
+        dc = self.translate_to_data_condition(self.payload, dcg)
+
+        assert dc.type == self.condition
+        assert dc.condition == "state.has_reappeared"
+        assert dc.comparison is True
+        assert dc.condition_result is True
+        assert dc.condition_group == dcg
+
+
+class TestRegressionEventCondition(ConditionTestCase):
+    condition = Condition.GROUP_EVENT_ATTR_COMPARISON
+    rule_cls = RegressionEventCondition
+    payload = {"id": RegressionEventCondition.id}
+
+    def test(self):
+        state = EventState(
+            is_new=False,
+            is_regression=True,
+            is_new_group_environment=False,
+            has_reappeared=True,
+            has_escalated=False,
+        )
+        dc = self.create_data_condition(
+            type=Condition.GROUP_EVENT_ATTR_COMPARISON,
+            condition="state.is_regression",
+            comparison=True,
+            condition_result=True,
+        )
+
+        self.assert_passes(dc, self.event, state=state)
+
+        state.is_regression = False
+        self.assert_does_not_pass(dc, self.event, state=state)
+
+    def test_dual_write(self):
+        dcg = self.create_data_condition_group()
+        dc = self.translate_to_data_condition(self.payload, dcg)
+
+        assert dc.type == self.condition
+        assert dc.condition == "state.is_regression"
+        assert dc.comparison is True
+        assert dc.condition_result is True
+        assert dc.condition_group == dcg