chore(post-process): Remove Event.build_group_events (#69472)

This isn't necessary anymore - events can have at most one group, and so
we can use `Event.for_group` instead. We'll probably continue
simplifying this more.

Author: wedamija

src/sentry/eventstore/models.py

@@ -3,7 +3,7 @@
 import abc
 import logging
 import string
-from collections.abc import Generator, Mapping, MutableMapping, Sequence
+from collections.abc import Mapping, MutableMapping, Sequence
 from copy import deepcopy
 from datetime import datetime, timezone
 from hashlib import md5
@@ -703,13 +703,6 @@ def groups(self, values: Sequence[Group] | None):
         self._groups_cache = values
         self._group_ids = [group.id for group in values] if values else None
 
-    def build_group_events(self) -> Generator[GroupEvent, None, None]:
-        """
-        Yields a GroupEvent for each Group associated with this Event.
-        """
-        for group in self.groups:
-            yield GroupEvent.from_event(self, group)
-
     def for_group(self, group: Group) -> GroupEvent:
         return GroupEvent.from_event(self, group)
 

src/sentry/tasks/post_process.py

@@ -2,7 +2,7 @@
 
 import logging
 import uuid
-from collections.abc import Mapping, Sequence
+from collections.abc import Sequence
 from datetime import datetime, timedelta
 from time import time
 from typing import TYPE_CHECKING, Any, TypedDict
@@ -55,7 +55,7 @@
 
 
 class PostProcessJob(TypedDict, total=False):
-    event: Event | GroupEvent
+    event: GroupEvent
     group_state: GroupState
     is_reprocessed: bool
     has_reappeared: bool
@@ -667,34 +667,24 @@ def get_event_raise_exception() -> Event:
                 "is_new_group_environment": is_new_group_environment,
             }
 
-            update_event_group(event, group_state)
+            group_event = update_event_group(event, group_state)
             bind_organization_context(event.project.organization)
             _capture_event_stats(event)
             if should_update_escalating_metrics(event, is_transaction_event):
                 _update_escalating_metrics(event)
 
-            group_events: Mapping[int, GroupEvent] = {
-                ge.group_id: ge for ge in list(event.build_group_events())
-            }
-            if occurrence is not None:
-                for ge in group_events.values():
-                    ge.occurrence = occurrence
+            group_event.occurrence = occurrence
 
             group_job: PostProcessJob = {
-                "event": group_events[group_state["id"]],
+                "event": group_event,
                 "group_state": group_state,
                 "is_reprocessed": is_reprocessed,
                 "has_reappeared": bool(not group_state["is_new"]),
                 "has_alert": False,
                 "has_escalated": False,
             }
             run_post_process_job(group_job)
-
-            if group_events:
-                # In practice, we only have one group here and will be removing the list of jobs. For now, just grab a
-                # random one
-                group_event = list(group_events.values())[0]
-                metric_tags["occurrence_type"] = group_event.group.issue_type.slug
+            metric_tags["occurrence_type"] = group_event.group.issue_type.slug
 
         if not is_reprocessed and event.data.get("received"):
             duration = time() - event.data["received"]
@@ -795,7 +785,7 @@ def process_event(data: dict, group_id: int | None) -> Event:
     return event
 
 
-def update_event_group(event: Event, group_state: GroupState) -> None:
+def update_event_group(event: Event, group_state: GroupState) -> GroupEvent:
     # NOTE: we must pass through the full Event object, and not an
     # event_id since the Event object may not actually have been stored
     # in the database due to sampling.
@@ -821,6 +811,7 @@ def update_event_group(event: Event, group_state: GroupState) -> None:
         event.group = rebound_group
 
     event.groups = [rebound_group]
+    return event.for_group(rebound_group)
 
 
 def process_inbox_adds(job: PostProcessJob) -> None:

tests/sentry/eventstore/test_models.py

@@ -534,57 +534,6 @@ def test_from_group_snuba(self):
         assert event.groups == [self.group]
 
 
-class EventBuildGroupEventsTest(TestCase):
-    def test_none(self):
-        event = Event(
-            event_id="a" * 32,
-            data={
-                "level": "info",
-                "message": "Foo bar",
-                "culprit": "app/components/events/eventEntries in map",
-                "type": "transaction",
-                "contexts": {"trace": {"trace_id": "b" * 32, "span_id": "c" * 16, "op": ""}},
-            },
-            project_id=self.project.id,
-        )
-        assert list(event.build_group_events()) == []
-
-    def test(self):
-        event = Event(
-            event_id="a" * 32,
-            data={
-                "level": "info",
-                "message": "Foo bar",
-                "culprit": "app/components/events/eventEntries in map",
-                "type": "transaction",
-                "contexts": {"trace": {"trace_id": "b" * 32, "span_id": "c" * 16, "op": ""}},
-            },
-            project_id=self.project.id,
-            groups=[self.group],
-        )
-        assert list(event.build_group_events()) == [GroupEvent.from_event(event, self.group)]
-
-    def test_multiple(self):
-        self.group_2 = self.create_group()
-        event = Event(
-            event_id="a" * 32,
-            data={
-                "level": "info",
-                "message": "Foo bar",
-                "culprit": "app/components/events/eventEntries in map",
-                "type": "transaction",
-                "contexts": {"trace": {"trace_id": "b" * 32, "span_id": "c" * 16, "op": ""}},
-            },
-            project_id=self.project.id,
-            groups=[self.group, self.group_2],
-        )
-        sort_key = lambda group_event: (group_event.event_id, group_event.group_id)
-        assert sorted(event.build_group_events(), key=sort_key) == sorted(
-            [GroupEvent.from_event(event, self.group), GroupEvent.from_event(event, self.group_2)],
-            key=sort_key,
-        )
-
-
 class EventForGroupTest(TestCase):
     def test(self):
         event = Event(

tests/sentry/integrations/slack/test_unfurl.py

@@ -212,7 +212,7 @@ def test_unfurl_issues(self):
         assert (
             unfurls[links[1].url]
             == SlackIssuesMessageBuilder(
-                group2, next(iter(event.build_group_events())), link_to_event=True
+                group2, event.for_group(group2), link_to_event=True
             ).build()
         )
 
@@ -242,7 +242,7 @@ def test_unfurl_issues_block_kit(self):
         assert (
             unfurls[links[1].url]
             == SlackIssuesMessageBuilder(
-                group2, next(iter(event.build_group_events())), link_to_event=True
+                group2, event.for_group(group2), link_to_event=True
             ).build()
         )
 

tests/sentry/rules/processing/test_processor.py

@@ -1,4 +1,5 @@
 from datetime import UTC, datetime, timedelta
+from typing import cast
 from unittest import mock
 from unittest.mock import patch
 
@@ -8,7 +9,7 @@
 from django.utils import timezone
 
 from sentry.constants import ObjectStatus
-from sentry.models.group import GroupStatus
+from sentry.models.group import Group, GroupStatus
 from sentry.models.grouprulestatus import GroupRuleStatus
 from sentry.models.projectownership import ProjectOwnership
 from sentry.models.rule import Rule
@@ -46,7 +47,7 @@ def passes(self, event, state):
 class RuleProcessorTest(TestCase):
     def setUp(self):
         event = self.store_event(data={}, project_id=self.project.id)
-        self.group_event = next(event.build_group_events())
+        self.group_event = event.for_group(cast(Group, event.group))
 
         Rule.objects.filter(project=self.group_event.project).delete()
         ProjectOwnership.objects.create(project_id=self.project.id, fallthrough=True)
@@ -402,7 +403,7 @@ class RuleProcessorTestFilters(TestCase):
 
     def setUp(self):
         event = self.store_event(data={}, project_id=self.project.id)
-        self.group_event = next(event.build_group_events())
+        self.group_event = event.for_group(cast(Group, event.group))
 
     @patch("sentry.constants._SENTRY_RULES", MOCK_SENTRY_RULES_WITH_FILTERS)
     def test_filter_passes(self):
@@ -591,7 +592,7 @@ def test_latest_release(self):
         self.create_release(project=self.project, version="2021-02.newRelease")
 
         event = self.store_event(data={"release": "2021-02.newRelease"}, project_id=self.project.id)
-        self.group_event = next(event.build_group_events())
+        self.group_event = event.for_group(cast(Group, event.group))
 
         Rule.objects.filter(project=self.group_event.project).delete()
         ProjectOwnership.objects.create(project_id=self.project.id, fallthrough=True)
@@ -639,7 +640,7 @@ def test_latest_release_environment(self):
             },
             project_id=self.project.id,
         )
-        self.group_event = next(event.build_group_events())
+        self.group_event = event.for_group(cast(Group, event.group))
 
         Rule.objects.filter(project=self.group_event.project).delete()
         ProjectOwnership.objects.create(project_id=self.project.id, fallthrough=True)