chore(hybrid-cloud): Break queries that depend on cross silo FKs (#45095)

Separating out the query changes from
https://github.com/getsentry/sentry/pull/44595/files

Hybrid Cloud needs to break many foreign key relationships that depend
on cross silo models. To support this, we have a new column which acts
merely as a big int referencing identifiers, but uses a eventually
consistent system to cascade or set null when deletions happen across
silos.

This PR first changes all known api and test usages of several cross
silo foreign keys in preparation for the migration that actually breaks
those foreign keys. Several more to come.

Author: corps

src/sentry/api/endpoints/project_transaction_threshold.py

@@ -90,7 +90,7 @@ def post(self, request: Request, project) -> Response:
                 )
                 project_threshold.threshold = data.get("threshold") or project_threshold.threshold
                 project_threshold.metric = data.get("metric") or project_threshold.metric
-                project_threshold.edited_by = request.user
+                project_threshold.edited_by_id = request.user.id
                 project_threshold.save()
 
                 created = False
@@ -101,7 +101,7 @@ def post(self, request: Request, project) -> Response:
                     organization=project.organization,
                     threshold=data.get("threshold", 300),
                     metric=data.get("metric", TransactionMetric.DURATION.value),
-                    edited_by=request.user,
+                    edited_by_id=request.user.id,
                 )
 
                 created = True

src/sentry/api/endpoints/project_transaction_threshold_override.py

@@ -117,7 +117,7 @@ def post(self, request: Request, organization) -> Response:
                 defaults={
                     "threshold": data["threshold"],
                     "metric": data["metric"],
-                    "edited_by": request.user,
+                    "edited_by_id": request.user.id,
                 },
             )
 

src/sentry/api/helpers/group_index/update.py

@@ -49,7 +49,7 @@
 from sentry.models.grouphistory import record_group_history_from_activity_type
 from sentry.models.groupinbox import GroupInboxRemoveAction, add_group_to_inbox
 from sentry.notifications.types import SUBSCRIPTION_REASON_MAP, GroupSubscriptionReason
-from sentry.services.hybrid_cloud.user import RpcUser
+from sentry.services.hybrid_cloud.user import RpcUser, user_service
 from sentry.signals import (
     issue_ignored,
     issue_mark_reviewed,
@@ -61,7 +61,6 @@
 from sentry.tasks.merge import merge_groups
 from sentry.types.activity import ActivityType
 from sentry.utils import metrics
-from sentry.utils.functional import extract_lazy_object
 
 from . import ACTIVITIES_COUNT, BULK_MUTATION_LIMIT, SearchFunction, delete_group_list
 from .validators import GroupValidator, ValidationError
@@ -280,10 +279,15 @@ def update_groups(
                 # no version yet
                 "version": ""
             }
+
+            serialized_user = user_service.serialize_many(
+                filter=dict(user_ids=[user.id]), as_user=user
+            )
             status_details = {
                 "inNextRelease": True,
-                "actor": serialize(extract_lazy_object(user), user),
             }
+            if serialized_user:
+                status_details["actor"] = serialized_user[0]
             res_type = GroupResolution.Type.in_next_release
             res_type_str = "in_next_release"
             res_status = GroupResolution.Status.pending
@@ -301,10 +305,15 @@ def update_groups(
                 # no version yet
                 "version": release.version
             }
+
+            serialized_user = user_service.serialize_many(
+                filter=dict(user_ids=[user.id]), as_user=user
+            )
             status_details = {
                 "inRelease": release.version,
-                "actor": serialize(extract_lazy_object(user), user),
             }
+            if serialized_user:
+                status_details["actor"] = serialized_user[0]
             res_type = GroupResolution.Type.in_release
             res_type_str = "in_release"
             res_status = GroupResolution.Status.resolved
@@ -318,10 +327,15 @@ def update_groups(
             commit = statusDetails["inCommit"]
             activity_type = ActivityType.SET_RESOLVED_IN_COMMIT.value
             activity_data = {"commit": commit.id}
+            serialized_user = user_service.serialize_many(
+                filter=dict(user_ids=[user.id]), as_user=user
+            )
+
             status_details = {
                 "inCommit": serialize(commit, user),
-                "actor": serialize(extract_lazy_object(user), user),
             }
+            if serialized_user:
+                status_details["actor"] = serialized_user[0]
             res_type_str = "in_commit"
         else:
             res_type_str = "now"
@@ -572,14 +586,18 @@ def update_groups(
                                 "actor_id": user.id if user.is_authenticated else None,
                             },
                         )
+                        serialized_user = user_service.serialize_many(
+                            filter=dict(user_ids=[user.id]), as_user=user
+                        )
                         result["statusDetails"] = {
                             "ignoreCount": ignore_count,
                             "ignoreUntil": ignore_until,
                             "ignoreUserCount": ignore_user_count,
                             "ignoreUserWindow": ignore_user_window,
                             "ignoreWindow": ignore_window,
-                            "actor": serialize(extract_lazy_object(user), user),
                         }
+                        if serialized_user:
+                            result["statusDetails"]["actor"] = serialized_user[0]
                 else:
                     GroupSnooze.objects.filter(group__in=group_ids).delete()
                     ignore_until = None

src/sentry/api/serializers/models/alert_rule.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+from typing import MutableMapping
 
 from django.db.models import Max, prefetch_related_objects
 
@@ -23,6 +24,7 @@
     fetch_actors_by_actor_ids,
 )
 from sentry.services.hybrid_cloud.app import app_service
+from sentry.services.hybrid_cloud.user import RpcUser, user_service
 from sentry.snuba.models import SnubaQueryEventType
 
 
@@ -70,26 +72,32 @@ def get_attrs(self, item_list, user, **kwargs):
             rule_result = result[alert_rules[alert_rule_id]].setdefault("projects", [])
             rule_result.append(project_slug)
 
-        for rule_activity in AlertRuleActivity.objects.filter(
-            alert_rule__in=item_list, type=AlertRuleActivityType.CREATED.value
-        ).select_related("alert_rule", "user"):
-            if rule_activity.user:
-                user = {
-                    "id": rule_activity.user.id,
-                    "name": rule_activity.user.get_display_name(),
-                    "email": rule_activity.user.email,
-                }
+        rule_activities = list(
+            AlertRuleActivity.objects.filter(
+                alert_rule__in=item_list, type=AlertRuleActivityType.CREATED.value
+            )
+        )
+
+        use_by_user_id: MutableMapping[int, RpcUser] = {
+            user.id: user
+            for user in user_service.get_many(
+                filter=dict(user_ids=[r.user_id for r in rule_activities])
+            )
+        }
+        for rule_activity in rule_activities:
+            rpc_user = use_by_user_id.get(rule_activity.user_id)
+            if rpc_user:
+                user = dict(id=rpc_user.id, name=rpc_user.get_display_name(), email=rpc_user.email)
             else:
                 user = None
+            result[alert_rules[rule_activity.alert_rule_id]]["created_by"] = user
 
-            result[alert_rules[rule_activity.alert_rule.id]].update({"created_by": user})
-
-        resolved_actors = {}
         owners_by_type = defaultdict(list)
         for item in item_list:
             if item.owner_id is not None:
                 owners_by_type[actor_type_to_string(item.owner.type)].append(item.owner_id)
 
+        resolved_actors = {}
         for k, v in ACTOR_TYPES.items():
             resolved_actors[k] = {
                 a.actor_id: a.id

src/sentry/api/serializers/models/discoversavedquery.py

@@ -1,34 +1,28 @@
 from collections import defaultdict
 
-from django.db.models.query import prefetch_related_objects
-
-from sentry.api.serializers import Serializer, register, serialize
-from sentry.api.serializers.models.user import UserSerializer
+from sentry.api.serializers import Serializer, register
 from sentry.constants import ALL_ACCESS_PROJECTS
 from sentry.discover.models import DiscoverSavedQuery
+from sentry.services.hybrid_cloud.user import user_service
 from sentry.utils.dates import outside_retention_with_modified_start, parse_timestamp
 
 
 @register(DiscoverSavedQuery)
 class DiscoverSavedQuerySerializer(Serializer):
     def get_attrs(self, item_list, user):
-        prefetch_related_objects(item_list, "created_by")
-
         result = defaultdict(lambda: {"created_by": {}})
 
-        user_serializer = UserSerializer()
-        serialized_users = {
-            user["id"]: user
-            for user in serialize(
-                [
-                    discover_saved_query.created_by
+        service_serialized = user_service.serialize_many(
+            filter={
+                "user_ids": [
+                    discover_saved_query.created_by_id
                     for discover_saved_query in item_list
-                    if discover_saved_query.created_by
-                ],
-                user=user,
-                serializer=user_serializer,
-            )
-        }
+                    if discover_saved_query.created_by_id
+                ]
+            },
+            as_user=user,
+        )
+        serialized_users = {user["id"]: user for user in service_serialized}
 
         for discover_saved_query in item_list:
             result[discover_saved_query]["created_by"] = serialized_users.get(

src/sentry/api/serializers/models/exporteddata.py

@@ -1,25 +1,31 @@
-from sentry.api.serializers import Serializer, register, serialize
+from sentry.api.serializers import Serializer, register
 from sentry.data_export.base import ExportQueryType
 from sentry.data_export.models import ExportedData
-from sentry.models import User
+from sentry.services.hybrid_cloud.user import user_service
 
 
 @register(ExportedData)
 class ExportedDataSerializer(Serializer):
     def get_attrs(self, item_list, user, **kwargs):
         attrs = {}
-        users = User.objects.filter(id__in={item.user_id for item in item_list})
-        user_lookup = {user.id: user for user in users}
+        serialized_users = {
+            u["id"]: u
+            for u in user_service.serialize_many(
+                filter=dict(user_ids=[item.user_id for item in item_list])
+            )
+        }
         for item in item_list:
-            user = user_lookup[item.user_id]
-            serialized_user = serialize(user)
-            attrs[item] = {
-                "user": {
-                    "id": serialized_user["id"],
-                    "email": serialized_user["email"],
-                    "username": serialized_user["username"],
+            if str(item.user_id) in serialized_users:
+                serialized_user = serialized_users[str(item.user_id)]
+                attrs[item] = {
+                    "user": {
+                        "id": serialized_user["id"],
+                        "email": serialized_user["email"],
+                        "username": serialized_user["username"],
+                    }
                 }
-            }
+            else:
+                attrs[item] = {}
         return attrs
 
     def serialize(self, obj, attrs, user, **kwargs):
@@ -33,7 +39,7 @@ def serialize(self, obj, attrs, user, **kwargs):
 
         return {
             "id": obj.id,
-            "user": attrs["user"],
+            "user": attrs.get("user"),
             "dateCreated": obj.date_added,
             "dateFinished": obj.date_finished,
             "dateExpired": obj.date_expired,

src/sentry/api/serializers/models/group.py

@@ -15,6 +15,7 @@
     Optional,
     Protocol,
     Sequence,
+    Set,
     Tuple,
     TypedDict,
     Union,
@@ -35,7 +36,6 @@
 from sentry.constants import LOG_LEVELS
 from sentry.issues.grouptype import GroupCategory
 from sentry.models import (
-    ActorTuple,
     Commit,
     Environment,
     Group,
@@ -183,19 +183,32 @@ def __init__(
         self.collapse = collapse
         self.expand = expand
 
-    def _serialize_assigness(
-        self, actor_dict: Mapping[int, ActorTuple]
-    ) -> Mapping[int, Union[Team, Any]]:
-        actors_by_type: MutableMapping[Any, List[ActorTuple]] = defaultdict(list)
-        for actor in actor_dict.values():
-            actors_by_type[actor.type].append(actor)
+    def _serialize_assignees(self, item_list: Sequence[Group]) -> Mapping[int, Union[Team, Any]]:
+        gas = GroupAssignee.objects.filter(group__in=item_list)
+        result: MutableMapping[int, Union[Team, Any]] = {}
+        all_team_ids: MutableMapping[int, Set[int]] = {}
+        all_user_ids: MutableMapping[int, Set[int]] = {}
+
+        for g in gas:
+            if g.team_id:
+                if g.team_id not in all_team_ids:
+                    all_team_ids[g.team_id] = {g.group_id}
+                else:
+                    all_team_ids[g.team_id].add(g.group_id)
+            if g.user_id:
+                if g.team_id not in all_team_ids:
+                    all_user_ids[g.user_id] = {g.group_id}
+                else:
+                    all_user_ids[g.user_id].add(g.group_id)
+
+        for team in Team.objects.filter(id__in=all_team_ids.keys()):
+            for group_id in all_team_ids[team.id]:
+                result[group_id] = team
+        for user in user_service.get_many(filter=dict(user_ids=list(all_user_ids.keys()))):
+            for group_id in all_user_ids[user.id]:
+                result[group_id] = user
 
-        resolved_actors = {}
-        for t, actors in actors_by_type.items():
-            serializable = ActorTuple.resolve_many(actors)
-            resolved_actors[t] = {actor.id: actor for actor in serializable}
-
-        return {key: resolved_actors[value.type][value.id] for key, value in actor_dict.items()}
+        return result
 
     def get_attrs(
         self, item_list: Sequence[Group], user: Any, **kwargs: Any
@@ -223,11 +236,7 @@ def get_attrs(
             seen_groups = {}
             subscriptions = defaultdict(lambda: (False, False, None))
 
-        assignees: Mapping[int, ActorTuple] = {
-            a.group_id: a.assigned_actor()
-            for a in GroupAssignee.objects.filter(group__in=item_list)
-        }
-        resolved_assignees = self._serialize_assigness(assignees)
+        resolved_assignees = self._serialize_assignees(item_list)
 
         ignore_items = {g.group_id: g for g in GroupSnooze.objects.filter(group__in=item_list)}
 

src/sentry/api/serializers/models/incident.py

@@ -44,9 +44,7 @@ def get_attrs(self, item_list, user, **kwargs):
 
         if "seen_by" in self.expand:
             incident_seen_list = list(
-                IncidentSeen.objects.filter(incident__in=item_list)
-                .select_related("user")
-                .order_by("-last_seen")
+                IncidentSeen.objects.filter(incident__in=item_list).order_by("-last_seen")
             )
             incident_seen_dict = defaultdict(list)
             for incident_seen, serialized_seen_by in zip(
@@ -108,9 +106,9 @@ def get_attrs(self, item_list, user, **kwargs):
         subscribed_incidents = set()
         if user.is_authenticated:
             subscribed_incidents = set(
-                IncidentSubscription.objects.filter(incident__in=item_list, user=user).values_list(
-                    "incident_id", flat=True
-                )
+                IncidentSubscription.objects.filter(
+                    incident__in=item_list, user_id=user.id
+                ).values_list("incident_id", flat=True)
             )
 
         for item in item_list:

src/sentry/api/serializers/models/incidentactivity.py

@@ -1,20 +1,16 @@
 from django.db.models import prefetch_related_objects
 
-from sentry.api.serializers import Serializer, register, serialize
-from sentry.api.serializers.models.user import UserSerializer
+from sentry.api.serializers import Serializer, register
 from sentry.incidents.models import IncidentActivity
+from sentry.services.hybrid_cloud.user import user_service
 
 
 @register(IncidentActivity)
 class IncidentActivitySerializer(Serializer):
     def get_attrs(self, item_list, user, **kwargs):
         prefetch_related_objects(item_list, "incident__organization")
-        prefetch_related_objects(item_list, "user")
-        user_serializer = UserSerializer()
-        serialized_users = serialize(
-            {item.user for item in item_list if item.user_id},
-            user=user,
-            serializer=user_serializer,
+        serialized_users = user_service.serialize_many(
+            filter={"user_ids": [i.user_id for i in item_list if i.user_id]}, as_user=user
         )
         user_lookup = {user["id"]: user for user in serialized_users}
         return {item: {"user": user_lookup.get(str(item.user_id))} for item in item_list}