ref(uptime): Remove usage of ProjectUptimeSubscription from endpoints

This systemically removes ProjectUptimeSubscription usages from uptime
endpoints.

- Remove legacy dual ID handling logic and query parameter dependencies.
  The useDetectorId query parameter no longer has any affect, all IDs
  are treated as detector Ids.

- Update all endpoints to use Detector model instead of
  ProjectUptimeSubscription.

- Refactor serializers to work with Detector objects and associated
  UptimeSubscription data.

- Update validators to create and update Detector instances directly

- Update audit logging to use detector IDs and consolidated audit log
  data functions. Previously the get_audit_log_data method was part of
  the ProjectUptimeSubscription, which is no longer used.

- Remove unused ProjectUptimeSubscription references throughout codebase

IMPORTANTLY the tests have very little changes to them, this is because
this change does NOT change how data is returned.

Requires #98527

Author: evanpurkhiser

src/sentry/apidocs/parameters.py

@@ -654,7 +654,7 @@ class UptimeParams:
         location="path",
         required=True,
         type=int,
-        description="The ID of the uptime alert rule you'd like to query. Can be either a project uptime subscription ID (default) or a detector ID (when useDetectorId=1 query parameter is provided).",
+        description="The ID of the uptime alert rule you'd like to query.",
     )
     OWNER = OpenApiParameter(
         name="owner",

src/sentry/incidents/endpoints/organization_alert_rule_index.py

@@ -72,10 +72,14 @@
 from sentry.sentry_apps.services.app import app_service
 from sentry.sentry_apps.utils.errors import SentryAppBaseError
 from sentry.snuba.dataset import Dataset
-from sentry.uptime.models import ProjectUptimeSubscription, UptimeStatus
-from sentry.uptime.types import UptimeMonitorMode
+from sentry.uptime.types import (
+    DATA_SOURCE_UPTIME_SUBSCRIPTION,
+    GROUP_TYPE_UPTIME_DOMAIN_CHECK_FAILURE,
+    UptimeMonitorMode,
+)
 from sentry.utils.cursors import Cursor, StringCursor
-from sentry.workflow_engine.models import Detector
+from sentry.workflow_engine.models import Detector, DetectorState
+from sentry.workflow_engine.types import DetectorPriorityLevel
 
 logger = logging.getLogger(__name__)
 
@@ -274,12 +278,18 @@ def get(self, request: Request, organization: Organization) -> Response:
             project__in=projects,
         )
 
-        uptime_rules = ProjectUptimeSubscription.objects.filter(
-            project__in=projects,
-            mode__in=(
-                UptimeMonitorMode.MANUAL,
-                UptimeMonitorMode.AUTO_DETECTED_ACTIVE,
-            ),
+        uptime_rules = (
+            Detector.objects.filter(
+                type=GROUP_TYPE_UPTIME_DOMAIN_CHECK_FAILURE,
+                project__in=projects,
+                config__mode__in=(
+                    UptimeMonitorMode.MANUAL.value,
+                    UptimeMonitorMode.AUTO_DETECTED_ACTIVE.value,
+                ),
+                data_sources__type=DATA_SOURCE_UPTIME_SUBSCRIPTION,
+            )
+            .select_related("project")
+            .prefetch_related("data_sources")
         )
         crons_rules = (
             Monitor.objects.filter(project_id__in=[p.id for p in projects])
@@ -367,15 +377,18 @@ def get(self, request: Request, organization: Organization) -> Response:
                 incident_status=Value(-2, output_field=IntegerField())
             )
             uptime_rules = uptime_rules.annotate(
+                detector_priority=Subquery(
+                    DetectorState.objects.filter(detector=OuterRef("pk")).values("state")[:1]
+                ),
                 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
+                    # If an uptime detector is in HIGH priority (failing)
+                    # state, treat it like a critical incident
                     When(
-                        uptime_subscription__uptime_status=UptimeStatus.FAILED,
+                        detector_priority=DetectorPriorityLevel.HIGH,
                         then=IncidentStatus.CRITICAL.value,
                     ),
                     default=-2,
-                )
+                ),
             )
             crons_rules = crons_rules.annotate(
                 incident_status=Case(

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

@@ -29,10 +29,12 @@
 from sentry.sentry_apps.services.app.model import RpcSentryAppComponentContext
 from sentry.snuba.dataset import Dataset
 from sentry.snuba.models import SnubaQueryEventType
-from sentry.uptime.models import ProjectUptimeSubscription
+from sentry.uptime.endpoints.serializers import UptimeDetectorSerializer
+from sentry.uptime.types import GROUP_TYPE_UPTIME_DOMAIN_CHECK_FAILURE
 from sentry.users.models.user import User
 from sentry.users.services.user import RpcUser
 from sentry.users.services.user.service import user_service
+from sentry.workflow_engine.models import Detector
 
 logger = logging.getLogger(__name__)
 
@@ -377,12 +379,18 @@ 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)],
+        uptime_detectors = [
+            x
+            for x in item_list
+            if isinstance(x, Detector) and x.type == GROUP_TYPE_UPTIME_DOMAIN_CHECK_FAILURE
+        ]
+        serialized_uptime_detectors = serialize(
+            uptime_detectors,
             user=user,
+            serializer=UptimeDetectorSerializer(),
         )
-        serialized_uptime_monitor_map_by_id = {
-            item["id"]: item for item in serialized_uptime_monitors
+        serialized_uptime_detector_map_by_id = {
+            item["id"]: item for item in serialized_uptime_detectors
         }
 
         serialized_cron_monitors = serialize(
@@ -417,11 +425,12 @@ def get_attrs(
                 # This is an issue alert rule
                 results[item] = serialized_issue_rule_map_by_id[item_id]
             elif (
-                isinstance(item, ProjectUptimeSubscription)
-                and item_id in serialized_uptime_monitor_map_by_id
+                isinstance(item, Detector)
+                and item.type == GROUP_TYPE_UPTIME_DOMAIN_CHECK_FAILURE
+                and item_id in serialized_uptime_detector_map_by_id
             ):
-                # This is an uptime monitor
-                results[item] = serialized_uptime_monitor_map_by_id[item_id]
+                # This is an uptime detector
+                results[item] = serialized_uptime_detector_map_by_id[item_id]
             elif (
                 # XXX(epurkhiser): Monitors use their GUID as their IDs
                 isinstance(item, Monitor)
@@ -436,7 +445,10 @@ def get_attrs(
                         "id": item_id,
                         "issue_rule": isinstance(item, Rule),
                         "metric_rule": isinstance(item, AlertRule),
-                        "uptime_rule": isinstance(item, ProjectUptimeSubscription),
+                        "uptime_rule": (
+                            isinstance(item, Detector)
+                            and item.type == GROUP_TYPE_UPTIME_DOMAIN_CHECK_FAILURE
+                        ),
                         "crons_rule": isinstance(item, Monitor),
                     },
                 )
@@ -445,7 +457,7 @@ def get_attrs(
 
     def serialize(
         self,
-        obj: Rule | AlertRule | ProjectUptimeSubscription | Monitor,
+        obj: Rule | AlertRule | Detector | Monitor,
         attrs: Mapping[Any, Any],
         user: User | RpcUser | AnonymousUser,
         **kwargs: Any,
@@ -455,7 +467,7 @@ def serialize(
             updated_attrs["type"] = "alert_rule"
         elif isinstance(obj, Rule):
             updated_attrs["type"] = "rule"
-        elif isinstance(obj, ProjectUptimeSubscription):
+        elif isinstance(obj, Detector) and obj.type == GROUP_TYPE_UPTIME_DOMAIN_CHECK_FAILURE:
             updated_attrs["type"] = "uptime"
         elif isinstance(obj, Monitor):
             updated_attrs["type"] = "monitor"

src/sentry/uptime/detectors/result_handler.py

@@ -12,11 +12,8 @@
 from sentry import audit_log
 from sentry.uptime.detectors.ranking import _get_cluster
 from sentry.uptime.detectors.tasks import set_failed_url
-from sentry.uptime.models import UptimeSubscription, get_project_subscription
-from sentry.uptime.subscriptions.subscriptions import (
-    delete_uptime_detector,
-    update_project_uptime_subscription,
-)
+from sentry.uptime.models import UptimeSubscription, get_audit_log_data
+from sentry.uptime.subscriptions.subscriptions import delete_uptime_detector, update_uptime_detector
 from sentry.uptime.types import UptimeMonitorMode
 from sentry.utils import metrics
 from sentry.utils.audit import create_system_audit_entry
@@ -86,18 +83,17 @@ def handle_onboarding_result(
         if scheduled_check_time - ONBOARDING_MONITOR_PERIOD > detector.date_added:
             # If we've had mostly successes throughout the onboarding period then we can graduate the subscription
             # to active.
-            project_subscription = get_project_subscription(detector)
-            update_project_uptime_subscription(
-                project_subscription,
+            update_uptime_detector(
+                detector,
                 interval_seconds=int(AUTO_DETECTED_ACTIVE_SUBSCRIPTION_INTERVAL.total_seconds()),
                 mode=UptimeMonitorMode.AUTO_DETECTED_ACTIVE,
                 ensure_assignment=True,
             )
             create_system_audit_entry(
                 organization=detector.project.organization,
-                target_object=project_subscription.id,
+                target_object=detector.id,
                 event=audit_log.get_event_id("UPTIME_MONITOR_ADD"),
-                data=project_subscription.get_audit_log_data(),
+                data=get_audit_log_data(detector),
             )
 
             metrics.incr(

src/sentry/uptime/endpoints/bases.py

@@ -3,7 +3,6 @@
 from sentry.api.api_owners import ApiOwner
 from sentry.api.bases.project import ProjectAlertRulePermission, ProjectEndpoint
 from sentry.api.exceptions import ResourceDoesNotExist
-from sentry.uptime.models import ProjectUptimeSubscription, get_detector
 from sentry.uptime.types import (
     DATA_SOURCE_UPTIME_SUBSCRIPTION,
     GROUP_TYPE_UPTIME_DOMAIN_CHECK_FAILURE,
@@ -18,51 +17,25 @@ class ProjectUptimeAlertEndpoint(ProjectEndpoint):
     def convert_args(
         self,
         request: Request,
-        # XXX(epurkhiser): There's a getsentry test that depends on this
-        # argument name, when we change this over to purely detector_id we
-        # should make the effort to fix the parameter name then
+        # XXX(epurkhiser): THIS IS A DETECTOR
+        #
+        # This name is completely wrong, but there's a test in getsentry that's
+        # using this parameter name that we'll have to fix first to change it.
         uptime_project_subscription_id: str,
         *args,
         **kwargs,
     ):
         args, kwargs = super().convert_args(request, *args, **kwargs)
         project = kwargs["project"]
 
-        # Check query parameter to determine if ID should be treated as detector ID
-        use_detector_id = request.GET.get("useDetectorId") == "1"
-
-        # XXX(epurkhiser): We can remove this dual reading logic once all
-        # endpoints are using the Detector IDs over ProjectUptimeSubscription
-        # IDs.
-        if use_detector_id:
-            # Treat ID as detector ID - find detector and its associated subscription
-            try:
-                detector = Detector.objects.get(
-                    project=project,
-                    id=uptime_project_subscription_id,
-                    type=GROUP_TYPE_UPTIME_DOMAIN_CHECK_FAILURE,
-                    data_sources__type=DATA_SOURCE_UPTIME_SUBSCRIPTION,
-                )
-                # Get the uptime subscription from the detector's data source
-                data_source = detector.data_sources.get(type=DATA_SOURCE_UPTIME_SUBSCRIPTION)
-                uptime_subscription_id = data_source.source_id
-                uptime_monitor = ProjectUptimeSubscription.objects.get(
-                    project=project, uptime_subscription__id=uptime_subscription_id
-                )
-                kwargs["uptime_detector"] = detector
-                kwargs["uptime_monitor"] = uptime_monitor
-            except (Detector.DoesNotExist, ProjectUptimeSubscription.DoesNotExist, AttributeError):
-                raise ResourceDoesNotExist
-        else:
-            # Treat ID as project uptime subscription ID (legacy behavior)
-            try:
-                uptime_monitor = ProjectUptimeSubscription.objects.get(
-                    project=project, id=uptime_project_subscription_id
-                )
-                detector = get_detector(uptime_monitor.uptime_subscription)
-                kwargs["uptime_detector"] = detector
-                kwargs["uptime_monitor"] = uptime_monitor
-            except ProjectUptimeSubscription.DoesNotExist:
-                raise ResourceDoesNotExist
+        try:
+            kwargs["uptime_detector"] = Detector.objects.get(
+                project=project,
+                id=uptime_project_subscription_id,
+                type=GROUP_TYPE_UPTIME_DOMAIN_CHECK_FAILURE,
+                data_sources__type=DATA_SOURCE_UPTIME_SUBSCRIPTION,
+            )
+        except Detector.DoesNotExist:
+            raise ResourceDoesNotExist
 
         return args, kwargs

src/sentry/uptime/endpoints/organiation_uptime_alert_index.py

@@ -1,4 +1,6 @@
 from django.db.models import Q
+from django.db.models.fields import BigIntegerField, CharField
+from django.db.models.functions import Cast
 from drf_spectacular.utils import extend_schema
 from rest_framework.request import Request
 from rest_framework.response import Response
@@ -19,10 +21,15 @@
 from sentry.search.utils import tokenize_query
 from sentry.types.actor import Actor
 from sentry.uptime.endpoints.serializers import (
-    ProjectUptimeSubscriptionSerializer,
-    ProjectUptimeSubscriptionSerializerResponse,
+    UptimeDetectorSerializer,
+    UptimeDetectorSerializerResponse,
 )
-from sentry.uptime.models import ProjectUptimeSubscription
+from sentry.uptime.models import UptimeSubscription
+from sentry.uptime.types import (
+    DATA_SOURCE_UPTIME_SUBSCRIPTION,
+    GROUP_TYPE_UPTIME_DOMAIN_CHECK_FAILURE,
+)
+from sentry.workflow_engine.models import Detector
 
 
 @region_silo_endpoint
@@ -44,7 +51,7 @@ class OrganizationUptimeAlertIndexEndpoint(OrganizationEndpoint):
         ],
         responses={
             200: inline_sentry_response_serializer(
-                "UptimeAlertList", list[ProjectUptimeSubscriptionSerializerResponse]
+                "UptimeAlertList", list[UptimeDetectorSerializerResponse]
             ),
             401: RESPONSE_UNAUTHORIZED,
             403: RESPONSE_FORBIDDEN,
@@ -60,14 +67,17 @@ def get(self, request: Request, organization: Organization) -> Response:
         except NoProjects:
             return self.respond([])
 
-        queryset = ProjectUptimeSubscription.objects.filter(
-            project__organization_id=organization.id, project_id__in=filter_params["project_id"]
+        queryset = Detector.objects.filter(
+            type=GROUP_TYPE_UPTIME_DOMAIN_CHECK_FAILURE,
+            project__organization_id=organization.id,
+            project_id__in=filter_params["project_id"],
         )
         query = request.GET.get("query")
         owners = request.GET.getlist("owner")
 
         if "environment" in filter_params:
-            queryset = queryset.filter(environment__in=filter_params["environment_objects"])
+            environment_names = [env.name for env in filter_params["environment_objects"]]
+            queryset = queryset.filter(config__environment__in=environment_names)
 
         if owners:
             owners_set = set(owners)
@@ -103,10 +113,20 @@ def get(self, request: Request, organization: Organization) -> Response:
             for key, value in tokens.items():
                 if key == "query":
                     query_value = " ".join(value)
-                    queryset = queryset.filter(
-                        Q(name__icontains=query_value)
-                        | Q(uptime_subscription__url__icontains=query_value)
+
+                    linked_subscription_ids = queryset.values_list(
+                        Cast("data_sources__source_id", BigIntegerField()), flat=True
                     )
+                    matching_subscription_ids = UptimeSubscription.objects.filter(
+                        id__in=linked_subscription_ids, url__icontains=query_value
+                    ).values_list(Cast("id", CharField()), flat=True)
+
+                    url_filter = Q(
+                        data_sources__type=DATA_SOURCE_UPTIME_SUBSCRIPTION,
+                        data_sources__source_id__in=matching_subscription_ids,
+                    )
+
+                    queryset = queryset.filter(Q(name__icontains=query_value) | url_filter)
                 elif key == "name":
                     queryset = queryset.filter(in_iexact("name", value))
                 else:
@@ -115,6 +135,6 @@ def get(self, request: Request, organization: Organization) -> Response:
         return self.paginate(
             request=request,
             queryset=queryset,
-            on_results=lambda x: serialize(x, request.user, ProjectUptimeSubscriptionSerializer()),
+            on_results=lambda x: serialize(x, request.user, UptimeDetectorSerializer()),
             paginator_cls=OffsetPaginator,
         )

src/sentry/uptime/endpoints/project_uptime_alert_checks_index.py

@@ -35,11 +35,7 @@
 from sentry.uptime.eap_utils import get_columns_for_uptime_trace_item_type
 from sentry.uptime.endpoints.bases import ProjectUptimeAlertEndpoint
 from sentry.uptime.endpoints.serializers import EapCheckEntrySerializerResponse
-from sentry.uptime.models import (
-    ProjectUptimeSubscription,
-    UptimeSubscription,
-    get_uptime_subscription,
-)
+from sentry.uptime.models import UptimeSubscription, get_uptime_subscription
 from sentry.uptime.types import EapCheckEntry, IncidentStatus
 from sentry.utils import snuba_rpc
 from sentry.workflow_engine.models import Detector
@@ -60,7 +56,6 @@ def get(
         request: Request,
         project: Project,
         uptime_detector: Detector,
-        uptime_monitor: ProjectUptimeSubscription,
     ) -> Response:
         uptime_subscription = get_uptime_subscription(uptime_detector)