feat(ACI): Update metric issue occurrence (#92702)

Update the metric issue occurrence to use real data instead of hard
coded data. We might still need to add things like `evidence_display`
and more `event_data` but this should be a solid start.

---------

Co-authored-by: getsantry[bot] <66042841+getsantry[bot]@users.noreply.github.com>

Author: 2 people

src/sentry/incidents/grouptype.py

@@ -2,22 +2,30 @@
 
 from dataclasses import dataclass
 from datetime import UTC, datetime
-from typing import Any
 
 from sentry import features
+from sentry.constants import CRASH_RATE_ALERT_AGGREGATE_ALIAS
 from sentry.incidents.handlers.condition import *  # noqa
 from sentry.incidents.metric_alert_detector import MetricAlertsDetectorValidator
 from sentry.incidents.models.alert_rule import AlertRuleDetectionType, ComparisonDeltaChoices
+from sentry.incidents.utils.format_duration import format_duration_idiomatic
+from sentry.incidents.utils.metric_issue_poc import QUERY_AGGREGATION_DISPLAY
 from sentry.incidents.utils.types import QuerySubscriptionUpdate
+from sentry.integrations.metric_alerts import TEXT_COMPARISON_DELTA
 from sentry.issues.grouptype import GroupCategory, GroupType
 from sentry.models.organization import Organization
 from sentry.ratelimits.sliding_windows import Quota
+from sentry.snuba.metrics import format_mri_field, is_mri_field
+from sentry.snuba.models import QuerySubscription, SnubaQuery
+from sentry.types.actor import parse_and_validate_actor
 from sentry.types.group import PriorityLevel
 from sentry.workflow_engine.handlers.detector import DetectorOccurrence, StatefulDetectorHandler
-from sentry.workflow_engine.handlers.detector.base import EvidenceData
+from sentry.workflow_engine.handlers.detector.base import EventData, EvidenceData
+from sentry.workflow_engine.models.alertrule_detector import AlertRuleDetector
+from sentry.workflow_engine.models.data_condition import Condition, DataCondition
 from sentry.workflow_engine.models.data_source import DataPacket
 from sentry.workflow_engine.processors.data_condition_group import ProcessedDataConditionGroup
-from sentry.workflow_engine.types import DetectorPriorityLevel, DetectorSettings
+from sentry.workflow_engine.types import DetectorException, DetectorPriorityLevel, DetectorSettings
 
 COMPARISON_DELTA_CHOICES: list[None | int] = [choice.value for choice in ComparisonDeltaChoices]
 COMPARISON_DELTA_CHOICES.append(None)
@@ -28,29 +36,130 @@ class MetricIssueEvidenceData(EvidenceData):
     alert_id: int
 
 
-class MetricAlertDetectorHandler(StatefulDetectorHandler[QuerySubscriptionUpdate, int]):
+class MetricIssueDetectorHandler(StatefulDetectorHandler[QuerySubscriptionUpdate, int]):
     def create_occurrence(
         self,
         evaluation_result: ProcessedDataConditionGroup,
         data_packet: DataPacket[QuerySubscriptionUpdate],
         priority: DetectorPriorityLevel,
-    ) -> tuple[DetectorOccurrence, dict[str, Any]]:
-        # Returning a placeholder for now, this may require us passing more info
-        occurrence = DetectorOccurrence(
-            issue_title="Some Issue Title",
-            subtitle="An Issue Subtitle",
-            type=MetricIssue,
-            level="error",
-            culprit="Some culprit",
+    ) -> tuple[DetectorOccurrence, EventData]:
+        try:
+            alert_rule_detector = AlertRuleDetector.objects.get(detector=self.detector)
+            alert_id = alert_rule_detector.alert_rule_id
+        except AlertRuleDetector.DoesNotExist:
+            alert_id = None
+
+        try:
+            detector_trigger = DataCondition.objects.get(
+                condition_group=self.detector.workflow_condition_group, condition_result=priority
+            )
+        except DataCondition.DoesNotExist:
+            raise DetectorException(
+                f"Failed to find detector trigger for detector id {self.detector.id}, cannot create metric issue occurrence"
+            )
+
+        try:
+            query_subscription = QuerySubscription.objects.get(id=data_packet.source_id)
+        except QuerySubscription.DoesNotExist:
+            raise DetectorException(
+                f"Failed to find query subscription for detector id {self.detector.id}, cannot create metric issue occurrence"
+            )
+
+        try:
+            snuba_query = SnubaQuery.objects.get(id=query_subscription.snuba_query_id)
+        except SnubaQuery.DoesNotExist:
+            raise DetectorException(
+                f"Failed to find snuba query for detector id {self.detector.id}, cannot create metric issue occurrence"
+            )
+
+        try:
+            assignee = parse_and_validate_actor(
+                str(self.detector.created_by_id), self.detector.project.organization_id
+            )
+        except Exception:
+            assignee = None
+
+        title = self.construct_title(snuba_query, detector_trigger, priority)
+        event_data = {
+            "environment": self.detector.config.get("environment"),
+            "platform": None,
+            "sdk": None,
+        }  # XXX: may need to add to this
+
+        return (
+            DetectorOccurrence(
+                issue_title=self.detector.name,
+                subtitle=title,
+                resource_id=None,
+                evidence_data={
+                    "alert_id": alert_id,
+                },
+                evidence_display=[],  # XXX: may need to pass more info here for the front end
+                type=MetricIssue,
+                level="error",
+                culprit="",
+                priority=priority,
+                assignee=assignee,
+            ),
+            event_data,
         )
-        return occurrence, {}
 
     def extract_dedupe_value(self, data_packet: DataPacket[QuerySubscriptionUpdate]) -> int:
         return int(data_packet.packet.get("timestamp", datetime.now(UTC)).timestamp())
 
     def extract_value(self, data_packet: DataPacket[QuerySubscriptionUpdate]) -> int:
         return data_packet.packet["values"]["value"]
 
+    def construct_title(
+        self,
+        snuba_query: SnubaQuery,
+        detector_trigger: DataCondition,
+        priority: DetectorPriorityLevel,
+    ) -> str:
+        comparison_delta = self.detector.config.get("comparison_delta")
+        agg_display_key = snuba_query.aggregate
+
+        if is_mri_field(agg_display_key):
+            aggregate = format_mri_field(agg_display_key)
+        elif CRASH_RATE_ALERT_AGGREGATE_ALIAS in agg_display_key:
+            agg_display_key = agg_display_key.split(f"AS {CRASH_RATE_ALERT_AGGREGATE_ALIAS}")[
+                0
+            ].strip()
+            aggregate = QUERY_AGGREGATION_DISPLAY.get(agg_display_key, agg_display_key)
+        else:
+            aggregate = QUERY_AGGREGATION_DISPLAY.get(agg_display_key, agg_display_key)
+
+        # Determine the higher or lower comparison
+        higher_or_lower = ""
+        if detector_trigger.type == Condition.GREATER:
+            higher_or_lower = "greater than" if comparison_delta else "above"
+        else:
+            higher_or_lower = "less than" if comparison_delta else "below"
+
+        label = "Warning" if priority == DetectorPriorityLevel.MEDIUM else "Critical"
+
+        # Format the time window for the threshold
+        time_window = format_duration_idiomatic(snuba_query.time_window // 60)
+
+        # If the detector_trigger has a comparison delta, format the comparison string
+        comparison: str | int | float = "threshold"
+        if comparison_delta:
+            comparison_delta_minutes = comparison_delta // 60
+            comparison = TEXT_COMPARISON_DELTA.get(
+                comparison_delta_minutes, f"same time {comparison_delta_minutes} minutes ago "
+            )
+        else:
+            comparison = detector_trigger.comparison
+
+        template = "{label}: {metric} in the last {time_window} {higher_or_lower} {comparison}"
+        return template.format(
+            label=label.capitalize(),
+            metric=aggregate,
+            higher_or_lower=higher_or_lower,
+            comparison=comparison,
+            time_window=time_window,
+        )
+
 
 # Example GroupType and detector handler for metric alerts. We don't create these issues yet, but we'll use something
 # like these when we're sending issues as alerts
@@ -65,8 +174,9 @@ class MetricIssue(GroupType):
     default_priority = PriorityLevel.HIGH
     enable_auto_resolve = False
     enable_escalation_detection = False
+    enable_status_change_workflow_notifications = False
     detector_settings = DetectorSettings(
-        handler=MetricAlertDetectorHandler,
+        handler=MetricIssueDetectorHandler,
         validator=MetricAlertsDetectorValidator,
         config_schema={
             "$schema": "https://json-schema.org/draft/2020-12/schema",

src/sentry/workflow_engine/handlers/detector/stateful.py

@@ -525,8 +525,8 @@ def _evaluation_detector_conditions(
                 if condition_result.result is not None
                 and isinstance(condition_result.result, DetectorPriorityLevel)
             ]
-
-            new_priority = max(new_priority, *validated_condition_results)
+            if validated_condition_results:
+                new_priority = max(new_priority, *validated_condition_results)
 
         return condition_evaluation, new_priority
 

src/sentry/workflow_engine/types.py

@@ -22,6 +22,10 @@
 T = TypeVar("T")
 
 
+class DetectorException(Exception):
+    pass
+
+
 class DetectorPriorityLevel(IntEnum):
     OK = 0
     LOW = PriorityLevel.LOW

tests/sentry/workflow_engine/handlers/detector/test_base.py

@@ -186,7 +186,7 @@ def tearDown(self):
         self.uuid_patcher.stop()
         self.sm_comp_patcher.stop()
 
-    def create_detector_and_conditions(self, type: str | None = None):
+    def create_detector_and_condition(self, type: str | None = None):
         if type is None:
             type = "handler_with_state"
         self.project = self.create_project()
@@ -195,19 +195,19 @@ def create_detector_and_conditions(self, type: str | None = None):
             workflow_condition_group=self.create_data_condition_group(),
             type=type,
         )
-        self.create_data_condition(
+        data_condition = self.create_data_condition(
             type=Condition.GREATER,
             comparison=5,
             condition_result=DetectorPriorityLevel.HIGH,
             condition_group=detector.workflow_condition_group,
         )
-        return detector
+        return detector, data_condition
 
     def build_handler(
         self, detector: Detector | None = None, detector_type=None
     ) -> MockDetectorStateHandler:
         if detector is None:
-            detector = self.create_detector_and_conditions(detector_type)
+            detector, _ = self.create_detector_and_condition(detector_type)
         return MockDetectorStateHandler(detector)
 
     def assert_updates(