support activity metric alerts path too for data + renderer

Author: Christinarlong

src/sentry/notifications/platform/slack/renderers/metric_alert.py

@@ -7,7 +7,7 @@
 from sentry.integrations.slack.message_builder.incidents import SlackIncidentsMessageBuilder
 from sentry.notifications.platform.renderer import NotificationRenderer
 from sentry.notifications.platform.slack.provider import SlackRenderable
-from sentry.notifications.platform.templates.metric_alert import MetricAlertNotificationData
+from sentry.notifications.platform.templates.metric_alert import BaseMetricAlertNotificationData
 from sentry.notifications.platform.types import (
     NotificationData,
     NotificationProviderKey,
@@ -22,15 +22,13 @@ class SlackMetricAlertRenderer(NotificationRenderer[SlackRenderable]):
     def render[DataT: NotificationData](
         cls, *, data: DataT, rendered_template: NotificationRenderedTemplate
     ) -> SlackRenderable:
-        if not isinstance(data, MetricAlertNotificationData):
+        if not isinstance(data, BaseMetricAlertNotificationData):
             raise ValueError(f"SlackMetricAlertRenderer does not support {data.__class__.__name__}")
 
-        # Re-fetch GroupEvent — needed to rebuild MetricIssueContext
-        event = data.event
         organization = data.organization
 
-        # Rebuild MetricIssueContext (the only context that holds ORM instances)
-        metric_issue_context = MetricAlertNotificationData.get_metric_issue_context(event)
+        # Rebuild MetricIssueContext — each subclass implements this differently
+        metric_issue_context = data.build_metric_issue_context()
 
         # Deserialize pre-computed contexts (no Action/Detector/GroupOpenPeriod re-queries)
         alert_context = data.alert_context.to_alert_context()

src/sentry/notifications/platform/templates/__init__.py

@@ -1,12 +1,13 @@
 from .data_export import DataExportFailureTemplate, DataExportSuccessTemplate
 from .issue import IssueNotificationTemplate
-from .metric_alert import MetricAlertNotificationTemplate
+from .metric_alert import ActivityMetricAlertNotificationTemplate, MetricAlertNotificationTemplate
 
 __all__ = (
     "DataExportSuccessTemplate",
     "DataExportFailureTemplate",
     "IssueNotificationTemplate",
     "MetricAlertNotificationTemplate",
+    "ActivityMetricAlertNotificationTemplate",
 )
 # All templates should be imported here so they are registered in the notifications Django app.
 # See sentry/notifications/apps.py

src/sentry/notifications/platform/templates/metric_alert.py

@@ -10,6 +10,7 @@
     MetricIssueContext,
     OpenPeriodContext,
 )
+from sentry.models.activity import Activity
 from sentry.models.group import Group
 from sentry.models.organization import Organization
 from sentry.notifications.platform.registry import template_registry
@@ -107,37 +108,24 @@ def to_open_period_context(self) -> OpenPeriodContext:
         )
 
 
-class MetricAlertNotificationData(NotificationData):
-    source: NotificationSource = NotificationSource.METRIC_ALERT
+class BaseMetricAlertNotificationData(NotificationData):
+    """
+    Shared fields and properties for metric alert notification data.
 
-    # For re-fetching GroupEvent via eventstore (MetricIssueContext has ORM instances)
-    event_id: str
-    project_id: int
-    group_id: int
+    Subclasses differ only in how they source MetricIssueContext
+    - MetricAlertNotificationData: re-fetches GroupEvent from Snuba
+    - ActivityMetricAlertNotificationData: re-fetches Activity
+    """
 
-    # For feature flag check(chartcuterie) + message builder
+    group_id: int
     organization_id: int
-    # To rebuild the contexts
     detector_id: int
 
-    # Pre-computed serializable contexts
     alert_context: SerializableAlertContext
     open_period_context: SerializableOpenPeriodContext
 
     notification_uuid: str
 
-    @property
-    def event(self) -> GroupEvent:
-        event = eventstore.backend.get_event_by_id(
-            self.project_id, self.event_id, group_id=self.group_id
-        )
-        if event is None:
-            raise ValueError(f"Event {self.event_id} not found")
-        elif not isinstance(event, GroupEvent):
-            raise ValueError(f"Event {self.event_id} is not a GroupEvent")
-
-        return event
-
     @property
     def organization(self) -> Organization:
         return Organization.objects.get_from_cache(id=self.organization_id)
@@ -166,41 +154,97 @@ def serialized_detector(self) -> DetectorSerializerResponse:
 
         return get_detector_serializer(self.detector)
 
-    @classmethod
-    def get_metric_issue_context(cls, event: GroupEvent) -> MetricIssueContext:
+    def build_metric_issue_context(self) -> MetricIssueContext:
+        raise NotImplementedError
+
+
+class MetricAlertNotificationData(BaseMetricAlertNotificationData):
+    source: NotificationSource = NotificationSource.METRIC_ALERT
+
+    event_id: str
+    project_id: int
+
+    @property
+    def event(self) -> GroupEvent:
+        event = eventstore.backend.get_event_by_id(
+            self.project_id, self.event_id, group_id=self.group_id
+        )
+        if event is None:
+            raise ValueError(f"Event {self.event_id} not found")
+        elif not isinstance(event, GroupEvent):
+            raise ValueError(f"Event {self.event_id} is not a GroupEvent")
+
+        return event
+
+    def build_metric_issue_context(self) -> MetricIssueContext:
         from sentry.notifications.notification_action.types import BaseMetricAlertHandler
 
+        event = self.event
         evidence_data, priority = BaseMetricAlertHandler._extract_from_group_event(event)
         return MetricIssueContext.from_group_event(event.group, evidence_data, priority)
 
 
+class ActivityMetricAlertNotificationData(BaseMetricAlertNotificationData):
+    source: NotificationSource = NotificationSource.ACTIVITY_METRIC_ALERT
+
+    activity_id: int
+
+    @property
+    def activity(self) -> Activity:
+        return Activity.objects.get(id=self.activity_id)
+
+    def build_metric_issue_context(self) -> MetricIssueContext:
+        from sentry.notifications.notification_action.types import BaseMetricAlertHandler
+
+        evidence_data, priority = BaseMetricAlertHandler._extract_from_activity(self.activity)
+        return MetricIssueContext.from_group_event(self.group, evidence_data, priority)
+
+
+_EXAMPLE_ALERT_CONTEXT = SerializableAlertContext(
+    name="Example Alert",
+    action_identifier_id=1,
+    detection_type="static",
+)
+_EXAMPLE_OPEN_PERIOD_CONTEXT = SerializableOpenPeriodContext(
+    id=1,
+    date_started=datetime(2024, 1, 1, 0, 0, 0),
+)
+
+
 @template_registry.register(NotificationSource.METRIC_ALERT)
 class MetricAlertNotificationTemplate(NotificationTemplate[MetricAlertNotificationData]):
     category = NotificationCategory.METRIC_ALERT
-    # hide_from_debugger because this template uses a custom renderer that bypasses
-    # the standard NotificationRenderedTemplate rendering path so wouldn't load correctly in the debugger.
     hide_from_debugger = True
     example_data = MetricAlertNotificationData(
         event_id="abc123",
         project_id=1,
         group_id=1,
         organization_id=1,
         detector_id=1,
-        alert_context=SerializableAlertContext(
-            name="Example Alert",
-            action_identifier_id=1,
-            detection_type="static",
-        ),
-        open_period_context=SerializableOpenPeriodContext(
-            id=1,
-            date_started=datetime(2024, 1, 1, 0, 0, 0),
-        ),
+        alert_context=_EXAMPLE_ALERT_CONTEXT,
+        open_period_context=_EXAMPLE_OPEN_PERIOD_CONTEXT,
         notification_uuid="test-uuid",
     )
 
     def render(self, data: MetricAlertNotificationData) -> NotificationRenderedTemplate:
-        # The actual rendering is handled by the provider-specific custom renderer
-        # (e.g. SlackMetricAlertRenderer), which rebuilds MetricIssueContext from the
-        # re-fetched GroupEvent and builds the full payload via SlackIncidentsMessageBuilder.
-        # This method returns a minimal fallback for providers without a custom renderer.
+        return NotificationRenderedTemplate(subject="Metric Alert", body=[])
+
+
+@template_registry.register(NotificationSource.ACTIVITY_METRIC_ALERT)
+class ActivityMetricAlertNotificationTemplate(
+    NotificationTemplate[ActivityMetricAlertNotificationData]
+):
+    category = NotificationCategory.METRIC_ALERT
+    hide_from_debugger = True
+    example_data = ActivityMetricAlertNotificationData(
+        group_id=1,
+        organization_id=1,
+        detector_id=1,
+        alert_context=_EXAMPLE_ALERT_CONTEXT,
+        open_period_context=_EXAMPLE_OPEN_PERIOD_CONTEXT,
+        notification_uuid="test-uuid",
+        activity_id=1,
+    )
+
+    def render(self, data: ActivityMetricAlertNotificationData) -> NotificationRenderedTemplate:
         return NotificationRenderedTemplate(subject="Metric Alert", body=[])

src/sentry/notifications/platform/types.py

@@ -58,6 +58,7 @@ class NotificationSource(StrEnum):
 
     # METRIC_ALERT
     METRIC_ALERT = "metric-alert"
+    ACTIVITY_METRIC_ALERT = "activity-metric-alert"
 
     # SEER
     SEER_AUTOFIX_ERROR = "seer-autofix-error"
@@ -93,6 +94,7 @@ class NotificationSource(StrEnum):
     ],
     NotificationCategory.METRIC_ALERT: [
         NotificationSource.METRIC_ALERT,
+        NotificationSource.ACTIVITY_METRIC_ALERT,
     ],
     NotificationCategory.SEER: [
         NotificationSource.SEER_AUTOFIX_TRIGGER,

tests/sentry/notifications/platform/slack/renderers/test_metric_alert.py

@@ -1,15 +1,18 @@
 from __future__ import annotations
 
+from dataclasses import asdict
 from datetime import datetime, timezone
 from typing import Any
 from unittest.mock import MagicMock, patch
 
 import pytest
 
 from sentry.incidents.typings.metric_detector import AlertContext, OpenPeriodContext
+from sentry.models.activity import Activity
 from sentry.notifications.platform.slack.provider import SlackNotificationProvider
 from sentry.notifications.platform.slack.renderers.metric_alert import SlackMetricAlertRenderer
 from sentry.notifications.platform.templates.metric_alert import (
+    ActivityMetricAlertNotificationData,
     MetricAlertNotificationData,
     SerializableAlertContext,
     SerializableOpenPeriodContext,
@@ -21,6 +24,7 @@
 )
 from sentry.testutils.cases import TestCase
 from sentry.testutils.helpers.features import with_feature
+from sentry.types.activity import ActivityType
 from sentry.workflow_engine.types import DetectorPriorityLevel
 from tests.sentry.notifications.notification_action.test_metric_alert_registry_handlers import (
     MetricAlertHandlerBase,
@@ -186,3 +190,72 @@ def test_render_continues_when_chart_fails(
         blocks: list[Any] = result["blocks"]
         assert len(blocks) == 1
         assert blocks[0]["type"] == "section"
+
+
+class SlackActivityMetricAlertRendererTest(MetricAlertHandlerBase):
+    def setUp(self) -> None:
+        super().setUp()
+        self.create_models()
+
+        activity = Activity(
+            project=self.project,
+            group=self.group,
+            type=ActivityType.SET_RESOLVED.value,
+            data=asdict(self.evidence_data),
+        )
+        activity.save()
+
+        alert_context = AlertContext.from_workflow_engine_models(
+            self.detector,
+            self.evidence_data,
+            self.group.status,
+            DetectorPriorityLevel.HIGH,
+        )
+        open_period_context = OpenPeriodContext.from_group(self.group)
+
+        self.notification_data = ActivityMetricAlertNotificationData(
+            group_id=self.group.id,
+            organization_id=self.organization.id,
+            detector_id=self.detector.id,
+            alert_context=SerializableAlertContext.from_alert_context(alert_context),
+            open_period_context=SerializableOpenPeriodContext.from_open_period_context(
+                open_period_context
+            ),
+            activity_id=activity.id,
+            notification_uuid="test-uuid",
+        )
+        self.rendered_template = NotificationRenderedTemplate(subject="Metric Alert", body=[])
+
+    def test_render_produces_blocks_without_snuba(self) -> None:
+        # The Activity path re-fetches from Postgres only (no Snuba) — no eventstore mock needed
+        result = SlackMetricAlertRenderer.render(
+            data=self.notification_data,
+            rendered_template=self.rendered_template,
+        )
+
+        blocks: list[Any] = result["blocks"]
+        assert len(blocks) == 1
+        assert blocks[0]["type"] == "section"
+        assert blocks[0]["text"]["type"] == "mrkdwn"
+        # "Resolved" appears in the fallback title (result["text"]), not the metric body block
+        assert "Resolved" in result["text"]
+        assert self.detector.name in result["text"]
+
+    @patch(
+        "sentry.notifications.platform.slack.renderers.metric_alert.build_metric_alert_chart",
+        return_value=MOCK_CHART_URL,
+    )
+    @with_feature({"organizations:metric-alert-chartcuterie": True})
+    def test_render_includes_image_block_when_chart_enabled(self, mock_chart: MagicMock) -> None:
+        result = SlackMetricAlertRenderer.render(
+            data=self.notification_data,
+            rendered_template=self.rendered_template,
+        )
+
+        blocks: list[Any] = result["blocks"]
+        assert len(blocks) == 2
+        assert blocks[0]["type"] == "section"
+        assert "Resolved" in result["text"]
+        assert blocks[1]["type"] == "image"
+        assert blocks[1]["image_url"] == MOCK_CHART_URL
+        assert blocks[1]["alt_text"] == "Metric Alert Chart"