feat(uptime): Backfill dual fingerprints into grouphashes table.

wedamija · wedamija · commit 90257003ad63 · 2025-05-08T14:12:20.000-07:00
We started dual writing these in #91087. This backfills both fingerprints into `GroupHash` so that we can stop relying on the old ones.
diff --git a/src/sentry/testutils/cases.py b/src/sentry/testutils/cases.py
@@ -3140,12 +3140,6 @@ def tearDown(self):
         self.mock_resolve_rdap_provider_ctx.__exit__(None, None, None)
         self.mock_requests_get_ctx.__exit__(None, None, None)
 
-
-class _OptionalCheckResult(TypedDict, total=False):
-    region: str
-
-
-class UptimeTestCase(UptimeTestCaseMixin, TestCase):
     def create_uptime_result(
         self,
         subscription_id: str | None = None,
@@ -3178,6 +3172,14 @@ def create_uptime_result(
         }
 
 
+class _OptionalCheckResult(TypedDict, total=False):
+    region: str
+
+
+class UptimeTestCase(UptimeTestCaseMixin, TestCase):
+    pass
+
+
 class IntegratedApiTestCase(BaseTestCase):
     def should_call_api_without_proxying(self) -> bool:
         return not IntegrationProxyClient.determine_whether_should_proxy_to_control()
diff --git a/src/sentry/uptime/migrations/0040_uptime_backfill_detector_grouphash.py b/src/sentry/uptime/migrations/0040_uptime_backfill_detector_grouphash.py
@@ -0,0 +1,100 @@
+# Generated by Django 5.1.7 on 2025-05-06 22:16
+from hashlib import md5
+
+from django.db import migrations
+from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+from django.db.migrations.state import StateApps
+
+from sentry.new_migrations.migrations import CheckedMigration
+from sentry.utils.query import RangeQuerySetWrapperWithProgressBar
+
+DATA_SOURCE_UPTIME_SUBSCRIPTION = "uptime_subscription"
+
+
+def get_project_subscription(ProjectUptimeSubscription, detector):
+    data_source = detector.data_sources.first()
+    return ProjectUptimeSubscription.objects.get(uptime_subscription_id=int(data_source.source_id))
+
+
+def build_detector_fingerprint_component(detector) -> str:
+    return f"uptime-detector:{detector.id}"
+
+
+def build_subscription_fingerprint_component(subscription_id) -> str:
+    return str(subscription_id)
+
+
+def hash_fingerprint(fingerprint: str) -> str:
+    return md5(fingerprint.encode("utf-8")).hexdigest()
+
+
+def update_auto_detected_active_interval_seconds(
+    apps: StateApps, schema_editor: BaseDatabaseSchemaEditor
+) -> None:
+    GroupHash = apps.get_model("sentry", "GroupHash")
+    DataSource = apps.get_model("workflow_engine", "DataSource")
+    ProjectUptimeSubscription = apps.get_model("uptime", "ProjectUptimeSubscription")
+
+    for data_source in RangeQuerySetWrapperWithProgressBar(
+        DataSource.objects.filter(type=DATA_SOURCE_UPTIME_SUBSCRIPTION)
+    ):
+        uptime_subscription_id = int(data_source.source_id)
+        project_subscription_id = ProjectUptimeSubscription.objects.get(
+            uptime_subscription_id=uptime_subscription_id
+        ).id
+        detector = data_source.detectors.first()
+
+        detector_fingerprint_hash = hash_fingerprint(build_detector_fingerprint_component(detector))
+        sub_fingerprint_hash = hash_fingerprint(
+            build_subscription_fingerprint_component(project_subscription_id)
+        )
+        group_hashes = list(
+            GroupHash.objects.filter(
+                project=detector.project,
+                hash__in=[detector_fingerprint_hash, sub_fingerprint_hash],
+            )
+        )
+        # If we have 0 or 2 group hashes then we don't need to backfill anything. Either the group doesn't exist
+        # at all for this detector, or both hashes are already associated
+        if len(group_hashes) != 1:
+            continue
+        group_hash = group_hashes[0]
+        # If the only hash that exists is for the detector fingerprint then we don't have any work to do
+        if group_hash.hash == detector_fingerprint_hash:
+            continue
+
+        GroupHash.objects.get_or_create(
+            project=detector.project,
+            hash=detector_fingerprint_hash,
+            defaults={
+                "group": group_hash.group,
+            },
+        )
+
+
+class Migration(CheckedMigration):
+    # This flag is used to mark that a migration shouldn't be automatically run in production.
+    # This should only be used for operations where it's safe to run the migration after your
+    # code has deployed. So this should not be used for most operations that alter the schema
+    # of a table.
+    # Here are some things that make sense to mark as post deployment:
+    # - Large data migrations. Typically we want these to be run manually so that they can be
+    #   monitored and not block the deploy for a long period of time while they run.
+    # - Adding indexes to large tables. Since this can take a long time, we'd generally prefer to
+    #   run this outside deployments so that we don't block them. Note that while adding an index
+    #   is a schema change, it's completely safe to run the operation after the code has deployed.
+    # Once deployed, run these manually via: https://develop.sentry.dev/database-migrations/#migration-deployment
+
+    is_post_deployment = True
+
+    dependencies = [
+        ("uptime", "0039_uptime_drop_project_subscription_uptime_status_db"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            update_auto_detected_active_interval_seconds,
+            migrations.RunPython.noop,
+            hints={"tables": ["sentry_grouphash"]},
+        )
+    ]
diff --git a/tests/sentry/uptime/migrations/test_0040_uptime_backfill_detector_grouphash.py b/tests/sentry/uptime/migrations/test_0040_uptime_backfill_detector_grouphash.py
@@ -0,0 +1,97 @@
+from hashlib import md5
+
+from sentry.models.group import Group
+from sentry.models.grouphash import GroupHash
+from sentry.testutils.cases import TestMigrations, UptimeTestCaseMixin
+from sentry.uptime.grouptype import UptimeDomainCheckFailure
+from sentry.uptime.issue_platform import (
+    build_detector_fingerprint_component,
+    create_issue_platform_occurrence,
+)
+from sentry.uptime.types import DATA_SOURCE_UPTIME_SUBSCRIPTION, ProjectUptimeSubscriptionMode
+from sentry.workflow_engine.models import DataSource, DataSourceDetector
+
+
+class TestUptimeBackfillDetectorGrouphash(TestMigrations, UptimeTestCaseMixin):
+    app = "uptime"
+    migrate_from = "0039_uptime_drop_project_subscription_uptime_status_db"
+    migrate_to = "0040_uptime_backfill_detector_grouphash"
+
+    def setup_before_migration(self, apps):
+        self.proj_sub_no_hash = self.create_project_uptime_subscription(project=self.project)
+        self.proj_sub_one_hash = self.create_project_uptime_subscription(project=self.project)
+        self.proj_sub_both_hash = self.create_project_uptime_subscription(project=self.project)
+
+        DataSource.objects.all().delete()
+        self.data_source_no_hash = self.create_data_source(
+            type=DATA_SOURCE_UPTIME_SUBSCRIPTION,
+            source_id=str(self.proj_sub_no_hash.uptime_subscription_id),
+        )
+        self.detector_no_hash = self.create_detector(
+            type=UptimeDomainCheckFailure.slug,
+            config={"mode": ProjectUptimeSubscriptionMode.MANUAL, "environment": None},
+            project=self.project,
+        )
+        DataSourceDetector.objects.create(
+            data_source=self.data_source_no_hash, detector=self.detector_no_hash
+        )
+
+        self.data_source_one_hash = self.create_data_source(
+            type=DATA_SOURCE_UPTIME_SUBSCRIPTION,
+            source_id=str(self.proj_sub_one_hash.uptime_subscription_id),
+        )
+        self.detector_one_hash = self.create_detector(
+            type=UptimeDomainCheckFailure.slug,
+            config={"mode": ProjectUptimeSubscriptionMode.MANUAL, "environment": None},
+            project=self.project,
+        )
+        DataSourceDetector.objects.create(
+            data_source=self.data_source_one_hash, detector=self.detector_one_hash
+        )
+
+        self.data_source_both_hash = self.create_data_source(
+            type=DATA_SOURCE_UPTIME_SUBSCRIPTION,
+            source_id=str(self.proj_sub_both_hash.uptime_subscription_id),
+        )
+        self.detector_both_hash = self.create_detector(
+            type=UptimeDomainCheckFailure.slug,
+            config={"mode": ProjectUptimeSubscriptionMode.MANUAL, "environment": None},
+            project=self.project,
+        )
+        DataSourceDetector.objects.create(
+            data_source=self.data_source_both_hash, detector=self.detector_both_hash
+        )
+
+        with self.tasks(), self.feature(UptimeDomainCheckFailure.build_ingest_feature_name()):
+            create_issue_platform_occurrence(self.create_uptime_result(), self.detector_both_hash)
+            create_issue_platform_occurrence(self.create_uptime_result(), self.detector_one_hash)
+
+        # Remove the hash for the detector
+        self.group_one_hash = Group.objects.last()
+        GroupHash.objects.filter(
+            group=self.group_one_hash,
+            hash=md5(
+                build_detector_fingerprint_component(self.detector_one_hash).encode("utf-8")
+            ).hexdigest(),
+        ).delete()
+
+    def test(self):
+        assert GroupHash.objects.filter(
+            group=self.group_one_hash,
+            hash=md5(
+                build_detector_fingerprint_component(self.detector_one_hash).encode("utf-8")
+            ).hexdigest(),
+        ).exists()
+        assert not GroupHash.objects.filter(
+            project=self.detector_no_hash.project,
+            hash=md5(
+                build_detector_fingerprint_component(self.detector_no_hash).encode("utf-8")
+            ).hexdigest(),
+        ).exists()
+        both_group = GroupHash.objects.get(
+            project=self.detector_both_hash.project,
+            hash=md5(
+                build_detector_fingerprint_component(self.detector_both_hash).encode("utf-8")
+            ).hexdigest(),
+        ).group
+        assert GroupHash.objects.filter(group=both_group).count() == 2
