Revert "chore(slack): default message builder to block kit (#68016)"

This reverts commit 5b6682b.

Co-authored-by: cathteng <70817427+cathteng@users.noreply.github.com>

Author: 2 people

src/sentry/integrations/slack/message_builder/issues.py

@@ -10,7 +10,7 @@
 from django.utils.translation import gettext as _
 from sentry_relay.processing import parse_release
 
-from sentry import tagstore
+from sentry import features, tagstore
 from sentry.api.endpoints.group_details import get_group_global_count
 from sentry.constants import LOG_LEVELS_MAP
 from sentry.eventstore.models import GroupEvent
@@ -22,6 +22,7 @@
     format_actor_option,
     format_actor_options,
     get_color,
+    get_timestamp,
     get_title_link,
 )
 from sentry.integrations.slack.message_builder import (
@@ -264,20 +265,36 @@ def get_context(group: Group) -> str:
     return context_text.rstrip()
 
 
+def get_option_groups(group: Group) -> Sequence[Mapping[str, Any]]:
+    all_members = group.project.get_members_as_rpc_users()
+    members = list({m.id: m for m in all_members}.values())
+    teams = group.project.teams.all()
+
+    option_groups = []
+    if teams:
+        option_groups.append({"text": "Teams", "options": format_actor_options(teams)})
+
+    if members:
+        option_groups.append({"text": "People", "options": format_actor_options(members)})
+
+    return option_groups
+
+
 def get_option_groups_block_kit(group: Group) -> Sequence[Mapping[str, Any]]:
     all_members = group.project.get_members_as_rpc_users()
     members = list({m.id: m for m in all_members}.values())
     teams = group.project.teams.all()
+    use_block_kit = features.has("organizations:slack-block-kit", group.project.organization)
 
     option_groups = []
     if teams:
-        team_options = format_actor_options(teams, True)
+        team_options = format_actor_options(teams, use_block_kit)
         option_groups.append(
             {"label": {"type": "plain_text", "text": "Teams"}, "options": team_options}
         )
 
     if members:
-        member_options = format_actor_options(members, True)
+        member_options = format_actor_options(members, use_block_kit)
         option_groups.append(
             {"label": {"type": "plain_text", "text": "People"}, "options": member_options}
         )
@@ -408,51 +425,91 @@ def build_actions(
     identity: RpcIdentity | None = None,
 ) -> tuple[Sequence[MessageAction], str, str]:
     """Having actions means a button will be shown on the Slack message e.g. ignore, resolve, assign."""
+    use_block_kit = features.has("organizations:slack-block-kit", project.organization)
+
     if actions and identity:
         text = get_action_text(text, actions, identity)
         return [], text, "_actioned_issue"
 
     status = group.get_status()
 
-    def _ignore_button() -> MessageAction | None:
+    def _ignore_button(use_block_kit) -> MessageAction | None:
         if group.issue_category == GroupCategory.FEEDBACK:
             return None
+        if use_block_kit:
+            if status == GroupStatus.IGNORED:
+                return MessageAction(
+                    name="status", label="Mark as Ongoing", value="unresolved:ongoing"
+                )
+            return MessageAction(name="status", label="Archive", value="archive_dialog")
+
         if status == GroupStatus.IGNORED:
-            return MessageAction(name="status", label="Mark as Ongoing", value="unresolved:ongoing")
+            return MessageAction(
+                name="status",
+                label="Mark as Ongoing",
+                value="unresolved:ongoing",
+            )
 
-        return MessageAction(name="status", label="Archive", value="archive_dialog")
+        return MessageAction(
+            name="status",
+            label="Archive",
+            value="ignored:until_escalating",
+        )
+
+    def _resolve_button(use_block_kit) -> MessageAction:
+        if use_block_kit:
+            if status == GroupStatus.RESOLVED:
+                return MessageAction(
+                    name="unresolved:ongoing", label="Unresolve", value="unresolved:ongoing"
+                )
+            if not project.flags.has_releases:
+                return MessageAction(name="status", label="Resolve", value="resolved")
+            return MessageAction(
+                name="status",
+                label="Resolve",
+                value="resolve_dialog",
+            )
 
-    def _resolve_button() -> MessageAction:
         if status == GroupStatus.RESOLVED:
             return MessageAction(
-                name="unresolved:ongoing", label="Unresolve", value="unresolved:ongoing"
+                name="status",
+                label="Unresolve",
+                value="unresolved:ongoing",
             )
-        if not project.flags.has_releases:
-            return MessageAction(name="status", label="Resolve", value="resolved")
 
+        if not project.flags.has_releases:
+            return MessageAction(
+                name="status",
+                label="Resolve",
+                value="resolved",
+            )
         return MessageAction(
-            name="status",
-            label="Resolve",
+            name="resolve_dialog",
+            label="Resolve...",
             value="resolve_dialog",
         )
 
-    def _assign_button() -> MessageAction:
+    def _assign_button(use_block_kit) -> MessageAction:
         assignee = group.get_assignee()
         assign_button = MessageAction(
             name="assign",
             label="Select Assignee...",
             type="select",
-            selected_options=format_actor_options([assignee], True) if assignee else [],
-            option_groups=get_option_groups_block_kit(group),
+            selected_options=format_actor_options([assignee]) if assignee else [],
+            option_groups=(
+                get_option_groups(group)
+                if not use_block_kit
+                else get_option_groups_block_kit(group)
+            ),
         )
         return assign_button
 
     action_list = [
         a
         for a in [
-            _resolve_button(),
-            _ignore_button(),
-            _assign_button(),
+            _resolve_button(use_block_kit),
+            _ignore_button(use_block_kit),
+            _assign_button(use_block_kit),
         ]
         if a is not None
     ]
@@ -495,6 +552,9 @@ def __init__(
         self.skip_fallback = skip_fallback
         self.notes = notes
         self.commits = commits
+        self.use_block_kit = features.has(
+            "organizations:slack-block-kit", group.project.organization
+        )
 
     @property
     def escape_text(self) -> bool:
@@ -508,7 +568,14 @@ def build(self, notification_uuid: str | None = None) -> SlackBlock | SlackAttac
         text = build_attachment_text(self.group, self.event) or ""
         text = text.strip(" \n")
 
-        text = escape_slack_markdown_text(text)
+        if self.use_block_kit:
+            text = escape_slack_markdown_text(text)
+        if not self.use_block_kit and self.escape_text:
+            text = escape_slack_text(text)
+            # XXX(scefali): Not sure why we actually need to do this just for unfurled messages.
+            # If we figure out why this is required we should note it here because it's quite strange
+            if self.is_unfurl:
+                text = escape_slack_text(text)
 
         # This link does not contain user input (it's a static label and a url), must not escape it.
         replay_link = build_attachment_replay_link(self.group, self.event)
@@ -517,6 +584,7 @@ def build(self, notification_uuid: str | None = None) -> SlackBlock | SlackAttac
         # If an event is unspecified, use the tags of the latest event (if one exists).
         event_for_tags = self.event or self.group.get_latest_event()
         color = get_color(event_for_tags, self.notification, self.group)
+        fields = build_tag_fields(event_for_tags, self.tags)
         footer = (
             self.notification.build_notification_footer(self.recipient, ExternalProviders.SLACK)
             if self.notification and self.recipient
@@ -550,6 +618,25 @@ def build(self, notification_uuid: str | None = None) -> SlackBlock | SlackAttac
         )
         title = build_attachment_title(obj)
 
+        if not features.has("organizations:slack-block-kit", self.group.project.organization):
+            if replay_link:
+                text += f"\n\n{replay_link}"
+            if action_text and self.identity:
+                text += "\n" + action_text
+
+            return self._build(
+                actions=payload_actions,
+                callback_id=json.dumps({"issue": self.group.id}),
+                color=color,
+                fallback=self.build_fallback_text(obj, project.slug),
+                fields=fields,
+                footer=footer,
+                text=text,
+                title=title,
+                title_link=title_link,
+                ts=get_timestamp(self.group, self.event) if not self.issue_details else None,
+            )
+
         # build up the blocks for newer issue alert formatting #
 
         # build title block

src/sentry/testutils/cases.py

@@ -646,21 +646,16 @@ def detect_performance_problems_interceptor(
                     perf_problem.fingerprint = fingerprint
             return perf_problems
 
-        with (
-            mock.patch(
-                "sentry.issues.ingest.send_issue_occurrence_to_eventstream",
-                side_effect=send_issue_occurrence_to_eventstream,
-            ) as mock_eventstream,
-            mock.patch(
-                "sentry.event_manager.detect_performance_problems",
-                side_effect=detect_performance_problems_interceptor,
-            ),
-            mock.patch.object(
-                issue_type, "noise_config", new=NoiseConfig(noise_limit, timedelta(minutes=1))
-            ),
-            override_options(
-                {"performance.issues.all.problem-detection": 1.0, detector_option: 1.0}
-            ),
+        with mock.patch(
+            "sentry.issues.ingest.send_issue_occurrence_to_eventstream",
+            side_effect=send_issue_occurrence_to_eventstream,
+        ) as mock_eventstream, mock.patch(
+            "sentry.event_manager.detect_performance_problems",
+            side_effect=detect_performance_problems_interceptor,
+        ), mock.patch.object(
+            issue_type, "noise_config", new=NoiseConfig(noise_limit, timedelta(minutes=1))
+        ), override_options(
+            {"performance.issues.all.problem-detection": 1.0, detector_option: 1.0}
         ):
             event = perf_event_manager.save(project_id)
             if mock_eventstream.call_args:
@@ -2856,15 +2851,14 @@ def responses_context(self):
     def assert_performance_issue_attachments(
         self, attachment, project_slug, referrer, alert_type="workflow"
     ):
-        assert "N+1 Query" in attachment["text"]
+        assert attachment["title"] == "N+1 Query"
         assert (
-            "db - SELECT `books_author`.`id`, `books_author`.`name` FROM `books_author` WHERE `books_author`.`id` = %s LIMIT 21"
-            in attachment["blocks"][1]["text"]["text"]
+            attachment["text"]
+            == "db - SELECT `books_author`.`id`, `books_author`.`name` FROM `books_author` WHERE `books_author`.`id` = %s LIMIT 21"
         )
-        title_link = attachment["blocks"][0]["text"]["text"][13:][1:-1]
-        notification_uuid = self.get_notification_uuid(title_link)
+        notification_uuid = self.get_notification_uuid(attachment["title_link"])
         assert (
-            attachment["blocks"][-2]["elements"][0]["text"]
+            attachment["footer"]
             == f"{project_slug} | production | <http://testserver/settings/account/notifications/{alert_type}/?referrer={referrer}&notification_uuid={notification_uuid}|Notification Settings>"
         )
 

tests/sentry/integrations/slack/notifications/test_assigned.py

@@ -8,7 +8,7 @@
 from sentry.testutils.cases import PerformanceIssueTestCase, SlackActivityNotificationTest
 from sentry.testutils.helpers.features import with_feature
 from sentry.testutils.helpers.notifications import TEST_ISSUE_OCCURRENCE, TEST_PERF_ISSUE_OCCURRENCE
-from sentry.testutils.helpers.slack import get_blocks_and_fallback_text
+from sentry.testutils.helpers.slack import get_attachment, get_blocks_and_fallback_text
 from sentry.testutils.skips import requires_snuba
 from sentry.types.activity import ActivityType
 from sentry.types.integrations import ExternalProviders
@@ -111,6 +111,22 @@ def test_multiple_orgs(self):
         channel = data["channel"][0]
         assert channel == self.identity.external_id
 
+    @responses.activate
+    def test_assignment(self):
+        """
+        Test that a Slack message is sent with the expected payload when an issue is assigned
+        """
+        with self.tasks():
+            self.create_notification(self.group, AssignedActivityNotification).send()
+        attachment, text = get_attachment()
+        assert text == f"Issue assigned to {self.name} by themselves"
+        assert attachment["title"] == self.group.title
+        notification_uuid = self.get_notification_uuid(attachment["title_link"])
+        assert (
+            attachment["footer"]
+            == f"{self.project.slug} | <http://testserver/settings/account/notifications/workflow/?referrer=assigned_activity-slack-user&notification_uuid={notification_uuid}|Notification Settings>"
+        )
+
     @responses.activate
     @with_feature("organizations:slack-block-kit")
     def test_assignment_block(self):
@@ -133,6 +149,29 @@ def test_assignment_block(self):
             == f"{self.project.slug} | <http://testserver/settings/account/notifications/workflow/?referrer=assigned_activity-slack-user&notification_uuid={notification_uuid}|Notification Settings>"
         )
 
+    @responses.activate
+    @mock.patch(
+        "sentry.eventstore.models.GroupEvent.occurrence",
+        return_value=TEST_ISSUE_OCCURRENCE,
+        new_callable=mock.PropertyMock,
+    )
+    def test_assignment_generic_issue(self, occurrence):
+        """
+        Test that a Slack message is sent with the expected payload when a generic issue type is assigned
+        """
+        event = self.store_event(
+            data={"message": "Hellboy's world", "level": "error"}, project_id=self.project.id
+        )
+        group_event = event.for_group(event.groups[0])
+
+        with self.tasks():
+            self.create_notification(group_event.group, AssignedActivityNotification).send()
+        attachment, text = get_attachment()
+        assert text == f"Issue assigned to {self.name} by themselves"
+        self.assert_generic_issue_attachments(
+            attachment, self.project.slug, "assigned_activity-slack-user"
+        )
+
     @responses.activate
     @mock.patch(
         "sentry.eventstore.models.GroupEvent.occurrence",
@@ -163,6 +202,26 @@ def test_assignment_generic_issue_block(self, occurrence):
             "assigned_activity-slack",
         )
 
+    @responses.activate
+    @mock.patch(
+        "sentry.eventstore.models.GroupEvent.occurrence",
+        return_value=TEST_PERF_ISSUE_OCCURRENCE,
+        new_callable=mock.PropertyMock,
+    )
+    def test_assignment_performance_issue(self, occurrence):
+        """
+        Test that a Slack message is sent with the expected payload when a performance issue is assigned
+        """
+        event = self.create_performance_issue()
+        with self.tasks():
+            self.create_notification(event.group, AssignedActivityNotification).send()
+
+        attachment, text = get_attachment()
+        assert text == f"Issue assigned to {self.name} by themselves"
+        self.assert_performance_issue_attachments(
+            attachment, self.project.slug, "assigned_activity-slack-user"
+        )
+
     @responses.activate
     @mock.patch(
         "sentry.eventstore.models.GroupEvent.occurrence",