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

Change size analysis diff monitors to use sequential comparisons instead
of git-based (merge-base) comparisons. When a new build arrives, each
diff-threshold monitor 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).

- Add get_sequential_base_artifact() to artifact_search.py for n-1
  base lookup with batch optimization per unique query string
- Refactor maybe_emit_issues into maybe_emit_issues_from_diff_size_results
  which owns all diff monitor evaluation via sequential comparison
- Remove maybe_emit_issues call from git-based _run_size_analysis_comparison
  so the git path only persists comparison records for status checks
- Restructure compare_preprod_artifact_size_analysis so the commit_comparison
  check guards only the git block; sequential monitor eval runs unconditionally

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.vcs.status_checks.size.tasks import create_preprod_status_check_task
 from sentry.silo.base import SiloMode
@@ -91,6 +93,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(
@@ -269,6 +273,9 @@ def compare_preprod_artifact_size_analysis(
             extra={"artifact_id": artifact_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",
@@ -533,50 +540,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
@@ -590,62 +586,107 @@ 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
+
+    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
 
-    data_packet: SizeAnalysisDataPacket = DataPacket(
-        source_id=f"preprod-size-analysis:{project_id}",
-        packet=size_data,
-    )
+        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
 
-    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),
-        },
-    )
+        base_metric = base_metrics[0]
+
+        metadata: SizeAnalysisMetadata = {
+            "platform": _get_platform(artifact),
+            "head_metric_id": head_metric.id,
+            "base_metric_id": 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": base_metric.max_install_size or 0,
+            "base_download_size_bytes": 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(