fix(3129) Grouping behaviour for demo alert

API changes

engine/apps/alerts/models/alert.py

@@ -96,7 +96,7 @@ def create(
         integration_unique_data: typing.Optional[typing.Dict],
         raw_request_data: RawRequestData,
         enable_autoresolve=True,
-        is_demo: bool = False,
+        group_alerts: bool = True,
         channel_filter: typing.Optional["ChannelFilter"] = None,
         received_at: typing.Optional[str] = None,
     ) -> "Alert":
@@ -109,7 +109,7 @@ def create(
         parsed_labels = gather_labels_from_alert_receive_channel_and_raw_request_data(
             alert_receive_channel, raw_request_data
         )
-        group_data = Alert.render_group_data(alert_receive_channel, raw_request_data, parsed_labels, is_demo)
+        group_data = Alert.render_group_data(alert_receive_channel, raw_request_data, parsed_labels, group_alerts)
 
         if channel_filter is None:
             channel_filter = ChannelFilter.select_filter(alert_receive_channel, raw_request_data, parsed_labels)
@@ -247,7 +247,7 @@ def render_group_data(
         alert_receive_channel: "AlertReceiveChannel",
         raw_request_data: RawRequestData,
         labels: typing.Optional[AlertLabels],
-        is_demo=False,
+        group_alerts=True,
     ) -> "AlertGroup.GroupData":
         from apps.alerts.models import AlertGroup
 
@@ -278,8 +278,8 @@ def render_group_data(
                 grouping_id_template, "grouping_id_template", alert_receive_channel, raw_request_data, labels
             )
 
-        # Insert random uuid to prevent grouping of demo alerts or alerts with group_distinction=None
-        if is_demo or not group_distinction:
+        # Insert random uuid to prevent grouping of demo alerts or alerts with group_distinction=None #
+        if not group_alerts or not group_distinction:
             group_distinction = cls.insert_random_uuid(group_distinction)
 
         if group_distinction is not None:

engine/apps/alerts/models/alert_receive_channel.py

@@ -666,7 +666,7 @@ def heartbeat_module(self):
         return getattr(heartbeat, self.integration, None)
 
     # Demo alerts
-    def send_demo_alert(self, payload: typing.Optional[typing.Dict] = None) -> None:
+    def send_demo_alert(self, payload: typing.Optional[typing.Dict] = None, group_alerts: bool = True) -> None:
         logger.info(f"send_demo_alert integration={self.pk}")
 
         if not self.is_demo_alert_enabled:
@@ -687,7 +687,7 @@ def send_demo_alert(self, payload: typing.Optional[typing.Dict] = None) -> None:
                     "Unable to send demo alert as payload has no 'alerts' key, it is not array, or it is empty."
                 )
             for alert in alerts:
-                create_alertmanager_alerts.delay(alert_receive_channel_pk=self.pk, alert=alert, is_demo=True)
+                create_alertmanager_alerts.delay(alert_receive_channel_pk=self.pk, alert=alert, group_alerts=group_alerts)
         else:
             timestamp = timezone.now().isoformat()
             create_alert.delay(
@@ -698,7 +698,7 @@ def send_demo_alert(self, payload: typing.Optional[typing.Dict] = None) -> None:
                 alert_receive_channel_pk=self.pk,
                 integration_unique_data=None,
                 raw_request_data=payload,
-                is_demo=True,
+                group_alerts=group_alerts,
                 received_at=timestamp,
             )
 

engine/apps/alerts/tests/test_alert_receiver_channel.py

@@ -108,7 +108,7 @@ def test_send_demo_alert(mocked_create_alert, make_organization, make_alert_rece
     )
     alert_receive_channel.send_demo_alert(payload=payload)
     assert mocked_create_alert.called
-    assert mocked_create_alert.call_args.args[1]["is_demo"]
+    assert mocked_create_alert.call_args.args[1]["group_alerts"]
     assert (
         mocked_create_alert.call_args.args[1]["raw_request_data"] == payload
         or alert_receive_channel.config.example_payload
@@ -139,7 +139,7 @@ def test_send_demo_alert_alertmanager_payload_shape(
     alert_receive_channel = make_alert_receive_channel(organization, integration=integration)
     alert_receive_channel.send_demo_alert(payload=payload)
     assert mocked_create_alert.called
-    assert mocked_create_alert.call_args.args[1]["is_demo"]
+    assert mocked_create_alert.call_args.args[1]["group_alerts"]
     assert (
         mocked_create_alert.call_args.args[1]["alert"] == payload["alerts"][0]
         if payload

engine/apps/api/tests/test_alert_receive_channel.py

@@ -1140,6 +1140,40 @@ def test_alert_receive_channel_send_demo_alert(
     response = client.post(url, format="json", **make_user_auth_headers(user, token))
     assert response.status_code == status.HTTP_200_OK
 
+@pytest.mark.django_db
+@pytest.mark.parametrize(
+    "group_alerts,expected_status",
+    [
+        ("random_str", status.HTTP_400_BAD_REQUEST),
+        ({}, status.HTTP_400_BAD_REQUEST),
+        (True, status.HTTP_200_OK)
+    ],
+)
+def test_alert_receive_channel_send_demo_alert_incorrect_group_alerts(
+    make_organization_and_user_with_plugin_token,
+    make_user_auth_headers,
+    make_alert_receive_channel,
+    group_alerts,
+    expected_status
+):
+    organization, user, token = make_organization_and_user_with_plugin_token()
+    alert_receive_channel = make_alert_receive_channel(
+        organization, integration=AlertReceiveChannel.INTEGRATION_GRAFANA
+    )
+    client = APIClient()
+
+    url = reverse(
+        "api-internal:alert_receive_channel-send-demo-alert",
+        kwargs={"pk": alert_receive_channel.public_primary_key},
+    )
+
+    data = {
+        "group_alerts": group_alerts
+    }
+
+    response = client.post(url, data=data, format="json", **make_user_auth_headers(user, token))
+    assert response.status_code == expected_status
+
 
 @pytest.mark.django_db
 def test_alert_receive_channel_send_demo_alert_not_enabled(

engine/apps/api/views/alert_receive_channel.py

@@ -264,6 +264,7 @@ def paginate_queryset(self, queryset):
             name="AlertReceiveChannelSendDemoAlert",
             fields={
                 "demo_alert_payload": serializers.DictField(required=False, allow_null=True),
+                "group_alerts": serializers.DictField(required=False, allow_null=True)
             },
         ),
         responses={status.HTTP_200_OK: None},
@@ -272,12 +273,16 @@ def paginate_queryset(self, queryset):
     def send_demo_alert(self, request, pk):
         instance = self.get_object()
         payload = request.data.get("demo_alert_payload", None)
+        group_alerts = request.data.get("group_alerts", True)
+
+        if not isinstance(group_alerts, bool):
+            raise BadRequest(detail="group_alerts for demo alert must be a boolean")
 
         if payload is not None and not isinstance(payload, dict):
             raise BadRequest(detail="Payload for demo alert must be a valid json object")
 
         try:
-            instance.send_demo_alert(payload=payload)
+            instance.send_demo_alert(payload=payload, group_alerts=group_alerts)
         except UnableToSendDemoAlert as e:
             raise BadRequest(detail=str(e))
 

engine/apps/integrations/tasks.py

@@ -27,7 +27,7 @@
     retry_backoff=True,
     max_retries=1 if settings.DEBUG else None,
 )
-def create_alertmanager_alerts(alert_receive_channel_pk, alert, is_demo=False, received_at=None):
+def create_alertmanager_alerts(alert_receive_channel_pk, alert, group_alerts=False, received_at=None):
     from apps.alerts.models import Alert, AlertReceiveChannel
 
     alert_receive_channel = AlertReceiveChannel.objects_with_deleted.get(pk=alert_receive_channel_pk)
@@ -48,7 +48,7 @@ def create_alertmanager_alerts(alert_receive_channel_pk, alert, is_demo=False, r
             integration_unique_data=None,
             raw_request_data=alert,
             enable_autoresolve=False,
-            is_demo=is_demo,
+            group_alerts=group_alerts,
             received_at=received_at,
         )
     except ConcurrentUpdateError:
@@ -85,7 +85,7 @@ def create_alert(
     alert_receive_channel_pk: int,
     integration_unique_data: typing.Optional[typing.Dict],
     raw_request_data: "Alert.RawRequestData",
-    is_demo: bool = False,
+    group_alerts: bool = True,
     received_at: typing.Optional[str] = None,
 ) -> None:
     from apps.alerts.models import Alert, AlertReceiveChannel
@@ -107,7 +107,7 @@ def create_alert(
             alert_receive_channel=alert_receive_channel,
             integration_unique_data=integration_unique_data,
             raw_request_data=raw_request_data,
-            is_demo=is_demo,
+            group_alerts=group_alerts,
             received_at=received_at,
         )
         logger.debug(