fix event ruler to not evaluate all payload

bentsku · bentsku · commit c6f23142731b · 2025-03-17T12:56:21.000+01:00
diff --git a/localstack-core/localstack/services/events/event_rule_engine.py b/localstack-core/localstack/services/events/event_rule_engine.py
@@ -43,7 +43,7 @@ def _evaluate_nested_event_pattern_on_dict(self, event_pattern, payload: dict) -
 
         # TODO: maybe save/cache the flattened/expanded pattern?
         flat_pattern_conditions = self.flatten_pattern(event_pattern)
-        flat_payloads = self.flatten_payload(payload)
+        flat_payloads = self.flatten_payload(payload, flat_pattern_conditions)
 
         return any(
             all(
@@ -59,9 +59,6 @@ def _evaluate_nested_event_pattern_on_dict(self, event_pattern, payload: dict) -
             for flat_pattern in flat_pattern_conditions
         )
 
-    def _build_event_branches(self, pattern, event):
-        pass
-
     def _evaluate_condition(self, value, condition, field_exists: bool):
         if not isinstance(condition, dict):
             return field_exists and value == condition
@@ -150,7 +147,7 @@ def _evaluate_cidr(condition: str, value: str) -> bool:
 
     @staticmethod
     def _evaluate_wildcard(condition: str, value: str) -> bool:
-        return re.match(re.escape(condition).replace("\\*", ".+") + "$", value)
+        return bool(re.match(re.escape(condition).replace("\\*", ".+") + "$", value))
 
     @staticmethod
     def _evaluate_numeric_condition(conditions: list, value: t.Any) -> bool:
@@ -240,18 +237,24 @@ def _traverse_event_pattern(obj, array=None, parent_key=None) -> list:
         return _traverse_event_pattern(nested_dict)
 
     @staticmethod
-    def flatten_payload(nested_dict: dict) -> list[dict]:
+    def flatten_payload(payload: dict, patterns: list[dict]) -> list[dict]:
         """
         Takes a dictionary as input and will output the dictionary on a single level.
         The dictionary can have lists containing other dictionaries, and one root level entry will be created for every
-        item in a list.
+        item in a list if it corresponds to the entries of the patterns.
         Input:
+        payload:
         `{"field1": {
             "field2: [
                 {"field3: "val1", "field4": "val2"},
                 {"field3: "val3", "field4": "val4"},
             }
         ]}`
+        patterns:
+        `[
+            "field1.field2.field3": <condition>,
+            "field1.field2.field4": <condition>,
+        ]`
         Output:
         `[
             {
@@ -263,16 +266,25 @@ def flatten_payload(nested_dict: dict) -> list[dict]:
                 "field1.field2.field4": "val4"
             },
         ]`
-        :param nested_dict: a (nested) dictionary
+        :param payload: a (nested) dictionary, the event payload
+        :param patterns: the flattened patterns from the EventPattern (see flatten_pattern)
         :return: flatten_dict: a dictionary with no nested dict inside, flattened to a single level
         """
+        patterns_keys = {key for keys in patterns for key in keys}
+
+        def _is_key_in_patterns(key: str) -> bool:
+            return key is None or any(pattern_key.startswith(key) for pattern_key in patterns_keys)
 
         def _traverse(_object: dict, array=None, parent_key=None) -> list:
             if isinstance(_object, dict):
                 for key, values in _object.items():
-                    # We update the parent key do that {"key1": {"key2": ""}} becomes "key1.key2"
+                    # We update the parent key so that {"key1": {"key2": ""}} becomes "key1.key2"
                     _parent_key = f"{parent_key}.{key}" if parent_key else key
-                    array = _traverse(values, array, _parent_key)
+
+                    # we make sure that we are building only the relevant parts of the payload related to the pattern
+                    # the payload could be very complex, and the pattern only applies to part of it
+                    if _is_key_in_patterns(_parent_key):
+                        array = _traverse(values, array, _parent_key)
 
             elif isinstance(_object, list):
                 if not _object:
@@ -282,7 +294,7 @@ def _traverse(_object: dict, array=None, parent_key=None) -> list:
                 array = [{**item, parent_key: _object} for item in array]
             return array
 
-        return _traverse(nested_dict, array=[{}], parent_key=None)
+        return _traverse(payload, array=[{}], parent_key=None)
 
 
 class EventPatternCompiler:
diff --git a/tests/unit/services/events/test_event_ruler.py b/tests/unit/services/events/test_event_ruler.py
@@ -0,0 +1,69 @@
+import pytest
+
+from localstack.services.events.event_rule_engine import EventRuleEngine
+
+
+class TestEventRuler:
+    @pytest.mark.parametrize(
+        "input_pattern,flat_patterns",
+        [
+            (
+                {"filter": [{"anything-but": {"prefix": "type"}}]},
+                [{"filter": [{"anything-but": {"prefix": "type"}}]}],
+            ),
+            (
+                {"field1": {"field2": {"field3": "val1", "field4": "val2"}}},
+                [{"field1.field2.field3": "val1", "field1.field2.field4": "val2"}],
+            ),
+            (
+                {"$or": [{"field1": "val1"}, {"field2": "val2"}], "field3": "val3"},
+                [{"field1": "val1", "field3": "val3"}, {"field2": "val2", "field3": "val3"}],
+            ),
+        ],
+        ids=["simple", "simple-with-dots", "$or-pattern"],
+    )
+    def test_flatten_patterns(self, input_pattern, flat_patterns):
+        engine = EventRuleEngine()
+        assert engine.flatten_pattern(input_pattern) == flat_patterns
+
+    @pytest.mark.parametrize(
+        "input_payload,flat_patterns,flat_payload",
+        [
+            (
+                {"field1": "val1", "field3": "val3"},
+                [{"field1": "val1", "field3": "val3"}, {"field2": "val2", "field3": "val3"}],
+                [{"field1": "val1", "field3": "val3"}],
+            ),
+            (
+                {"f1": {"f2": {"f3": "v3"}}, "f4": "v4"},
+                [{"f4": "test1"}],
+                [{"f4": "v4"}],
+            ),
+            (
+                {"f1": {"f2": {"f3": {"f4": [{"f5": "v5"}]}, "f6": [{"f8": "v8"}]}}},
+                [{"f1.f2.f3": "val1", "f1.f2.f4": "val2"}],
+                [{}],
+            ),
+            (
+                {"f1": {"f2": {"f3": {"f4": [{"f5": "v5"}]}, "f6": [{"f7": "v7"}]}}},
+                [{"f1.f2.f3.f4.f5": "val1", "f1.f2.f4": "val2"}],
+                [{"f1.f2.f3.f4.f5": "v5"}],
+            ),
+            (
+                {"f1": {"f2": {"f3": {"f4": [{"f5": "v5"}]}, "f6": [{"f7": "v7"}]}}},
+                [{"f1.f2.f3.f4.f5": "test1", "f1.f2.f6.f7": "test2"}],
+                [{"f1.f2.f3.f4.f5": "v5", "f1.f2.f6.f7": "v7"}],
+            ),
+        ],
+        ids=[
+            "simple-with-or-pattern-flat",
+            "simple-pattern-filter",
+            "nested-payload-no-result",
+            "nested-payload-1-match",
+            "nested-payload-2-match",
+        ],
+    )
+    def test_flatten_payload(self, input_payload, flat_patterns, flat_payload):
+        engine = EventRuleEngine()
+
+        assert engine.flatten_payload(input_payload, flat_patterns) == flat_payload
