feat(rulesnooze): Don't notify if rule is snoozed (#47197)

This pr adds the removal of notifications for rules where a RuleSnooze
exists. This handles both cases of individual snoozing and everyone
having the alert snoozed.

Closes #46842

Author: roggenkemper

src/sentry/notifications/notifications/rules.py

@@ -73,6 +73,7 @@ def get_participants(self) -> Mapping[ExternalProviders, Iterable[RpcActor]]:
             event=self.event,
             notification_type=self.notification_setting_type,
             fallthrough_choice=self.fallthrough_choice,
+            rules=self.rules,
         )
 
     def get_subject(self, context: Mapping[str, Any] | None = None) -> str:

src/sentry/notifications/utils/participants.py

@@ -4,6 +4,8 @@
 from collections import defaultdict
 from typing import TYPE_CHECKING, Any, Iterable, List, Mapping, MutableMapping, Sequence, Tuple
 
+from django.db.models import Q
+
 from sentry import features
 from sentry.models import (
     ActorTuple,
@@ -16,6 +18,8 @@
     Project,
     ProjectOwnership,
     Release,
+    Rule,
+    RuleSnooze,
     Team,
     User,
 )
@@ -384,10 +388,25 @@ def get_send_to(
     event: Event | None = None,
     notification_type: NotificationSettingTypes = NotificationSettingTypes.ISSUE_ALERTS,
     fallthrough_choice: FallthroughChoiceType | None = None,
+    rules: Iterable[Rule] | None = None,
 ) -> Mapping[ExternalProviders, set[RpcActor]]:
     recipients = determine_eligible_recipients(
         project, target_type, target_identifier, event, fallthrough_choice
     )
+
+    if rules:
+        rule_snoozes = RuleSnooze.objects.filter(Q(rule__in=rules))
+        muted_user_ids = []
+        for rule_snooze in rule_snoozes:
+            if rule_snooze.user_id is None:
+                return {}
+            else:
+                muted_user_ids.append(rule_snooze.user_id)
+
+        if muted_user_ids:
+            recipients = filter(
+                lambda x: x.actor_type != ActorType.USER or x.id not in muted_user_ids, recipients
+            )
     return get_recipients_by_provider(project, recipients, notification_type)
 
 

tests/sentry/mail/test_adapter.py

@@ -31,6 +31,7 @@
     ProjectOwnership,
     Repository,
     Rule,
+    RuleSnooze,
     User,
     UserEmail,
     UserOption,
@@ -48,7 +49,7 @@
 from sentry.plugins.base import Notification
 from sentry.services.hybrid_cloud.actor import RpcActor
 from sentry.testutils import TestCase
-from sentry.testutils.helpers import override_options
+from sentry.testutils.helpers import override_options, with_feature
 from sentry.testutils.helpers.datetime import before_now, iso_format
 from sentry.testutils.silo import region_silo_test
 from sentry.types.activity import ActivityType
@@ -183,6 +184,82 @@ def test_simple_notification(self):
         assert msg.subject == "[Sentry] BAR-1 - Hello world"
         assert "my rule" in msg.alternatives[0][0]
 
+    @with_feature("organizations:mute-alerts")
+    def test_simple_snooze(self):
+        """Test that notification for alert snoozed by user is not send to that user."""
+        event = self.store_event(
+            data={"message": "Hello world", "level": "error"}, project_id=self.project.id
+        )
+
+        rule = self.create_project_rule(project=self.project)
+        RuleSnooze.objects.create(user_id=self.user.id, owner_id=self.user.id, rule=rule)
+        ProjectOwnership.objects.create(project_id=self.project.id, fallthrough=True)
+
+        notification = Notification(event=event, rule=rule)
+
+        with self.options({"system.url-prefix": "http://example.com"}), self.tasks():
+            self.adapter.notify(notification, ActionTargetType.ISSUE_OWNERS)
+
+        assert len(mail.outbox) == 0
+
+    @with_feature("organizations:mute-alerts")
+    def test_snooze_for_all(self):
+        """Test that notification for alert snoozed for everyone is not send to user."""
+        event = self.store_event(
+            data={"message": "Hello world", "level": "error"}, project_id=self.project.id
+        )
+
+        rule = self.create_project_rule(project=self.project)
+        RuleSnooze.objects.create(owner_id=self.user.id, rule=rule)
+        ProjectOwnership.objects.create(project_id=self.project.id, fallthrough=True)
+
+        notification = Notification(event=event, rule=rule)
+
+        with self.options({"system.url-prefix": "http://example.com"}), self.tasks():
+            self.adapter.notify(notification, ActionTargetType.ISSUE_OWNERS)
+
+        assert len(mail.outbox) == 0
+
+    @with_feature("organizations:mute-alerts")
+    def test_someone_else_snoozes_themself(self):
+        """Test that notification for alert snoozed by user2 for themself is sent to user"""
+        event = self.store_event(
+            data={"message": "Hello world", "level": "error"}, project_id=self.project.id
+        )
+
+        rule = self.create_project_rule(project=self.project)
+        user2 = self.create_user(email="[email protected]")
+        RuleSnooze.objects.create(user_id=user2.id, owner_id=user2.id, rule=rule)
+        ProjectOwnership.objects.create(project_id=self.project.id, fallthrough=True)
+
+        notification = Notification(event=event, rule=rule)
+
+        with self.options({"system.url-prefix": "http://example.com"}), self.tasks():
+            self.adapter.notify(notification, ActionTargetType.ISSUE_OWNERS)
+
+        assert len(mail.outbox) == 1
+        msg = mail.outbox[0]
+        assert msg.subject == "[Sentry] BAR-1 - Hello world"
+
+    @with_feature("organizations:mute-alerts")
+    def test_someone_else_snoozes_everyone(self):
+        """Test that notification for alert snoozed by user2 for everyone is not sent to user"""
+        event = self.store_event(
+            data={"message": "Hello world", "level": "error"}, project_id=self.project.id
+        )
+
+        rule = self.create_project_rule(project=self.project)
+        user2 = self.create_user(email="[email protected]")
+        RuleSnooze.objects.create(owner_id=user2.id, rule=rule)
+        ProjectOwnership.objects.create(project_id=self.project.id, fallthrough=True)
+
+        notification = Notification(event=event, rule=rule)
+
+        with self.options({"system.url-prefix": "http://example.com"}), self.tasks():
+            self.adapter.notify(notification, ActionTargetType.ISSUE_OWNERS)
+
+        assert len(mail.outbox) == 0
+
     def test_simple_notification_generic(self):
         """Test that an issue that is neither error nor performance type renders a generic email template"""
         event = self.store_event(