feat(uptime): Include uptime monitors in the combined rule endpoint. (#74611)

This updates the combined rule endpoint to include uptime monitors if
the flag is enabled. These monitors will be sorted to the top of the
list if failed, and then lower down with issue alerts if they're in an
ok state.

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

Author: wedamija

src/sentry/api/paginator.py

@@ -659,6 +659,8 @@ def _sort_combined_querysets(item):
             sort_keys = []
             sort_keys.append(self.get_item_key(item))
             if len(self.model_key_map.get(type(item))) > 1:
+                # XXX: This doesn't do anything - it just uses a column name as the sort key. It should be pulling the
+                # value of the other keys out instead.
                 sort_keys.extend(iter(self.model_key_map.get(type(item))[1:]))
             sort_keys.append(type(item).__name__)
             return tuple(sort_keys)

src/sentry/incidents/endpoints/organization_alert_rule_index.py

@@ -2,7 +2,7 @@
 from datetime import UTC, datetime
 
 from django.conf import settings
-from django.db.models import DateTimeField, IntegerField, OuterRef, Q, Subquery, Value
+from django.db.models import Case, DateTimeField, IntegerField, OuterRef, Q, Subquery, Value, When
 from django.db.models.functions import Coalesce
 from drf_spectacular.utils import extend_schema, extend_schema_serializer
 from rest_framework import serializers, status
@@ -35,9 +35,10 @@
     AlertRuleSerializerResponse,
     CombinedRuleSerializer,
 )
+from sentry.incidents.endpoints.utils import parse_team_params
 from sentry.incidents.logic import get_slack_actions_with_async_lookups
 from sentry.incidents.models.alert_rule import AlertRule
-from sentry.incidents.models.incident import Incident
+from sentry.incidents.models.incident import Incident, IncidentStatus
 from sentry.incidents.serializers import AlertRuleSerializer as DrfAlertRuleSerializer
 from sentry.incidents.utils.sentry_apps import trigger_sentry_app_action_creators_for_incidents
 from sentry.integrations.slack.utils import RedisRuleStatus
@@ -49,10 +50,9 @@
 from sentry.signals import alert_rule_created
 from sentry.snuba.dataset import Dataset
 from sentry.tasks.integrations.slack import find_channel_id_for_alert_rule
+from sentry.uptime.models import ProjectUptimeSubscription, UptimeStatus
 from sentry.utils.cursors import Cursor, StringCursor
 
-from .utils import parse_team_params
-
 
 class AlertRuleIndexMixin(Endpoint):
     def fetch_metric_alert(self, request, organization, project=None):
@@ -152,7 +152,7 @@ class OrganizationCombinedRuleIndexEndpoint(OrganizationEndpoint):
 
     def get(self, request: Request, organization) -> Response:
         """
-        Fetches (metric) alert rules and legacy (issue alert) rules for an organization
+        Fetches metric, issue and uptime alert rules for an organization
         """
         project_ids = self.get_requested_project_ids_unchecked(request) or None
         if project_ids == {-1}:  # All projects for org:
@@ -196,6 +196,11 @@ def get(self, request: Request, organization) -> Response:
             project__in=projects,
         )
 
+        uptime_rules = ProjectUptimeSubscription.objects.filter(project__in=projects)
+
+        if not features.has("organizations:uptime-rule-api", organization):
+            uptime_rules = ProjectUptimeSubscription.objects.none()
+
         if not features.has("organizations:performance-view", organization):
             # Filter to only error alert rules
             alert_rules = alert_rules.filter(snuba_query__dataset=Dataset.Events.value)
@@ -208,8 +213,9 @@ def get(self, request: Request, organization) -> Response:
 
         name = request.GET.get("name", None)
         if name:
-            alert_rules = alert_rules.filter(Q(name__icontains=name))
-            issue_rules = issue_rules.filter(Q(label__icontains=name))
+            alert_rules = alert_rules.filter(name__icontains=name)
+            issue_rules = issue_rules.filter(label__icontains=name)
+            uptime_rules = uptime_rules.filter(name__icontains=name)
 
         if teams_query is not None:
             team_ids = teams_query.values_list("id", flat=True)
@@ -220,6 +226,7 @@ def get(self, request: Request, organization) -> Response:
                 team_rule_condition = team_rule_condition | Q(owner_team_id__isnull=True)
             alert_rules = alert_rules.filter(team_alert_condition)
             issue_rules = issue_rules.filter(team_rule_condition)
+            uptime_rules = uptime_rules.filter(team_rule_condition)
 
         expand = request.GET.getlist("expand", [])
         if "latestIncident" in expand:
@@ -255,6 +262,14 @@ def get(self, request: Request, organization) -> Response:
             issue_rules = issue_rules.annotate(
                 incident_status=Value(-2, output_field=IntegerField())
             )
+            uptime_rules = uptime_rules.annotate(
+                incident_status=Case(
+                    # If an uptime monitor is failing we want to treat it the same as if an alert is failing, so sort
+                    # by the critical status
+                    When(uptime_status=UptimeStatus.FAILED, then=IncidentStatus.CRITICAL.value),
+                    default=-2,
+                )
+            )
 
         if "date_triggered" in sort_key:
             far_past_date = Value(datetime.min.replace(tzinfo=UTC), output_field=DateTimeField())
@@ -269,16 +284,18 @@ def get(self, request: Request, organization) -> Response:
                 ),
             )
             issue_rules = issue_rules.annotate(date_triggered=far_past_date)
+            uptime_rules = uptime_rules.annotate(date_triggered=far_past_date)
         alert_rules_count = alert_rules.count()
         issue_rules_count = issue_rules.count()
         alert_rule_intermediary = CombinedQuerysetIntermediary(alert_rules, sort_key)
         rule_intermediary = CombinedQuerysetIntermediary(issue_rules, rule_sort_key)
+        uptime_intermediary = CombinedQuerysetIntermediary(uptime_rules, rule_sort_key)
         response = self.paginate(
             request,
             paginator_cls=CombinedQuerysetPaginator,
             on_results=lambda x: serialize(x, request.user, CombinedRuleSerializer(expand=expand)),
             default_per_page=25,
-            intermediaries=[alert_rule_intermediary, rule_intermediary],
+            intermediaries=[alert_rule_intermediary, rule_intermediary, uptime_intermediary],
             desc=not is_asc,
             cursor_cls=StringCursor if case_insensitive else Cursor,
             case_insensitive=case_insensitive,