Add responders improvements

docs/sources/open-source/_index.md

@@ -96,7 +96,7 @@ features:
       should_escape: false
     - command: /escalate
       url: <ONCALL_ENGINE_PUBLIC_URL>/slack/interactive_api_endpoint/
-      description: Direct page user(s) or schedule(s)
+      description: Direct page a team or user(s)
       should_escape: false
 oauth_config:
   redirect_urls:

engine/apps/alerts/models/alert_group.py

@@ -70,6 +70,15 @@ class LogRecordUser(typing.TypedDict):
     avatar_full: str
 
 
+class PagedUser(typing.TypedDict):
+    username: str
+    name: str
+    pk: str
+    avatar: str
+    avatar_full: str
+    important: bool
+
+
 class LogRecords(typing.TypedDict):
     time: str  # humanized delta relative to now
     action: str  # human-friendly description
@@ -509,22 +518,55 @@ def declare_incident_link(self) -> str:
     def happened_while_maintenance(self):
         return self.root_alert_group is not None and self.root_alert_group.maintenance_uuid is not None
 
-    def get_paged_users(self) -> QuerySet[User]:
+    def get_paged_users(self) -> typing.List[PagedUser]:
         from apps.alerts.models import AlertGroupLogRecord
 
-        users_ids = set()
-        for log_record in self.log_records.filter(
+        user_ids: typing.Set[str] = set()
+        users: typing.List[PagedUser] = []
+
+        log_records = self.log_records.filter(
             type__in=(AlertGroupLogRecord.TYPE_DIRECT_PAGING, AlertGroupLogRecord.TYPE_UNPAGE_USER)
-        ):
+        )
+
+        for log_record in log_records:
             # filter paging events, track still active escalations
             info = log_record.get_step_specific_info()
             user_id = info.get("user") if info else None
+            important = info.get("important") if info else None
+
             if user_id is not None:
-                users_ids.add(
+                user_ids.add(
                     user_id
-                ) if log_record.type == AlertGroupLogRecord.TYPE_DIRECT_PAGING else users_ids.discard(user_id)
+                ) if log_record.type == AlertGroupLogRecord.TYPE_DIRECT_PAGING else user_ids.discard(user_id)
+
+        user_instances = User.objects.filter(public_primary_key__in=user_ids)
+        user_map = {u.public_primary_key: u for u in user_instances}
 
-        return User.objects.filter(public_primary_key__in=users_ids)
+        # mostly doing this second loop to avoid having to query each user individually in the first loop
+        for log_record in log_records:
+            # filter paging events, track still active escalations
+            info = log_record.get_step_specific_info()
+            user_id = info.get("user") if info else None
+            important = info.get("important") if info else False
+
+            if user_id is not None and (user := user_map.get(user_id)) is not None:
+                if log_record.type == AlertGroupLogRecord.TYPE_DIRECT_PAGING:
+                    # add the user
+                    users.append(
+                        {
+                            "pk": user.public_primary_key,
+                            "name": user.name,
+                            "username": user.username,
+                            "avatar": user.avatar_url,
+                            "avatar_full": user.avatar_full_url,
+                            "important": important,
+                        }
+                    )
+                else:
+                    # user was unpaged at some point, remove them
+                    users = [u for u in users if u["pk"] != user_id]
+
+        return users
 
     def _get_response_time(self):
         """Return response_time based on current alert group status."""

engine/apps/alerts/paging.py

@@ -1,53 +1,20 @@
-import enum
 import typing
 from uuid import uuid4
 
 from django.db import transaction
-from django.db.models import Q
 
 from apps.alerts.models import (
     Alert,
     AlertGroup,
     AlertGroupLogRecord,
     AlertReceiveChannel,
     ChannelFilter,
-    EscalationChain,
     UserHasNotification,
 )
 from apps.alerts.tasks.notify_user import notify_user_task
-from apps.schedules.ical_utils import list_users_to_notify_from_ical
-from apps.schedules.models import OnCallSchedule
 from apps.user_management.models import Organization, Team, User
 
-
-class PagingError(enum.StrEnum):
-    USER_HAS_NO_NOTIFICATION_POLICY = "USER_HAS_NO_NOTIFICATION_POLICY"
-    USER_IS_NOT_ON_CALL = "USER_IS_NOT_ON_CALL"
-
-
-# notifications: (User|Schedule, important)
 UserNotifications = list[tuple[User, bool]]
-ScheduleNotifications = list[tuple[OnCallSchedule, bool]]
-
-
-class NoNotificationPolicyWarning(typing.TypedDict):
-    error: typing.Literal[PagingError.USER_HAS_NO_NOTIFICATION_POLICY]
-    data: typing.Dict
-
-
-ScheduleWarnings = typing.Dict[str, typing.List[str]]
-
-
-class _NotOnCallWarningData(typing.TypedDict):
-    schedules: ScheduleWarnings
-
-
-class NotOnCallWarning(typing.TypedDict):
-    error: typing.Literal[PagingError.USER_IS_NOT_ON_CALL]
-    data: _NotOnCallWarningData
-
-
-AvailabilityWarning = NoNotificationPolicyWarning | NotOnCallWarning
 
 
 class DirectPagingAlertGroupResolvedError(Exception):
@@ -56,6 +23,12 @@ class DirectPagingAlertGroupResolvedError(Exception):
     DETAIL = "Cannot add responders for a resolved alert group"  # Returned in BadRequest responses and Slack warnings
 
 
+class DirectPagingUserTeamValidationError(Exception):
+    """Raised when trying to use direct paging and no team or user is specified."""
+
+    DETAIL = "No team or user(s) specified"  # Returned in BadRequest responses and Slack warnings
+
+
 class _OnCall(typing.TypedDict):
     title: str
     message: str
@@ -68,14 +41,7 @@ class DirectPagingAlertPayload(typing.TypedDict):
     oncall: _OnCall
 
 
-def _trigger_alert(
-    organization: Organization,
-    team: Team | None,
-    title: str,
-    message: str,
-    from_user: User,
-    escalation_chain: EscalationChain = None,
-) -> AlertGroup:
+def _trigger_alert(organization: Organization, team: Team | None, message: str, from_user: User) -> AlertGroup:
     """Trigger manual integration alert from params."""
     alert_receive_channel = AlertReceiveChannel.get_or_create_manual_integration(
         organization=organization,
@@ -87,37 +53,24 @@ def _trigger_alert(
             "verbal_name": f"Direct paging ({team.name if team else 'No'} team)",
         },
     )
+
+    channel_filter = None
     if alert_receive_channel.default_channel_filter is None:
-        ChannelFilter.objects.create(
+        channel_filter = ChannelFilter.objects.create(
             alert_receive_channel=alert_receive_channel,
             notify_in_slack=True,
             is_default=True,
         )
 
-    channel_filter = None
-    if escalation_chain is not None:
-        channel_filter, _ = ChannelFilter.objects.get_or_create(
-            alert_receive_channel=alert_receive_channel,
-            escalation_chain=escalation_chain,
-            is_default=False,
-            defaults={
-                "filtering_term": f"escalate to {escalation_chain.name}",
-                "notify_in_slack": True,
-            },
-        )
-
-    permalink = None
-    if not title:
-        title = "Message from {}".format(from_user.username)
-
+    title = "Direct page from {}".format(from_user.username)
     payload: DirectPagingAlertPayload = {
         # Custom oncall property in payload to simplify rendering
         "oncall": {
             "title": title,
             "message": message,
             "uid": str(uuid4()),  # avoid grouping
             "author_username": from_user.username,
-            "permalink": permalink,
+            "permalink": None,
         },
     }
 
@@ -134,107 +87,40 @@ def _trigger_alert(
     return alert.group
 
 
-def check_user_availability(user: User) -> typing.List[AvailabilityWarning]:
-    """Check user availability to be paged.
-
-    Return a warnings list indicating `error` and any additional related `data`.
-    """
-    warnings: typing.List[AvailabilityWarning] = []
-    if not user.notification_policies.exists():
-        warnings.append(
-            {
-                "error": PagingError.USER_HAS_NO_NOTIFICATION_POLICY,
-                "data": {},
-            }
-        )
-
-    is_on_call = False
-    schedules = OnCallSchedule.objects.filter(
-        Q(cached_ical_file_primary__contains=user.username) | Q(cached_ical_file_primary__contains=user.email),
-        organization=user.organization,
-    )
-    schedules_data: ScheduleWarnings = {}
-    for s in schedules:
-        # keep track of schedules and on call users to suggest if needed
-        oncall_users = list_users_to_notify_from_ical(s)
-        schedules_data[s.name] = set(u.public_primary_key for u in oncall_users)
-        if user in oncall_users:
-            is_on_call = True
-            break
-
-    if not is_on_call:
-        # user is not on-call
-        # TODO: check working hours
-        warnings.append(
-            {
-                "error": PagingError.USER_IS_NOT_ON_CALL,
-                "data": {"schedules": schedules_data},
-            }
-        )
-
-    return warnings
-
-
 def direct_paging(
     organization: Organization,
-    team: Team | None,
     from_user: User,
-    title: str = None,
-    message: str = None,
+    message: str,
+    team: Team | None = None,
     users: UserNotifications | None = None,
-    schedules: ScheduleNotifications | None = None,
-    escalation_chain: EscalationChain | None = None,
     alert_group: AlertGroup | None = None,
 ) -> AlertGroup | None:
-    """Trigger escalation targeting given users/schedules.
+    """Trigger escalation targeting given team/users.
 
     If an alert group is given, update escalation to include the specified users.
-    Otherwise, create a new alert using given title and message.
-
+    Otherwise, create a new alert using given message.
     """
-
     if users is None:
         users = []
 
-    if schedules is None:
-        schedules = []
-
-    if escalation_chain is not None and alert_group is not None:
-        raise ValueError("Cannot change an existing alert group escalation chain")
+    if not users and team is None:
+        raise DirectPagingUserTeamValidationError
 
     # Cannot add responders to a resolved alert group
     if alert_group and alert_group.resolved:
         raise DirectPagingAlertGroupResolvedError
 
     # create alert group if needed
     if alert_group is None:
-        alert_group = _trigger_alert(organization, team, title, message, from_user, escalation_chain=escalation_chain)
-
-    # initialize direct paged users (without a schedule)
-    users = [(u, important, None) for u, important in users]
-
-    # get on call users, add log entry for each schedule
-    for s, important in schedules:
-        oncall_users = list_users_to_notify_from_ical(s)
-        users += [(u, important, s) for u in oncall_users]
-        alert_group.log_records.create(
-            type=AlertGroupLogRecord.TYPE_DIRECT_PAGING,
-            author=from_user,
-            reason=f"{from_user.username} paged schedule {s.name}",
-            step_specific_info={"schedule": s.public_primary_key},
-        )
+        alert_group = _trigger_alert(organization, team, message, from_user)
 
-    for u, important, schedule in users:
-        reason = f"{from_user.username} paged user {u.username}"
-        if schedule:
-            reason += f" (from schedule {schedule.name})"
+    for u, important in users:
         alert_group.log_records.create(
             type=AlertGroupLogRecord.TYPE_DIRECT_PAGING,
             author=from_user,
-            reason=reason,
+            reason=f"{from_user.username} paged user {u.username}",
             step_specific_info={
                 "user": u.public_primary_key,
-                "schedule": schedule.public_primary_key if schedule else None,
                 "important": important,
             },
         )

engine/apps/alerts/tests/test_alert_group.py

@@ -482,3 +482,48 @@ def test_alert_group_log_record_action_source(
     alert_group.un_attach_by_user(user, action_source=action_source)
     log_record = alert_group.log_records.last()
     assert (log_record.type, log_record.action_source) == (AlertGroupLogRecord.TYPE_UNATTACHED, action_source)
+
+
+@pytest.mark.django_db
+def test_alert_group_get_paged_users(
+    make_organization_and_user,
+    make_user_for_organization,
+    make_alert_receive_channel,
+    make_alert_group,
+):
+    organization, user = make_organization_and_user()
+    other_user = make_user_for_organization(organization)
+    alert_receive_channel = make_alert_receive_channel(organization)
+
+    def _make_log_record(alert_group, user, log_type, important=False):
+        alert_group.log_records.create(
+            type=log_type,
+            author=user,
+            reason="paged user",
+            step_specific_info={
+                "user": user.public_primary_key,
+                "important": important,
+            },
+        )
+
+    # user was paged - also check that important is persisted/available
+    alert_group = make_alert_group(alert_receive_channel)
+    _make_log_record(alert_group, user, AlertGroupLogRecord.TYPE_DIRECT_PAGING)
+    _make_log_record(alert_group, other_user, AlertGroupLogRecord.TYPE_DIRECT_PAGING, True)
+
+    paged_users = {u["pk"]: u["important"] for u in alert_group.get_paged_users()}
+
+    assert user.public_primary_key in paged_users
+    assert paged_users[user.public_primary_key] is False
+
+    assert other_user.public_primary_key in paged_users
+    assert paged_users[other_user.public_primary_key] is True
+
+    # user was paged and then unpaged
+    alert_group = make_alert_group(alert_receive_channel)
+    _make_log_record(alert_group, user, AlertGroupLogRecord.TYPE_DIRECT_PAGING)
+    _make_log_record(alert_group, user, AlertGroupLogRecord.TYPE_UNPAGE_USER)
+
+    _make_log_record(alert_group, other_user, AlertGroupLogRecord.TYPE_DIRECT_PAGING)
+
+    alert_group.get_paged_users()[0]["pk"] == other_user.public_primary_key