ref(grouping): Add optional variants attribute to CalculatedHashes class (#68360)

As part of calculating grouping hashes for an event, we first put together "variants," which contain information about the results of applying various possible types of grouping (based on stacktrace, based on message, etc) to the event, as well as about how those results relate to each other in terms of what takes precedence and why, and though we store the resulting hashes on the event, we don't store the much larger `variants` data structure. This means that when we want access to variant data, we need to recalculate it. So far, it's only powered two features (other than the initial hash calculations) - showing grouping info at the bottom of the issue details page and making sure that seer-derived similar issues on the Similar Issues tab are based on the same normalized stacktrace used for grouping. In both cases, the relative infrequency with which those features are used and their separation from ingestion have made it worthwhile for us to pay the time penalty of the recalculation rather than store a whole bunch more data on every event.

Now we want to use seer to find similar issues during ingestion as well, though. In the long run, that may mean that we end up storing some variant information on the event. In the short run, it means that at minimum, we don't want to have to calculate the variants twice during ingest. This therefore propagates variant information farther on in the ingest pipeline, by adding it to the `CalculatedHashes` data structure we use to carry hash values from the actual calculation machinery to where those values are used.

Author: lobsterkatie

src/sentry/eventstore/models.py

@@ -368,7 +368,10 @@ def get_hashes(self, force_config: StrategyConfiguration | None = None) -> Calcu
         hierarchical_hashes = [hash_ for _, hash_ in hierarchical_hashes]
 
         return CalculatedHashes(
-            hashes=flat_hashes, hierarchical_hashes=hierarchical_hashes, tree_labels=tree_labels
+            hashes=flat_hashes,
+            hierarchical_hashes=hierarchical_hashes,
+            tree_labels=tree_labels,
+            variants=[*flat_variants, *hierarchical_variants],
         )
 
     def get_sorted_grouping_variants(self, force_config: StrategyConfiguration | None = None):

src/sentry/grouping/result.py

@@ -3,6 +3,7 @@
 from typing import Any, Optional, TypedDict
 
 from sentry.db.models import NodeData
+from sentry.grouping.variants import BaseVariant
 from sentry.utils.safe import get_path, safe_execute, set_path
 
 EventMetadata = dict[str, Any]
@@ -99,6 +100,7 @@ class CalculatedHashes:
     hashes: Sequence[str]
     hierarchical_hashes: Sequence[str]
     tree_labels: Sequence[TreeLabel | None]
+    variants: list[tuple[str, BaseVariant]] | None = None
 
     def write_to_event(self, event_data: NodeData) -> None:
         event_data["hashes"] = self.hashes

tests/sentry/eventstore/test_models.py

@@ -6,8 +6,10 @@
 from sentry import eventstore, nodestore
 from sentry.db.models.fields.node import NodeData, NodeIntegrityFailure
 from sentry.eventstore.models import Event, GroupEvent
-from sentry.grouping.api import GroupingConfig
+from sentry.grouping.api import GroupingConfig, get_grouping_variants_for_event
 from sentry.grouping.enhancer import Enhancements
+from sentry.grouping.result import CalculatedHashes
+from sentry.grouping.utils import hash_from_values
 from sentry.interfaces.user import User
 from sentry.issues.issue_occurrence import IssueOccurrence
 from sentry.models.environment import Environment
@@ -21,6 +23,8 @@
 
 pytestmark = [requires_snuba]
 
+NEWSTYLE_GROUPING_CONFIG = "newstyle:2023-01-11"
+
 
 class EventTest(TestCase, PerformanceIssueTestCase):
     def test_pickling_compat(self):
@@ -394,6 +398,65 @@ def test_grouping_reset(self):
             v.as_dict()["hash"] for v in variants2.values()
         )
 
+    def test_get_hashes_pulls_existing_hashes(self):
+        hashes = ["04e89719410791836f0a0bbf03bf0d2e"]
+        event = Event(
+            event_id="11212012123120120415201309082013",
+            data={
+                "message": "Dogs are great!",
+                "hashes": hashes,
+            },
+            project_id=self.project.id,
+        )
+
+        assert event.get_hashes() == CalculatedHashes(hashes, [], [], None)
+
+    def test_get_hashes_gets_hashes_and_variants_if_none_on_event(self):
+        self.project.update_option("sentry:grouping_config", NEWSTYLE_GROUPING_CONFIG)
+        event = Event(
+            event_id="11212012123120120415201309082013",
+            data={"message": "Dogs are great!"},
+            project_id=self.project.id,
+        )
+
+        calculated_hashes = event.get_hashes()
+        expected_hash_values = [hash_from_values(["Dogs are great!"])]
+        expected_variants = list(get_grouping_variants_for_event(event).items())
+
+        assert calculated_hashes.hashes == expected_hash_values
+        assert (
+            calculated_hashes.variants is not None
+            and len(calculated_hashes.variants) == len(expected_variants) == 1
+        )
+
+        variant_key, variant = calculated_hashes.variants[0]
+        expected_variant_key, expected_variant = expected_variants[0]
+        variant_dict = variant._get_metadata_as_dict()
+        expected_variant_dict = expected_variant._get_metadata_as_dict()
+
+        assert variant_key == expected_variant_key == "default"
+        assert (
+            variant_dict["config"]["id"]
+            == expected_variant_dict["config"]["id"]
+            == NEWSTYLE_GROUPING_CONFIG
+        )
+        assert (
+            variant_dict["component"]["id"] == expected_variant_dict["component"]["id"] == "default"
+        )
+        assert (
+            len(variant_dict["component"]["values"])
+            == len(expected_variant_dict["component"]["values"])
+            == 1
+        )
+
+        component_value = variant_dict["component"]["values"][0]
+        expected_component_value = expected_variant_dict["component"]["values"][0]
+
+        assert component_value["id"] == expected_component_value["id"] == "message"
+        assert (
+            component_value["values"] == expected_component_value["values"] == ["Dogs are great!"]
+        )
+
 
 class EventGroupsTest(TestCase):
     def test_none(self):