ref(investigations): Share the breached monitor snapshot

Part of a series that adds follow-up actions to Seer investigations: when a run completes, Seer suggests one next step, and the user can apply a typed action, such as a monitor change, with one click.

This moves building the monitor snapshot we send Seer, and reading a monitor's detection type, out of the breached-metric source code into two functions. The stale re-check can then send Seer the monitor in the same shape as when the investigation started.

Author: wedamija

src/sentry/investigations/services/breached_metrics.py

@@ -15,8 +15,14 @@
 from sentry.models.groupopenperiod import GroupOpenPeriod
 from sentry.models.organization import Organization
 from sentry.snuba.dataset import Dataset
-from sentry.snuba.models import QuerySubscription, SnubaQueryEventType
-from sentry.workflow_engine.models import DataCondition, DataSourceDetector, DetectorGroup
+from sentry.snuba.models import QuerySubscription, SnubaQuery, SnubaQueryEventType
+from sentry.workflow_engine.models import (
+    DataCondition,
+    DataConditionGroup,
+    DataSourceDetector,
+    Detector,
+    DetectorGroup,
+)
 from sentry.workflow_engine.models.data_condition import Condition
 from sentry.workflow_engine.types import DetectorPriorityLevel
 
@@ -97,6 +103,59 @@ def _condition_snapshot(
     return snapshot
 
 
+def breached_metric_detection_type(detector: Detector) -> AlertRuleDetectionType | None:
+    try:
+        detection_type = AlertRuleDetectionType(detector.config.get("detection_type"))
+    except (TypeError, ValueError):
+        return None
+    if (
+        detection_type == AlertRuleDetectionType.STATIC
+        and detector.config.get("comparison_delta") is not None
+    ):
+        return AlertRuleDetectionType.PERCENT
+    return detection_type
+
+
+def breached_metric_monitor_snapshot(
+    detector: Detector,
+    snuba_query: SnubaQuery,
+    condition_group: DataConditionGroup,
+    detection_type: AlertRuleDetectionType,
+) -> dict[str, Any] | None:
+    """The monitor settings we share with Seer, or None if Seer can't query the monitor."""
+
+    try:
+        dataset = Dataset(snuba_query.dataset)
+    except ValueError:
+        return None
+    code_mode_dataset = _code_mode_dataset(dataset, snuba_query.event_types)
+    if code_mode_dataset is None:
+        return None
+    conditions = [
+        _condition_snapshot(condition, detection_type)
+        # Sort in Python, so a prefetch can still serve it.
+        for condition in sorted(condition_group.conditions.all(), key=lambda c: c.id)
+    ]
+    if not conditions:
+        return None
+    return {
+        "id": str(detector.id),
+        "name": detector.name,
+        "dataset": code_mode_dataset,
+        "query": snuba_query.query,
+        "aggregate": snuba_query.aggregate,
+        "groupBy": snuba_query.group_by or [],
+        "timeWindowSeconds": snuba_query.time_window,
+        "detectionType": detection_type.value,
+        "comparisonDeltaSeconds": detector.config.get("comparison_delta"),
+        "direction": _direction(conditions),
+        "conditions": conditions,
+        "environment": (
+            snuba_query.environment.name if snuba_query.environment is not None else None
+        ),
+    }
+
+
 def _analysis_window(open_period: GroupOpenPeriod, now: datetime) -> dict[str, str]:
     end = open_period.date_ended or now
     breach_start = max(open_period.date_started, end - MAX_BREACH_WINDOW)
@@ -189,15 +248,9 @@ def resolve_breached_metric_sources(
         detector = detector_group.detector
         if detector.type != "metric_issue" or detector.project_id != group.project_id:
             continue
-        try:
-            detection_type = AlertRuleDetectionType(detector.config.get("detection_type"))
-        except (TypeError, ValueError):
+        detection_type = breached_metric_detection_type(detector)
+        if detection_type is None:
             continue
-        if (
-            detection_type == AlertRuleDetectionType.STATIC
-            and detector.config.get("comparison_delta") is not None
-        ):
-            detection_type = AlertRuleDetectionType.PERCENT
         data_source_link = data_source_links.get(detector.id)
         if data_source_link is None:
             continue
@@ -208,43 +261,19 @@ def resolve_breached_metric_sources(
         subscription = subscriptions.get(subscription_id)
         if subscription is None or subscription.project_id != group.project_id:
             continue
-        snuba_query = subscription.snuba_query
-        try:
-            dataset = Dataset(snuba_query.dataset)
-        except ValueError:
-            continue
-        code_mode_dataset = _code_mode_dataset(dataset, snuba_query.event_types)
-        if code_mode_dataset is None:
-            continue
         condition_group = detector.workflow_condition_group
         if condition_group is None:
             continue
-        conditions = [
-            _condition_snapshot(condition, detection_type)
-            for condition in condition_group.conditions.all()
-        ]
-        if not conditions:
+        monitor = breached_metric_monitor_snapshot(
+            detector, subscription.snuba_query, condition_group, detection_type
+        )
+        if monitor is None:
             continue
         snapshot = {
             "groupId": str(group.id),
             "groupTitle": group.title,
             "openPeriodId": str(open_period.id),
-            "monitor": {
-                "id": str(detector.id),
-                "name": detector.name,
-                "dataset": code_mode_dataset,
-                "query": snuba_query.query,
-                "aggregate": snuba_query.aggregate,
-                "groupBy": snuba_query.group_by or [],
-                "timeWindowSeconds": snuba_query.time_window,
-                "detectionType": detection_type.value,
-                "comparisonDeltaSeconds": detector.config.get("comparison_delta"),
-                "direction": _direction(conditions),
-                "conditions": conditions,
-                "environment": (
-                    snuba_query.environment.name if snuba_query.environment is not None else None
-                ),
-            },
+            "monitor": monitor,
             "project": {"id": str(group.project_id), "slug": group.project.slug},
             "analysisWindow": _analysis_window(open_period, current_time),
         }
@@ -258,7 +287,7 @@ def resolve_breached_metric_sources(
         }
         resolved[source_ref] = BreachedMetricSource(
             project_id=group.project_id,
-            dataset=code_mode_dataset,
+            dataset=monitor["dataset"],
             source=source,
         )
     return resolved

tests/sentry/investigations/services/test_breached_metrics.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from datetime import timedelta
+
+from sentry.incidents.models.alert_rule import AlertRuleDetectionType
+from sentry.investigations.services.breached_metrics import breached_metric_monitor_snapshot
+from sentry.snuba.dataset import Dataset
+from sentry.snuba.models import SnubaQuery, SnubaQueryEventType
+from sentry.snuba.subscriptions import create_snuba_query
+from sentry.testutils.cases import TestCase
+from sentry.workflow_engine.models.data_condition import Condition
+from sentry.workflow_engine.types import DetectorPriorityLevel
+
+
+class BreachedMetricMonitorSnapshotTest(TestCase):
+    def test_snapshot_has_the_monitor_settings_and_conditions_in_id_order(self) -> None:
+        snuba_query = create_snuba_query(
+            query_type=SnubaQuery.Type.ERROR,
+            dataset=Dataset.Events,
+            query="level:error",
+            aggregate="count()",
+            time_window=timedelta(minutes=5),
+            resolution=timedelta(minutes=1),
+            environment=self.environment,
+            event_types=[SnubaQueryEventType.EventType.ERROR],
+        )
+        group = self.create_data_condition_group()
+        high = self.create_data_condition(
+            condition_group=group,
+            type=Condition.GREATER,
+            comparison=500,
+            condition_result=DetectorPriorityLevel.HIGH,
+        )
+        ok = self.create_data_condition(
+            condition_group=group,
+            type=Condition.LESS_OR_EQUAL,
+            comparison=500,
+            condition_result=DetectorPriorityLevel.OK,
+        )
+        detector = self.create_detector(name="Checkout errors")
+
+        snapshot = breached_metric_monitor_snapshot(
+            detector, snuba_query, group, AlertRuleDetectionType.STATIC
+        )
+
+        assert snapshot == {
+            "id": str(detector.id),
+            "name": "Checkout errors",
+            "dataset": "errors",
+            "query": "level:error",
+            "aggregate": "count()",
+            "groupBy": [],
+            "timeWindowSeconds": 300,
+            "detectionType": "static",
+            "comparisonDeltaSeconds": None,
+            "direction": "above",
+            "conditions": [
+                {"type": high.type, "comparison": 500, "result": DetectorPriorityLevel.HIGH},
+                {"type": ok.type, "comparison": 500, "result": DetectorPriorityLevel.OK},
+            ],
+            "environment": self.environment.name,
+        }