ref(rules): Handle action match in delayed rule processor (#69797)

Another follow up to #69167,
specifically the [comment about handling any and all action
matches](#69167 (comment))
to check if the rule is for "any" or "all" conditions and only add to
the list to be fired if it matches accordingly.

Author: ceorourke

src/sentry/rules/processing/delayed_processing.py

@@ -61,10 +61,8 @@ def get_rules_to_groups(rulegroup_to_events: dict[str, str]) -> DefaultDict[int,
 
 def get_rule_to_slow_conditions(
     alert_rules: list[Rule],
-) -> DefaultDict[Rule, list[MutableMapping[str, str] | None]]:
-    rule_to_slow_conditions: DefaultDict[Rule, list[MutableMapping[str, str] | None]] = defaultdict(
-        list
-    )
+) -> DefaultDict[Rule, list[MutableMapping[str, str]]]:
+    rule_to_slow_conditions: DefaultDict[Rule, list[MutableMapping[str, str]]] = defaultdict(list)
     for rule in alert_rules:
         slow_conditions = get_slow_conditions(rule)
         for condition_data in slow_conditions:
@@ -141,25 +139,34 @@ def get_condition_group_results(
 
 def get_rules_to_fire(
     condition_group_results: dict[UniqueCondition, dict[int, int]],
-    rule_to_slow_conditions: DefaultDict[Rule, list[MutableMapping[str, str] | None]],
+    rule_to_slow_conditions: DefaultDict[Rule, list[MutableMapping[str, str]]],
     rules_to_groups: DefaultDict[int, set[int]],
 ) -> DefaultDict[Rule, set[int]]:
     rules_to_fire = defaultdict(set)
     for alert_rule, slow_conditions in rule_to_slow_conditions.items():
-        for slow_condition in slow_conditions:
-            if slow_condition:
-                condition_id = slow_condition.get("id")
-                condition_interval = slow_condition.get("interval")
-                target_value = int(str(slow_condition.get("value")))
-                for condition_data, results in condition_group_results.items():
-                    if (
-                        alert_rule.environment_id == condition_data.environment_id
-                        and condition_id == condition_data.cls_id
-                        and condition_interval == condition_data.interval
-                    ):
-                        for group_id in rules_to_groups[alert_rule.id]:
-                            if results[group_id] > target_value:
-                                rules_to_fire[alert_rule].add(group_id)
+        action_match = alert_rule.data.get("action_match", "any")
+        for group_id in rules_to_groups[alert_rule.id]:
+            conditions_matched = 0
+            for slow_condition in slow_conditions:
+                unique_condition = UniqueCondition(
+                    str(slow_condition.get("id")),
+                    str(slow_condition.get("interval")),
+                    alert_rule.environment_id,
+                )
+                results = condition_group_results.get(unique_condition, {})
+                if results:
+                    target_value = int(str(slow_condition.get("value")))
+                    if results[group_id] > target_value:
+                        if action_match == "any":
+                            rules_to_fire[alert_rule].add(group_id)
+                            break
+                        conditions_matched += 1
+                    else:
+                        if action_match == "all":
+                            # We failed to match all conditions for this group, skip
+                            break
+            if action_match == "all" and conditions_matched == len(slow_conditions):
+                rules_to_fire[alert_rule].add(group_id)
     return rules_to_fire
 
 

tests/sentry/rules/processing/test_delayed_processing.py

@@ -22,7 +22,9 @@
 
 
 class ProcessDelayedAlertConditionsTest(TestCase, APITestCase, BaseEventFrequencyPercentTest):
-    def create_event(self, project_id, timestamp, fingerprint, environment=None) -> Event:
+    def create_event(
+        self, project_id, timestamp, fingerprint, environment=None, user: bool = True
+    ) -> Event:
         data = {
             "timestamp": iso_format(timestamp),
             "stacktrace": copy.deepcopy(DEFAULT_EVENT_DATA["stacktrace"]),
@@ -70,7 +72,7 @@ def setUp(self):
         self.event_frequency_condition3 = self.create_event_frequency_condition(
             interval="1h", value=1
         )
-        user_frequency_condition = self.create_event_frequency_condition(
+        self.user_frequency_condition = self.create_event_frequency_condition(
             interval="1m",
             id="EventUniqueUserFrequencyCondition",
         )
@@ -91,7 +93,7 @@ def setUp(self):
         assert self.group1
 
         self.rule2 = self.create_project_rule(
-            project=self.project, condition_match=[user_frequency_condition]
+            project=self.project, condition_match=[self.user_frequency_condition]
         )
         self.event2 = self.create_event(self.project, self.now, "group-2", self.environment.name)
         self.create_event(self.project, self.now, "group-2", self.environment.name)
@@ -266,3 +268,45 @@ def test_apply_delayed_two_rules_one_fires(self):
             rules = apply_delayed(self.project.id)
             assert self.rule1 in rules
             assert no_fire_rule not in rules
+
+    def test_apply_delayed_action_match_all(self):
+        """
+        Test that a rule with multiple conditions and an action match of 'all' is scheduled to fire
+        """
+        two_conditions_match_all_rule = self.create_project_rule(
+            project=self.project,
+            condition_match=[self.event_frequency_condition, self.user_frequency_condition],
+            environment_id=self.environment.id,
+        )
+        event5 = self.create_event(self.project.id, self.now, "group-5", self.environment.name)
+        self.create_event(self.project.id, self.now, "group-5", self.environment.name)
+        group5 = event5.group
+        assert group5
+        event6 = self.create_event(
+            self.project.id, self.now, "group-6", self.environment.name, user=False
+        )
+        self.create_event(self.project.id, self.now, "group-5", self.environment.name, user=False)
+        group6 = event6.group
+        assert group6
+        assert self.group1
+        assert self.group2
+        condition_wont_pass_rule = self.create_project_rule(
+            project=self.project,
+            condition_match=[self.create_event_frequency_condition(value=100)],
+            environment_id=self.environment.id,
+        )
+
+        self.push_to_hash(
+            self.project.id, two_conditions_match_all_rule.id, group5.id, event5.event_id
+        )
+
+        with patch("sentry.buffer.backend.get_hash", self.redis_buffer.get_hash):
+            rules = apply_delayed(self.project.id)
+            assert self.rule1 in rules
+            assert self.group1.id in rules[self.rule1]
+            assert self.rule2 in rules
+            assert self.group2.id in rules[self.rule2]
+            assert two_conditions_match_all_rule in rules
+            assert group5.id in rules[two_conditions_match_all_rule]
+            assert group6.id not in rules[two_conditions_match_all_rule]
+            assert condition_wont_pass_rule not in rules