feat(preprod): Use sequential (n-1) comparisons for size analysis diff monitors (#111482)

Change size analysis diff monitors to use sequential (n-1) comparisons
instead of git-based (merge-base) comparisons. When a new build arrives,
each diff-threshold monitor (`absolute_diff`, `relative_diff`) now
resolves its base by finding the most recent prior artifact matching the
detector's query filters and structural identity (`app_id`,
`artifact_type`, `build_configuration`), ordered by `date_added`.

Previously, monitors were evaluated inside the git-based comparison path
(`_run_size_analysis_comparison` → `maybe_emit_issues`), which meant:
- Artifacts without git metadata (no `commit_comparison`) never
triggered monitors
- All diff detectors shared a single git-derived base, even if they had
different query filters
- Monitor evaluation was coupled to the status check comparison flow

Now the two paths are independent:
- **Git path** — persists `PreprodArtifactSizeComparison` records and
triggers status checks. No longer evaluates monitors.
- **Sequential path** — `maybe_emit_issues_from_diff_size_results` runs
unconditionally after the git block (even without git metadata). Each
detector resolves its own base via `get_sequential_base_artifact`, with
batch optimization (one DB lookup per unique query string across
detectors).

`absolute` threshold monitors are unaffected — they're already handled
separately by `maybe_emit_issues_from_absolute_size_results`.

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: mtopo27

src/sentry/preprod/artifact_search.py

@@ -315,3 +315,49 @@ def apply_filters(
             q = ~q
         queryset = queryset.filter(q)
     return queryset
+
+
+def get_sequential_base_artifact(
+    artifact: PreprodArtifact,
+    query: str,
+    organization: Organization,
+) -> PreprodArtifact | None:
+    """
+    Find the most recent prior artifact matching the given query and structural
+    identity fields, with completed size metrics.
+
+    Used by sequential (n-1) monitors to resolve the base artifact for diff
+    comparisons. Unlike the git-based lookup (get_base_artifact_for_commit),
+    this orders by date_added rather than commit ancestry.
+
+    Args:
+        artifact: The current (head) artifact to find a base for.
+        query: The detector's query string (e.g. "app_name:MyApp"). May be empty.
+        organization: The organization for scoping query filters.
+
+    Returns:
+        The most recent prior PreprodArtifact matching the criteria, or None.
+    """
+    queryset = PreprodArtifact.objects.get_queryset()
+
+    if query and query.strip():
+        search_filters = parse_search_query(
+            query, config=search_config, get_field_type=get_field_type
+        )
+        queryset = apply_filters(queryset, search_filters, organization)
+
+    queryset = queryset.filter(
+        project_id=artifact.project_id,
+        app_id=artifact.app_id,
+        artifact_type=artifact.artifact_type,
+        build_configuration=artifact.build_configuration,
+    )
+
+    queryset = queryset.filter(
+        preprodartifactsizemetrics__state=PreprodArtifactSizeMetrics.SizeAnalysisState.COMPLETED,
+        preprodartifactsizemetrics__metrics_artifact_type=PreprodArtifactSizeMetrics.MetricsArtifactType.MAIN_ARTIFACT,
+    )
+
+    queryset = queryset.exclude(pk=artifact.pk)
+
+    return queryset.order_by("-date_added").first()

src/sentry/preprod/size_analysis/tasks.py

@@ -8,7 +8,9 @@
 from django.utils import timezone
 
 from sentry import features
+from sentry.exceptions import InvalidSearchQuery
 from sentry.models.files.file import File
+from sentry.preprod.artifact_search import get_sequential_base_artifact
 from sentry.preprod.models import (
     PreprodArtifact,
     PreprodArtifactSizeComparison,
@@ -21,7 +23,7 @@
     SizeAnalysisMetadata,
     SizeAnalysisValue,
 )
-from sentry.preprod.size_analysis.models import ComparisonResults, SizeAnalysisResults
+from sentry.preprod.size_analysis.models import SizeAnalysisResults
 from sentry.preprod.size_analysis.utils import build_size_metrics_map, can_compare_size_metrics
 from sentry.preprod.size_analysis.webhooks import send_size_analysis_webhook
 from sentry.preprod.vcs.status_checks.size.tasks import create_preprod_status_check_task
@@ -96,6 +98,8 @@ def compare_preprod_artifact_size_analysis(
                             "caller": "compare_build_config_mismatch",
                         }
                     )
+                    # Still evaluate sequential monitors even on build config mismatch
+                    maybe_emit_issues_from_diff_size_results(artifact, org_id)
                     return
 
                 base_size_metrics_qs = PreprodArtifactSizeMetrics.objects.filter(
@@ -279,6 +283,9 @@ def compare_preprod_artifact_size_analysis(
     finally:
         send_size_analysis_webhook(artifact=artifact, organization_id=org_id)
 
+    # Evaluate sequential monitors unconditionally — independent of git metadata
+    maybe_emit_issues_from_diff_size_results(artifact, org_id)
+
 
 @instrumented_task(
     name="sentry.preprod.tasks.manual_size_analysis_comparison",
@@ -543,50 +550,39 @@ def _run_size_analysis_comparison(
         comparison.state = PreprodArtifactSizeComparison.State.SUCCESS
         comparison.save()
 
-    maybe_emit_issues(
-        comparison_results=comparison_results,
-        head_metric=head_size_metric,
-        base_metric=base_size_metric,
-    )
-
     logger.info(
         "preprod.size_analysis.compare.success",
         extra={"comparison_id": comparison.id},
     )
 
 
-def maybe_emit_issues(
-    comparison_results: ComparisonResults,
-    head_metric: PreprodArtifactSizeMetrics,
-    base_metric: PreprodArtifactSizeMetrics,
+def maybe_emit_issues_from_diff_size_results(
+    artifact: PreprodArtifact,
+    org_id: int,
 ) -> None:
     try:
-        _maybe_emit_issues(
-            comparison_results=comparison_results, head_metric=head_metric, base_metric=base_metric
-        )
+        _maybe_emit_issues_from_diff_size_results(artifact=artifact, org_id=org_id)
     except Exception:
-        logger.exception("Error emitting issues")
+        logger.exception("Error emitting issues from diff size results")
 
 
 def _get_platform(artifact: PreprodArtifact) -> str:
     return artifact.platform or "unknown"
 
 
-def _maybe_emit_issues(
-    comparison_results: ComparisonResults,
-    head_metric: PreprodArtifactSizeMetrics,
-    base_metric: PreprodArtifactSizeMetrics,
+def _maybe_emit_issues_from_diff_size_results(
+    artifact: PreprodArtifact,
+    org_id: int,
 ) -> None:
-    project = head_metric.preprod_artifact.project
+    project = artifact.project
     project_id = project.id
-    organization_id = project.organization.id
 
     if not features.has("organizations:preprod-issues", project.organization):
         logger.info(
-            "preprod.size_analysis.compare.issues.disabled",
+            "preprod.size_analysis.diff_results.issues.disabled",
             extra={
                 "project_id": project_id,
-                "organization_id": organization_id,
+                "organization_id": org_id,
             },
         )
         return
@@ -600,62 +596,129 @@ def _maybe_emit_issues(
     )
     if not detectors:
         logger.info(
-            "preprod.size_analysis.no_detectors",
+            "preprod.size_analysis.diff_results.no_detectors",
             extra={"project_id": project_id},
         )
         return
 
-    # Only process diff-based detectors from the comparison path
     detectors = [d for d in detectors if d.config.get("threshold_type") in DIFF_THRESHOLD_TYPES]
     if not detectors:
         logger.info(
-            "preprod.size_analysis.no_diff_detectors",
+            "preprod.size_analysis.diff_results.no_diff_detectors",
             extra={"project_id": project_id},
         )
         return
 
-    diff = comparison_results.size_metric_diff_item
-    head_artifact = head_metric.preprod_artifact
-    base_artifact = base_metric.preprod_artifact
+    head_metrics = list(
+        PreprodArtifactSizeMetrics.objects.filter(
+            preprod_artifact=artifact,
+            metrics_artifact_type=PreprodArtifactSizeMetrics.MetricsArtifactType.MAIN_ARTIFACT,
+            state=PreprodArtifactSizeMetrics.SizeAnalysisState.COMPLETED,
+        ).select_related("preprod_artifact", "preprod_artifact__mobile_app_info")
+    )
+    if not head_metrics:
+        logger.info(
+            "preprod.size_analysis.diff_results.no_head_metrics",
+            extra={"artifact_id": artifact.id},
+        )
+        return
 
-    metadata: SizeAnalysisMetadata = {
-        "platform": _get_platform(head_artifact),
-        "head_metric_id": head_metric.id,
-        "base_metric_id": base_metric.id,
-        "head_artifact_id": head_artifact.id,
-        "base_artifact_id": base_artifact.id,
-        "head_artifact": head_artifact,
-        "base_artifact": base_artifact,
-    }
+    head_metric = head_metrics[0]
+    organization = project.organization
 
-    size_data: SizeAnalysisValue = {
-        "head_install_size_bytes": diff.head_install_size,
-        "head_download_size_bytes": diff.head_download_size,
-        "base_install_size_bytes": diff.base_install_size,
-        "base_download_size_bytes": diff.base_download_size,
-        "metadata": metadata,
-    }
+    # Batch-resolve sequential bases by unique query string
+    query_to_base: dict[str, PreprodArtifact | None] = {}
+    for detector in detectors:
+        query = detector.config.get("query", "")
+        normalized_query = query.strip() if query else ""
+        if normalized_query not in query_to_base:
+            try:
+                base = get_sequential_base_artifact(artifact, normalized_query, organization)
+            except InvalidSearchQuery:
+                logger.exception(
+                    "preprod.size_analysis.diff_results.invalid_query",
+                    extra={"detector_id": detector.id, "query": normalized_query},
+                )
+                base = None
+            query_to_base[normalized_query] = base
+
+    # Run comparisons for unique sequential bases (persists file-level diffs)
+    base_artifact_to_metric: dict[int, PreprodArtifactSizeMetrics] = {}
+    seen_base_ids: set[int] = set()
+    for base_artifact in query_to_base.values():
+        if base_artifact is None or base_artifact.id in seen_base_ids:
+            continue
+        seen_base_ids.add(base_artifact.id)
+
+        base_metrics = list(
+            PreprodArtifactSizeMetrics.objects.filter(
+                preprod_artifact=base_artifact,
+                metrics_artifact_type=PreprodArtifactSizeMetrics.MetricsArtifactType.MAIN_ARTIFACT,
+                state=PreprodArtifactSizeMetrics.SizeAnalysisState.COMPLETED,
+            ).select_related("preprod_artifact", "preprod_artifact__mobile_app_info")
+        )
+        if not base_metrics:
+            continue
 
-    data_packet: SizeAnalysisDataPacket = DataPacket(
-        source_id=f"preprod-size-analysis:{project_id}",
-        packet=size_data,
-    )
+        base_metric = base_metrics[0]
+        base_artifact_to_metric[base_artifact.id] = base_metric
 
-    logger.info(
-        "preprod.size_analysis.process_detectors.starting",
-        extra={
-            "project_id": project_id,
-            "detector_count": len(detectors),
-        },
-    )
-    results = process_detectors(data_packet, detectors)
-    logger.info(
-        "preprod.size_analysis.process_detectors.completed",
-        extra={
-            "project_id": project_id,
-            "detector_count": len(results),
-        },
-    )
+        with transaction.atomic(router.db_for_write(PreprodArtifactSizeComparison)):
+            PreprodArtifactSizeComparison.objects.get_or_create(
+                head_size_analysis=head_metric,
+                base_size_analysis=base_metric,
+                organization_id=org_id,
+                defaults={"state": PreprodArtifactSizeComparison.State.PENDING},
+            )
+        _run_size_analysis_comparison(org_id, head_metric, base_metric)
+
+    for detector in detectors:
+        query = detector.config.get("query", "")
+        normalized_query = query.strip() if query else ""
+        base_artifact = query_to_base.get(normalized_query)
+        if base_artifact is None:
+            logger.info(
+                "preprod.size_analysis.diff_results.no_base",
+                extra={"detector_id": detector.id, "artifact_id": artifact.id},
+            )
+            continue
+
+        detector_base_metric = base_artifact_to_metric.get(base_artifact.id)
+        if detector_base_metric is None:
+            continue
+
+        metadata: SizeAnalysisMetadata = {
+            "platform": _get_platform(artifact),
+            "head_metric_id": head_metric.id,
+            "base_metric_id": detector_base_metric.id,
+            "head_artifact_id": artifact.id,
+            "base_artifact_id": base_artifact.id,
+            "head_artifact": artifact,
+            "base_artifact": base_artifact,
+        }
+
+        size_data: SizeAnalysisValue = {
+            "head_install_size_bytes": head_metric.max_install_size or 0,
+            "head_download_size_bytes": head_metric.max_download_size or 0,
+            "base_install_size_bytes": detector_base_metric.max_install_size or 0,
+            "base_download_size_bytes": detector_base_metric.max_download_size or 0,
+            "metadata": metadata,
+        }
+
+        data_packet: SizeAnalysisDataPacket = DataPacket(
+            source_id=f"preprod-size-analysis:{project_id}",
+            packet=size_data,
+        )
+
+        logger.info(
+            "preprod.size_analysis.diff_results.evaluating",
+            extra={
+                "detector_id": detector.id,
+                "artifact_id": artifact.id,
+                "base_artifact_id": base_artifact.id,
+            },
+        )
+        process_detectors(data_packet, [detector])
 
 
 def maybe_emit_issues_from_absolute_size_results(