feat(uptime): Add serializer for uptime monitors and include them in the combined alert serializer (#74612)

This adds a serializer for uptime monitors, and also adds them to the
combined alert serializer so that we can include them in the combined
alerts endpoint results.

Also adds in a feature flag for gating access to showing these in the
api

<!-- Describe your PR here. -->

Author: wedamija

src/sentry/features/temporary.py

@@ -467,6 +467,8 @@ def register_temporary_features(manager: FeatureManager):
     manager.add("organizations:uptime-automatic-hostname-detection", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE)
     # Enables automatic subscription creation in uptime
     manager.add("organizations:uptime-automatic-subscription-creation", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE)
+    # Enabled returning uptime monitors from the rule api
+    manager.add("organizations:uptime-rule-api", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE)
     # Enables uptime related settings for projects and orgs
     manager.add('organizations:uptime-settings', OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE)
     manager.add("organizations:use-metrics-layer", OrganizationFeature, FeatureHandlerStrategy.REMOTE)

src/sentry/incidents/endpoints/serializers/alert_rule.py

@@ -30,6 +30,7 @@
 from sentry.sentry_apps.services.app import app_service
 from sentry.sentry_apps.services.app.model import RpcSentryAppComponentContext
 from sentry.snuba.models import SnubaQueryEventType
+from sentry.uptime.models import ProjectUptimeSubscription
 from sentry.users.services.user import RpcUser
 from sentry.users.services.user.service import user_service
 
@@ -395,6 +396,14 @@ def get_attrs(
             serialized_rule["id"]: serialized_rule for serialized_rule in serialized_issue_rules
         }
 
+        serialized_uptime_monitors = serialize(
+            [x for x in item_list if isinstance(x, ProjectUptimeSubscription)],
+            user=user,
+        )
+        serialized_uptime_monitor_map_by_id = {
+            item["id"]: item for item in serialized_uptime_monitors
+        }
+
         for item in item_list:
             item_id = str(item.id)
             if item_id in serialized_alert_rule_map_by_id:
@@ -418,6 +427,9 @@ def get_attrs(
             elif item_id in serialized_issue_rule_map_by_id:
                 # This is an issue alert rule
                 results[item] = serialized_issue_rule_map_by_id[item_id]
+            elif item_id in serialized_uptime_monitor_map_by_id:
+                # This is an uptime monitor
+                results[item] = serialized_uptime_monitor_map_by_id[item_id]
             else:
                 logger.error(
                     "Alert Rule found but dropped during serialization",
@@ -432,18 +444,18 @@ def get_attrs(
 
     def serialize(
         self,
-        obj: Rule | AlertRule,
+        obj: Rule | AlertRule | ProjectUptimeSubscription,
         attrs: Mapping[Any, Any],
         user: User | RpcUser,
         **kwargs: Any,
     ) -> MutableMapping[Any, Any]:
+        updated_attrs = {**attrs}
         if isinstance(obj, AlertRule):
-            alert_rule_attrs: MutableMapping[Any, Any] = {**attrs}
-            alert_rule_attrs["type"] = "alert_rule"
-            return alert_rule_attrs
+            updated_attrs["type"] = "alert_rule"
         elif isinstance(obj, Rule):
-            rule_attrs: MutableMapping[Any, Any] = {**attrs}
-            rule_attrs["type"] = "rule"
-            return rule_attrs
+            updated_attrs["type"] = "rule"
+        elif isinstance(obj, ProjectUptimeSubscription):
+            updated_attrs["type"] = "uptime"
         else:
             raise AssertionError(f"Invalid rule to serialize: {type(obj)}")
+        return updated_attrs

src/sentry/testutils/factories.py

@@ -152,11 +152,13 @@
 from sentry.testutils.outbox import outbox_runner
 from sentry.testutils.silo import assume_test_silo_mode
 from sentry.types.activity import ActivityType
+from sentry.types.actor import Actor
 from sentry.types.region import Region, get_local_region, get_region_by_name
 from sentry.types.token import AuthTokenType
 from sentry.uptime.models import (
     ProjectUptimeSubscription,
     ProjectUptimeSubscriptionMode,
+    UptimeStatus,
     UptimeSubscription,
 )
 from sentry.users.services.user import RpcUser
@@ -1950,9 +1952,24 @@ def create_project_uptime_subscription(
         project: Project,
         uptime_subscription: UptimeSubscription,
         mode: ProjectUptimeSubscriptionMode,
+        name: str,
+        owner: Actor | None,
+        uptime_status: UptimeStatus,
     ):
+        owner_team_id = None
+        owner_user_id = None
+        if owner:
+            if owner.is_team:
+                owner_team_id = owner.id
+            elif owner.is_user:
+                owner_user_id = owner.id
+
         return ProjectUptimeSubscription.objects.create(
             uptime_subscription=uptime_subscription,
             project=project,
             mode=mode,
+            name=name,
+            owner_team_id=owner_team_id,
+            owner_user_id=owner_user_id,
+            uptime_status=uptime_status,
         )

src/sentry/testutils/fixtures.py

@@ -22,6 +22,7 @@
 from sentry.models.project import Project
 from sentry.models.projecttemplate import ProjectTemplate
 from sentry.models.rule import Rule
+from sentry.models.team import Team
 from sentry.models.user import User
 from sentry.monitors.models import Monitor, MonitorType, ScheduleType
 from sentry.organizations.services.organization import RpcOrganization
@@ -34,9 +35,11 @@
 # all of the memoized fixtures are copypasta due to our inability to use pytest fixtures
 # on a per-class method basis
 from sentry.types.activity import ActivityType
+from sentry.types.actor import Actor
 from sentry.uptime.models import (
     ProjectUptimeSubscription,
     ProjectUptimeSubscriptionMode,
+    UptimeStatus,
     UptimeSubscription,
 )
 from sentry.users.services.user import RpcUser
@@ -647,13 +650,23 @@ def create_project_uptime_subscription(
         project: Project | None = None,
         uptime_subscription: UptimeSubscription | None = None,
         mode=ProjectUptimeSubscriptionMode.AUTO_DETECTED_ACTIVE,
+        name="Test Name",
+        owner: User | Team | None = None,
+        uptime_status=UptimeStatus.OK,
     ) -> ProjectUptimeSubscription:
         if project is None:
             project = self.project
 
         if uptime_subscription is None:
             uptime_subscription = self.create_uptime_subscription()
-        return Factories.create_project_uptime_subscription(project, uptime_subscription, mode)
+        return Factories.create_project_uptime_subscription(
+            project,
+            uptime_subscription,
+            mode,
+            name,
+            Actor.from_object(owner) if owner else None,
+            uptime_status,
+        )
 
     @pytest.fixture(autouse=True)
     def _init_insta_snapshot(self, insta_snapshot):

src/sentry/types/actor.py

@@ -40,7 +40,9 @@ class InvalidActor(ObjectDoesNotExist):
         pass
 
     @classmethod
-    def resolve_many(cls, actors: Sequence["Actor"]) -> list["Team | RpcUser"]:
+    def resolve_many(
+        cls, actors: Sequence["Actor"], filter_none: bool = True
+    ) -> list["Team | RpcUser | None"]:
         """
         Resolve a list of actors in a batch to the Team/User the Actor references.
 
@@ -64,7 +66,10 @@ def resolve_many(cls, actors: Sequence["Actor"]) -> list["Team | RpcUser"]:
                 for team in Team.objects.filter(id__in=[t.id for t in actor_list]):
                     results[(actor_type, team.id)] = team
 
-        return list(filter(None, [results.get((actor.actor_type, actor.id)) for actor in actors]))
+        final_results = [results.get((actor.actor_type, actor.id)) for actor in actors]
+        if filter_none:
+            final_results = list(filter(None, final_results))
+        return final_results
 
     @classmethod
     def many_from_object(cls, objects: Iterable[ActorTarget]) -> list["Actor"]:

src/sentry/uptime/apps.py

@@ -5,4 +5,4 @@ class Config(AppConfig):
     name = "sentry.uptime"
 
     def ready(self):
-        pass
+        from sentry.uptime.endpoints import serializers  # NOQA

src/sentry/uptime/endpoints/__init__.py

@@ -0,0 +1,59 @@
+from collections.abc import MutableMapping, Sequence
+from typing import Any, TypedDict
+
+from django.db.models import prefetch_related_objects
+
+from sentry.api.serializers import Serializer, register, serialize
+from sentry.api.serializers.models.actor import ActorSerializer, ActorSerializerResponse
+from sentry.types.actor import Actor
+from sentry.uptime.models import ProjectUptimeSubscription
+
+
+class ProjectUptimeSubscriptionSerializerResponse(TypedDict):
+    id: str
+    projectSlug: str
+    name: str
+    status: int
+    mode: int
+    url: str
+    intervalSeconds: int
+    timeoutMs: int
+    owner: ActorSerializerResponse
+
+
+@register(ProjectUptimeSubscription)
+class ProjectUptimeSubscriptionSerializer(Serializer):
+    def __init__(self, expand=None):
+        self.expand = expand
+
+    def get_attrs(
+        self, item_list: Sequence[ProjectUptimeSubscription], user: Any, **kwargs: Any
+    ) -> MutableMapping[Any, Any]:
+        prefetch_related_objects(item_list, "uptime_subscription", "project")
+        owners = list(filter(None, [item.owner for item in item_list]))
+        owners_serialized = serialize(
+            Actor.resolve_many(owners, filter_none=False), user, ActorSerializer()
+        )
+        serialized_owner_lookup = {
+            owner: serialized_owner for owner, serialized_owner in zip(owners, owners_serialized)
+        }
+
+        return {
+            item: {"owner": serialized_owner_lookup.get(item.owner) if item.owner else None}
+            for item in item_list
+        }
+
+    def serialize(
+        self, obj: ProjectUptimeSubscription, attrs, user, **kwargs
+    ) -> ProjectUptimeSubscriptionSerializerResponse:
+        return {
+            "id": str(obj.id),
+            "projectSlug": obj.project.slug,
+            "name": obj.name,
+            "status": obj.uptime_status,
+            "mode": obj.mode,
+            "url": obj.uptime_subscription.url,
+            "intervalSeconds": obj.uptime_subscription.interval_seconds,
+            "timeoutMs": obj.uptime_subscription.timeout_ms,
+            "owner": attrs["owner"],
+        }

src/sentry/uptime/endpoints/serializers.py

@@ -11,6 +11,7 @@
 from sentry.db.models.fields.hybrid_cloud_foreign_key import HybridCloudForeignKey
 from sentry.db.models.manager.base import BaseManager
 from sentry.remote_subscriptions.models import BaseRemoteSubscription
+from sentry.types.actor import Actor
 
 
 @region_silo_model
@@ -104,3 +105,7 @@ class Meta:
                 ),
             ),
         ]
+
+    @property
+    def owner(self) -> Actor | None:
+        return Actor.from_id(user_id=self.owner_user_id, team_id=self.owner_team_id)

src/sentry/uptime/models.py

@@ -326,16 +326,21 @@ def test_combined_serializer(self):
             }
         )
         other_alert_rule = self.create_alert_rule()
+        uptime_monitor = self.create_project_uptime_subscription()
 
         result = serialize(
-            [alert_rule, issue_rule, other_alert_rule], serializer=CombinedRuleSerializer()
+            [alert_rule, issue_rule, other_alert_rule, uptime_monitor],
+            serializer=CombinedRuleSerializer(),
         )
 
         self.assert_alert_rule_serialized(alert_rule, result[0])
         assert result[1]["id"] == str(issue_rule.id)
         assert result[1]["status"] == "active"
         assert not result[1]["snooze"]
         self.assert_alert_rule_serialized(other_alert_rule, result[2])
+        serialized_uptime_monitor = serialize(uptime_monitor)
+        serialized_uptime_monitor["type"] = "uptime"
+        assert result[3] == serialized_uptime_monitor
 
     def test_alert_snoozed(self):
         projects = [self.project, self.create_project()]