chore(uptime): Remove unused subscription de-duping functions (#85971)

We no longer use these since we're not de-duping subscriptions anymore.
Cleaning them up.

Author: wedamija

src/sentry/uptime/subscriptions/subscriptions.py

@@ -1,12 +1,6 @@
-import hashlib
 import logging
 from collections.abc import Sequence
 
-from django.db import IntegrityError
-from django.db.models import TextField
-from django.db.models.expressions import Value
-from django.db.models.functions import MD5, Coalesce
-
 from sentry import quotas
 from sentry.constants import DataCategory, ObjectStatus
 from sentry.models.environment import Environment
@@ -19,7 +13,6 @@
     ProjectUptimeSubscriptionMode,
     UptimeSubscription,
     UptimeSubscriptionRegion,
-    headers_json_encoder,
     load_regions_for_uptime_subscription,
 )
 from sentry.uptime.rdap.tasks import fetch_subscription_rdap_info
@@ -62,189 +55,6 @@ def __init__(self, result: SeatAssignmentResult | None) -> None:
         self.result = result
 
 
-def retrieve_uptime_subscription(
-    url: str,
-    interval_seconds: int,
-    timeout_ms: int,
-    method: str,
-    headers: Sequence[tuple[str, str]],
-    body: str | None,
-    trace_sampling: bool,
-) -> UptimeSubscription | None:
-    try:
-        subscription = (
-            UptimeSubscription.objects.filter(
-                url=url,
-                interval_seconds=interval_seconds,
-                timeout_ms=timeout_ms,
-                method=method,
-                trace_sampling=trace_sampling,
-            )
-            .annotate(
-                headers_md5=MD5("headers", output_field=TextField()),
-                body_md5=Coalesce(MD5("body"), Value(""), output_field=TextField()),
-            )
-            .filter(
-                headers_md5=hashlib.md5(headers_json_encoder(headers).encode("utf-8")).hexdigest(),
-                body_md5=hashlib.md5(body.encode("utf-8")).hexdigest() if body else "",
-            )
-            .get()
-        )
-    except UptimeSubscription.DoesNotExist:
-        subscription = None
-    return subscription
-
-
-def get_or_create_uptime_subscription(
-    url: str,
-    interval_seconds: int,
-    timeout_ms: int,
-    method: str = "GET",
-    headers: Sequence[tuple[str, str]] | None = None,
-    body: str | None = None,
-    trace_sampling: bool = False,
-) -> UptimeSubscription:
-    # XXX: Remove this, keeping it around for getsentry backwards compat
-    if headers is None:
-        headers = []
-    # We extract the domain and suffix of the url here. This is used to prevent there being too many checks to a single
-    # domain.
-    result = extract_domain_parts(url)
-
-    subscription = retrieve_uptime_subscription(
-        url, interval_seconds, timeout_ms, method, headers, body, trace_sampling
-    )
-    created = False
-
-    if subscription is None:
-        try:
-            subscription = UptimeSubscription.objects.create(
-                url=url,
-                url_domain=result.domain,
-                url_domain_suffix=result.suffix,
-                interval_seconds=interval_seconds,
-                timeout_ms=timeout_ms,
-                status=UptimeSubscription.Status.CREATING.value,
-                type=UPTIME_SUBSCRIPTION_TYPE,
-                method=method,
-                headers=headers,  # type: ignore[misc]
-                body=body,
-                trace_sampling=trace_sampling,
-            )
-            created = True
-        except IntegrityError:
-            # Handle race condition where we tried to retrieve an existing subscription while it was being created
-            subscription = retrieve_uptime_subscription(
-                url, interval_seconds, timeout_ms, method, headers, body, trace_sampling
-            )
-
-    if subscription is None:
-        # This shouldn't happen, since we should always be able to fetch or create the subscription.
-        logger.error(
-            "Unable to create uptime subscription",
-            extra={
-                "url": url,
-                "interval_seconds": interval_seconds,
-                "timeout_ms": timeout_ms,
-                "method": method,
-                "headers": headers,
-                "body": body,
-            },
-        )
-        raise ValueError("Unable to create uptime subscription")
-
-    if subscription.status == UptimeSubscription.Status.DELETING.value:
-        # This is pretty unlikely to happen, but we should avoid deleting the subscription here and just confirm it
-        # exists in the checker.
-        created = True
-
-    # Associate active regions with this subscription
-    for region in get_active_regions():
-        # If we add a region here we need to resend the subscriptions
-        created |= UptimeSubscriptionRegion.objects.update_or_create(
-            uptime_subscription=subscription,
-            region_slug=region.slug,
-            defaults={"mode": region.mode},
-        )[1]
-
-    if created:
-        subscription.update(status=UptimeSubscription.Status.CREATING.value)
-        create_remote_uptime_subscription.delay(subscription.id)
-        fetch_subscription_rdap_info.delay(subscription.id)
-    return subscription
-
-
-def get_or_create_project_uptime_subscription(
-    project: Project,
-    environment: Environment | None,
-    url: str,
-    interval_seconds: int,
-    timeout_ms: int,
-    method: str = "GET",
-    headers: Sequence[tuple[str, str]] | None = None,
-    body: str | None = None,
-    mode: ProjectUptimeSubscriptionMode = ProjectUptimeSubscriptionMode.MANUAL,
-    status: int = ObjectStatus.ACTIVE,
-    name: str = "",
-    owner: Actor | None = None,
-    trace_sampling: bool = False,
-    override_manual_org_limit: bool = False,
-) -> tuple[ProjectUptimeSubscription, bool]:
-    # XXX: Remove this function after getsentry is compat
-    if mode == ProjectUptimeSubscriptionMode.MANUAL:
-        manual_subscription_count = ProjectUptimeSubscription.objects.filter(
-            project__organization=project.organization, mode=ProjectUptimeSubscriptionMode.MANUAL
-        ).count()
-        if (
-            not override_manual_org_limit
-            and manual_subscription_count >= MAX_MANUAL_SUBSCRIPTIONS_PER_ORG
-        ):
-            raise MaxManualUptimeSubscriptionsReached
-
-    uptime_subscription = get_or_create_uptime_subscription(
-        url=url,
-        interval_seconds=interval_seconds,
-        timeout_ms=timeout_ms,
-        method=method,
-        headers=headers,
-        body=body,
-        trace_sampling=trace_sampling,
-    )
-    owner_user_id = None
-    owner_team_id = None
-    if owner:
-        if owner.is_user:
-            owner_user_id = owner.id
-        if owner.is_team:
-            owner_team_id = owner.id
-    uptime_monitor, created = ProjectUptimeSubscription.objects.get_or_create(
-        project=project,
-        environment=environment,
-        uptime_subscription=uptime_subscription,
-        mode=mode.value,
-        name=name,
-        owner_user_id=owner_user_id,
-        owner_team_id=owner_team_id,
-    )
-
-    # Update status. This may have the side effect of removing or creating a
-    # remote subscription. When a new monitor is created we will ensure seat
-    # assignment, which may cause the monitor to be disabled if there are no
-    # available seat assignments.
-    match status:
-        case ObjectStatus.ACTIVE:
-            try:
-                enable_project_uptime_subscription(uptime_monitor, ensure_assignment=created)
-            except UptimeMonitorNoSeatAvailable:
-                # No need to do anything if we failed to handle seat
-                # assignment. The monitor will be created, but not enabled
-                pass
-        case ObjectStatus.DISABLED:
-            disable_project_uptime_subscription(uptime_monitor)
-
-    return uptime_monitor, created
-
-
 def create_uptime_subscription(
     url: str,
     interval_seconds: int,