ref(grouping): Cache enhancements in split form (#92000)

Right now, even when we're using split enhancements, the version we cache isn't split, which means that every time we pull them out of the cache, the work to split the rules has to be done all over again. This is obviously not ideal, so this PR changes the way we compute (and parse) the cached string so that it now includes the split rules.

Since the rust enhancer can only parse base64 strings including one set of rules, this is done by computing a separate string for each of the three kinds of rules - rules in their original/pre-split form, classifier rules, and contributes rules - and then concatenating them, separated by a character which can't ever appear in base64. Older base64 strings containing only the original rules and no delimiter can still be parsed, because for them, splitting on the delimiter will be a no-op.

Author: lobsterkatie

src/sentry/grouping/enhancer/__init__.py

@@ -44,6 +44,10 @@
 ]
 LATEST_VERSION = VERSIONS[-1]
 
+# A delimiter to insert between rulesets in the base64 represenation of enhancements (by spec,
+# base64 strings never contain '#')
+BASE64_ENHANCEMENTS_DELIMITER = b"#"
+
 VALID_PROFILING_MATCHER_PREFIXES = (
     "stack.abs_path",
     "path",  # stack.abs_path alias
@@ -807,7 +811,19 @@ def _get_base64_bytes_from_rules(self, rules: list[EnhancementRule]) -> bytes:
     @cached_property
     def base64_string(self) -> str:
         """A base64 string representation of the enhancements object"""
-        base64_bytes = self._get_base64_bytes_from_rules(self.rules)
+        rulesets = [self.rules]
+
+        if self.run_split_enhancements:
+            rulesets.extend([self.classifier_rules, self.contributes_rules])
+
+        # Create a base64 bytestring for each set of rules, and join them with a character we know
+        # can never appear in base64. We do it this way rather than combining all three sets of
+        # rules into a single bytestring because the rust enhancer only knows how to deal with
+        # bytestrings encoding data of the form `[version, bases, rules]` (not
+        # `[version, bases, rules, rules, rules]`).
+        base64_bytes = BASE64_ENHANCEMENTS_DELIMITER.join(
+            self._get_base64_bytes_from_rules(ruleset) for ruleset in rulesets
+        )
         base64_str = base64_bytes.decode("ascii")
         return base64_str
 
@@ -845,13 +861,25 @@ def from_base64_string(
         with metrics.timer("grouping.enhancements.creation") as metrics_timer_tags:
             metrics_timer_tags.update({"source": "base64_string", "referrer": referrer})
 
-            bytes_str = (
+            raw_bytes_str = (
                 base64_string.encode("ascii", "ignore")
                 if isinstance(base64_string, str)
                 else base64_string
             )
 
-            unsplit_config = cls._get_config_from_base64_bytes(bytes_str)
+            # Split the string to get encoded data for each set of rules: unsplit rules (i.e., rules
+            # the way they're stored in project config), classifier rules, and contributes rules.
+            # Older base64 strings - such as those stored in events created before rule-splitting was
+            # introduced - will only have one part and thus will end up unchanged. (The delimiter is
+            # chosen specifically to be a character which can't appear in base64.)
+            bytes_strs = raw_bytes_str.split(BASE64_ENHANCEMENTS_DELIMITER)
+            configs = [cls._get_config_from_base64_bytes(bytes_str) for bytes_str in bytes_strs]
+
+            unsplit_config = configs[0]
+            split_configs = None
+
+            if len(configs) == 3:
+                split_configs = (configs[1], configs[2])
 
             version = unsplit_config.version
             bases = unsplit_config.bases
@@ -861,6 +889,7 @@ def from_base64_string(
             return cls(
                 rules=unsplit_config.rules,
                 rust_enhancements=unsplit_config.rust_enhancements,
+                split_enhancement_configs=split_configs,
                 version=version,
                 bases=bases,
             )

tests/sentry/grouping/test_enhancer.py

@@ -700,8 +700,8 @@ def test_loads_split_enhancements_from_base64_string(self, split_rules_spy: Magi
             == "<EnhancementRule function:playFetch +group>"
         )
         assert strategy_config.enhancements.id is None
-        # Currently we re-split the rules when translating from base64 back to object
-        assert split_rules_spy.call_count == 2
+        # Rules didn't have to be split again because they were cached in split form
+        assert split_rules_spy.call_count == 1
 
     def test_uses_default_enhancements_when_loading_string_with_invalid_version(self):
         enhancements = Enhancements.from_rules_text("function:playFetch +app")