feat(np): migrate legacy issue alerts to np (#127289)

migrates legacy issue alerts to np for teams, slack, and discord.

- Shared send logic: metric and issue alerts now share the code that
builds the send target, decides whether to thread, and sends with
failure logging.
- Threading: follow-up alerts for the same issue reply in the original
Slack thread and are also posted to the channel, matching legacy. Uptime
and metric issues get a new thread for each open period.
- Activity updates: resolve, assign, archive and similar updates are now
also posted in Slack threads created by the platform. For uptime issues
they go only to the current open period's thread.
- Seer autofix: Slack threads from platform alerts are registered for
Seer autofix updates, always using the thread's root message.

---------

Co-authored-by: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>
Co-authored-by: Cursor Agent <cursoragent@cursor.com>

Author: 3 people

src/sentry/integrations/discord/integration.py

@@ -97,7 +97,7 @@ def send_notification(
         except ApiError as e:
             translate_discord_api_error(e)
 
-    def send_notification_with_threading(
+    def send_notification_with_response(
         self,
         target: IntegrationNotificationTarget,
         payload: DiscordRenderable,

src/sentry/integrations/msteams/integration.py

@@ -103,7 +103,7 @@ def send_notification(
         client = self.get_client()
         client.send_card(conversation_id=target.resource_id, card=payload)
 
-    def send_notification_with_threading(
+    def send_notification_with_response(
         self,
         target: IntegrationNotificationTarget,
         payload: AdaptiveCard,

src/sentry/integrations/slack/integration.py

@@ -122,7 +122,7 @@ def send_notification(
             translate_slack_api_error(e)
             return {}
 
-    def send_notification_with_threading(
+    def send_notification_with_response(
         self,
         target: IntegrationNotificationTarget,
         payload: SlackRenderable,

src/sentry/integrations/slack/service.py

@@ -37,6 +37,10 @@
 from sentry.models.group import Group
 from sentry.models.options.organization_option import OrganizationOption
 from sentry.notifications.additional_attachment_manager import get_additional_attachment
+from sentry.notifications.models.notificationthread import (
+    NotificationThread,
+    NotificationThreadObjectType,
+)
 from sentry.notifications.notifications.activity.archive import ArchiveActivityNotification
 from sentry.notifications.notifications.activity.assigned import AssignedActivityNotification
 from sentry.notifications.notifications.activity.base import GroupActivityNotification
@@ -58,6 +62,8 @@
 from sentry.notifications.notifications.activity.unassigned import UnassignedActivityNotification
 from sentry.notifications.notifications.activity.unresolved import UnresolvedActivityNotification
 from sentry.notifications.notifications.base import BaseNotification
+from sentry.notifications.platform.rollout import NotificationRolloutService
+from sentry.notifications.platform.types import SLACK_PROVIDERS, NotificationSource
 from sentry.notifications.utils.open_period import open_period_start_for_group
 from sentry.silo.base import SiloMode
 from sentry.types.activity import ActivityType
@@ -249,6 +255,25 @@ def _notify_all_threads_for_activity(
                     group_ids=[group.id],
                 )
 
+        # Also query platform threads for issue alerts sent via notification platform. Only orgs in
+        # a platform rollout tier have them, so skip the query for everyone else. This checks the
+        # tier, not the per-send random rollout rate, so replies reach every existing thread.
+        platform_threads = NotificationThread.objects.none()
+        if NotificationRolloutService(organization=group.organization).has_feature_flag_access():
+            platform_threads = NotificationThread.objects.filter(
+                object_type=NotificationThreadObjectType.GROUP,
+                object_id=group.id,
+                key_type=NotificationSource.ISSUE.value,
+                provider_key__in=SLACK_PROVIDERS,
+            )
+        if use_open_period_start:
+            # The platform thread key stores the open period start as an ISO string
+            platform_threads = platform_threads.filter(
+                key_data__open_period_start=(
+                    open_period_start.isoformat() if open_period_start else None
+                )
+            )
+
         # We don't wrap this in a lifecycle because _handle_parent_notification is already wrapped in a lifecycle
         parent_notification_count = 0
         for parent_notification in parent_notifications:
@@ -307,6 +332,34 @@ def _notify_all_threads_for_activity(
                 },
             )
 
+        # Send to platform threads
+        for platform_thread in platform_threads:
+            with MessagingInteractionEvent(
+                interaction_type=MessagingInteractionType.SEND_ACTIVITY_NOTIFICATION,
+                spec=SlackMessagingSpec(),
+            ).capture() as lifecycle:
+                lifecycle.add_extras(
+                    {
+                        "activity_id": activity.id,
+                        "platform_thread_id": platform_thread.id,
+                        "integration_id": client.integration_id,
+                        "group_id": group.id,
+                        "project_id": activity.project.id,
+                    }
+                )
+                try:
+                    self._send_notification_to_slack_channel(
+                        channel_id=platform_thread.target_id,
+                        message_identifier=platform_thread.thread_identifier,
+                        notification_to_send=notification_to_send,
+                        client=client,
+                    )
+                except Exception as err:
+                    if isinstance(err, SlackApiError):
+                        record_lifecycle_termination_level(lifecycle, err)
+                    else:
+                        lifecycle.record_failure(err)
+
     def _get_channel_id_from_parent_notification_notification_action(
         self,
         parent_notification: NotificationActionNotificationMessage,