feat(group-by-alerts): add group by alerts metric issue functionality

Author: JoshFerge

src/sentry/incidents/grouptype.py

@@ -27,7 +27,12 @@
 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 DetectorException, DetectorPriorityLevel, DetectorSettings
+from sentry.workflow_engine.types import (
+    DetectorException,
+    DetectorGroupKey,
+    DetectorPriorityLevel,
+    DetectorSettings,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -189,6 +194,7 @@ def create_occurrence(
         evaluation_result: ProcessedDataConditionGroup,
         data_packet: DataPacket[MetricUpdate],
         priority: DetectorPriorityLevel,
+        group_key: DetectorGroupKey | None = None,
     ) -> tuple[DetectorOccurrence, EventData]:
         try:
             detector_trigger = DataCondition.objects.get(
@@ -223,7 +229,7 @@ def create_occurrence(
         return (
             DetectorOccurrence(
                 issue_title=self.detector.name,
-                subtitle=self.construct_title(snuba_query, detector_trigger, priority),
+                subtitle=self.construct_title(snuba_query, detector_trigger, priority, group_key),
                 evidence_data={
                     **self.build_detector_evidence_data(evaluation_result, data_packet, priority),
                 },
@@ -243,15 +249,40 @@ def extract_dedupe_value(self, data_packet: DataPacket[MetricUpdate]) -> int:
     def extract_value(self, data_packet: DataPacket[MetricUpdate]) -> MetricResult:
         # this is a bit of a hack - anomaly detection data packets send extra data we need to pass along
         values = data_packet.packet.values
-        if isinstance(data_packet.packet, AnomalyDetectionUpdate):
-            return {None: values}
-        return values.get("value")
+        # Check if this is grouped data returned in our data packet
+        if "groups" in values:
+            # Return grouped data as dict[DetectorGroupKey, int]
+            grouped_values = {}
+            for group_data in values["groups"]:
+                group_keys = group_data.get("group_keys", {})
+                group_value = group_data.get("value", 0)
+
+                # Create group key from group keys
+                group_key = self._create_group_key(group_keys)
+                grouped_values[group_key] = group_value
+
+            return grouped_values
+        else:
+            if values.get("value") is not None:
+                return values.get("value")
+            return values
+
+    def _create_group_key(self, group_keys: dict[str, str]) -> str:
+        """Create a deterministic group key from group keys"""
+        if not group_keys:
+            return None
+
+        # Sort keys for deterministic fingerprint.
+        sorted_items = sorted(group_keys.items())
+        key_string = ",".join(f"{k}={v}" for k, v in sorted_items)
+        return key_string
 
     def construct_title(
         self,
         snuba_query: SnubaQuery,
         detector_trigger: DataCondition,
         priority: DetectorPriorityLevel,
+        group_key: DetectorGroupKey | None = None,
     ) -> str:
         comparison_delta = self.detector.config.get("comparison_delta")
         detection_type = self.detector.config.get("detection_type")
@@ -308,8 +339,12 @@ def construct_title(
         else:
             comparison = detector_trigger.comparison
 
-        template = "{label}: {metric} in the last {time_window} {higher_or_lower} {comparison}"
+        template = (
+            "{group_key} {label}: {metric} in the last {time_window} {higher_or_lower} {comparison}"
+        )
+
         return template.format(
+            group_key=group_key,
             label=label.capitalize(),
             metric=aggregate,
             higher_or_lower=higher_or_lower,

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

@@ -115,6 +115,7 @@ def create_occurrence(
         evaluation_result: ProcessedDataConditionGroup,
         data_packet: DataPacket[DataPacketType],
         priority: DetectorPriorityLevel,
+        group_key: DetectorGroupKey | None = None,
     ) -> tuple[DetectorOccurrence, EventData]:
         """
         This method provides the value that was evaluated against, the data packet that was

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

@@ -522,7 +522,7 @@ def _build_detector_evaluation_result(
         else:
             # Call the `create_occurrence` method to create the detector occurrence.
             detector_occurrence, event_data = self.create_occurrence(
-                condition_results, data_packet, new_priority
+                condition_results, data_packet, new_priority, group_key
             )
             detector_result = self._create_decorated_issue_occurrence(
                 data_packet,

tests/sentry/incidents/utils/test_metric_issue_base.py

@@ -1,21 +1,26 @@
-from datetime import UTC, datetime, timedelta
+from datetime import UTC, datetime, timedelta, timezone
 
-from sentry.incidents.grouptype import MetricIssue
+from sentry.incidents.grouptype import MetricIssue, MetricIssueDetectorHandler
 from sentry.incidents.utils.constants import INCIDENTS_SNUBA_SUBSCRIPTION_TYPE
 from sentry.incidents.utils.types import (
     DATA_SOURCE_SNUBA_QUERY_SUBSCRIPTION,
     ProcessedSubscriptionUpdate,
+    QuerySubscriptionUpdate,
 )
 from sentry.issues.issue_occurrence import IssueOccurrence
 from sentry.issues.status_change_message import StatusChangeMessage
 from sentry.snuba.dataset import Dataset
 from sentry.snuba.models import SnubaQuery, SnubaQueryEventType
 from sentry.snuba.subscriptions import create_snuba_query, create_snuba_subscription
 from sentry.testutils.cases import TestCase
-from sentry.workflow_engine.models import DataPacket
-from sentry.workflow_engine.models.data_condition import Condition
+from sentry.testutils.helpers.datetime import freeze_time
+from sentry.workflow_engine.models import Condition, DataCondition, DataPacket
 from sentry.workflow_engine.processors.data_packet import process_data_packet
-from sentry.workflow_engine.types import DetectorEvaluationResult, DetectorPriorityLevel
+from sentry.workflow_engine.types import (
+    DetectorEvaluationResult,
+    DetectorGroupKey,
+    DetectorPriorityLevel,
+)
 
 
 class BaseMetricIssueTest(TestCase):
@@ -97,3 +102,126 @@ def process_packet_and_return_result(
             return None
         evaluation_result: DetectorEvaluationResult = results[0][1][self.detector_group_key]
         return evaluation_result.result
+
+
+@freeze_time()
+class TestEvaluateMetricDetectorGroupBy(BaseMetricIssueTest):
+    def setUp(self):
+        super().setUp()
+        self.detector = self.create_detector(
+            project=self.project,
+            workflow_condition_group=self.create_data_condition_group(),
+            type=MetricIssue.slug,
+            created_by_id=self.user.id,
+        )
+        self.critical_detector_trigger = self.create_data_condition(
+            type=Condition.GREATER,
+            comparison=5,
+            condition_result=DetectorPriorityLevel.HIGH,
+            condition_group=self.detector.workflow_condition_group,
+        )
+        self.warning_detector_trigger = self.create_data_condition(
+            comparison=3,
+            type=Condition.GREATER,
+            condition_result=DetectorPriorityLevel.MEDIUM,
+            condition_group=self.detector.workflow_condition_group,
+        )
+        with self.tasks():
+            self.snuba_query = create_snuba_query(
+                query_type=SnubaQuery.Type.ERROR,
+                dataset=Dataset.Events,
+                query="hello",
+                aggregate="count()",
+                time_window=timedelta(minutes=1),
+                resolution=timedelta(minutes=1),
+                environment=self.environment,
+                event_types=[SnubaQueryEventType.EventType.ERROR],
+                group_by=["level"],
+            )
+            self.query_subscription = create_snuba_subscription(
+                project=self.detector.project,
+                subscription_type=INCIDENTS_SNUBA_SUBSCRIPTION_TYPE,
+                snuba_query=self.snuba_query,
+            )
+        self.alert_rule = self.create_alert_rule()
+        self.create_alert_rule_detector(alert_rule_id=self.alert_rule.id, detector=self.detector)
+
+        self.handler = MetricIssueDetectorHandler(self.detector)
+
+    def test_metric_issue_occurrence(self):
+        self.detector_group_keys = ["level=error", "level=warning"]
+        self.detector_group_values = {
+            "groups": [
+                {
+                    "group_keys": {"level": "error"},
+                    "value": self.critical_detector_trigger.comparison + 1,
+                },
+                {
+                    "group_keys": {"level": "warning"},
+                    "value": self.warning_detector_trigger.comparison + 2,
+                },
+            ],
+        }
+        self.threshold_values = ["Critical", "Warning"]
+        self.comparison_values = [5, 3]
+
+        packet = ProcessedSubscriptionUpdate(
+            entity="entity",
+            subscription_id=str(self.query_subscription.id),
+            values=self.detector_group_values,
+            timestamp=datetime.now(timezone.utc),
+        )
+        data_packet = DataPacket[QuerySubscriptionUpdate](
+            source_id=str(self.query_subscription.id), packet=packet
+        )
+
+        result: dict[DetectorGroupKey, DetectorEvaluationResult] = self.handler.evaluate(
+            data_packet
+        )
+        for detector_group_key, detector_group_value, threshold_value, comparison_value in zip(
+            self.detector_group_keys,
+            self.detector_group_values["groups"],
+            self.threshold_values,
+            self.comparison_values,
+        ):
+            evaluation_result: DetectorEvaluationResult = result[detector_group_key]
+            assert isinstance(evaluation_result.result, IssueOccurrence)
+            occurrence: IssueOccurrence = evaluation_result.result
+            assert occurrence is not None
+            assert occurrence.issue_title == self.detector.name
+            assert (
+                occurrence.subtitle
+                == f"{detector_group_key} {threshold_value}: Number of events in the last minute above {comparison_value}"
+            )
+            assert occurrence.level == "error"
+
+    def generate_evidence_data(
+        self,
+        value: int,
+        detector_trigger: DataCondition,
+        extra_trigger: DataCondition | None = None,
+    ):
+        evidence_data = {
+            "detector_id": self.detector.id,
+            "value": detector_trigger.condition_result,
+            "alert_id": self.alert_rule.id,
+            "data_packet_source_id": str(self.query_subscription.id),
+            "conditions": [
+                {
+                    "id": detector_trigger.id,
+                    "type": detector_trigger.type,
+                    "comparison": detector_trigger.comparison,
+                    "condition_result": detector_trigger.condition_result.value,
+                },
+            ],
+        }
+        if extra_trigger:
+            evidence_data["conditions"].append(
+                {
+                    "id": extra_trigger.id,
+                    "type": extra_trigger.type,
+                    "comparison": extra_trigger.comparison,
+                    "condition_result": extra_trigger.condition_result.value,
+                }
+            )
+        return evidence_data