feat: add notification channel test button and delivery detail view

Add ability to send test notifications through channels and inspect
full delivery attempt details including request/response bodies.

Author: raffaelschneider

lib/sentinel_cp/events.ex

@@ -189,6 +189,54 @@ defmodule SentinelCp.Events do
 
   def get_delivery_attempt(id), do: Repo.get(DeliveryAttempt, id)
 
+  def get_delivery_attempt!(id), do: Repo.get!(DeliveryAttempt, id)
+
+  @doc """
+  Sends a test notification through a channel by creating a synthetic
+  `system.test` event and scheduling delivery.
+  """
+  def test_channel(%Channel{} = channel) do
+    now = DateTime.utc_now() |> DateTime.truncate(:second)
+
+    {:ok, event} =
+      create_event(%{
+        type: "system.test",
+        payload: %{
+          channel_id: channel.id,
+          channel_name: channel.name,
+          message: "Test notification from Sentinel CP"
+        },
+        project_id: channel.project_id,
+        emitted_at: now
+      })
+
+    {:ok, attempt} =
+      %DeliveryAttempt{}
+      |> DeliveryAttempt.changeset(%{
+        event_id: event.id,
+        channel_id: channel.id,
+        status: "pending",
+        attempt_number: 1
+      })
+      |> Repo.insert()
+
+    DeliveryWorker.enqueue(attempt.id)
+    {:ok, attempt}
+  end
+
+  @doc """
+  Lists all delivery attempts for a given event+channel pair, ordered by attempt number.
+  Used to show the retry timeline for a delivery.
+  """
+  def list_attempt_chain(event_id, channel_id) do
+    from(d in DeliveryAttempt,
+      where: d.event_id == ^event_id and d.channel_id == ^channel_id,
+      order_by: [asc: d.attempt_number],
+      preload: [:event, :channel]
+    )
+    |> Repo.all()
+  end
+
   def list_delivery_attempts(opts \\ []) do
     limit = Keyword.get(opts, :limit, 50)
     channel_id = Keyword.get(opts, :channel_id)

lib/sentinel_cp/events/delivery_attempt.ex

@@ -19,6 +19,8 @@ defmodule SentinelCp.Events.DeliveryAttempt do
     field :attempt_number, :integer, default: 1
     field :next_retry_at, :utc_datetime
     field :completed_at, :utc_datetime
+    field :request_body, :string
+    field :response_body, :string
 
     belongs_to :event, SentinelCp.Events.Event
     belongs_to :channel, SentinelCp.Events.Channel
@@ -37,7 +39,9 @@ defmodule SentinelCp.Events.DeliveryAttempt do
       :error,
       :attempt_number,
       :next_retry_at,
-      :completed_at
+      :completed_at,
+      :request_body,
+      :response_body
     ])
     |> validate_required([:event_id, :channel_id, :status, :attempt_number])
     |> validate_inclusion(:status, @statuses)
@@ -49,7 +53,7 @@ defmodule SentinelCp.Events.DeliveryAttempt do
     now = DateTime.utc_now() |> DateTime.truncate(:second)
 
     attempt
-    |> cast(attrs, [:status, :http_status, :latency_ms, :error])
+    |> cast(attrs, [:status, :http_status, :latency_ms, :error, :request_body, :response_body])
     |> put_change(:completed_at, now)
     |> validate_inclusion(:status, @statuses)
   end

lib/sentinel_cp/events/delivery_worker.ex

@@ -41,6 +41,8 @@ defmodule SentinelCp.Events.DeliveryWorker do
     end
   end
 
+  @max_response_body_size 10_240
+
   defp execute_delivery(attempt, event, channel) do
     start_time = System.monotonic_time(:millisecond)
 
@@ -49,62 +51,103 @@ defmodule SentinelCp.Events.DeliveryWorker do
     |> Ecto.Changeset.change(%{status: "delivering"})
     |> Repo.update!()
 
-    result = deliver_to_channel(event, channel)
+    {result, request_body, response_body} = deliver_to_channel(event, channel)
     latency_ms = System.monotonic_time(:millisecond) - start_time
+    response_body = truncate_body(response_body)
 
     case result do
       {:ok, http_status} ->
         attempt
         |> DeliveryAttempt.complete_changeset(%{
           status: "delivered",
           http_status: http_status,
-          latency_ms: latency_ms
+          latency_ms: latency_ms,
+          request_body: request_body,
+          response_body: response_body
         })
         |> Repo.update!()
 
         :ok
 
       {:error, reason} ->
-        handle_failure(attempt, reason, latency_ms)
+        handle_failure(attempt, reason, latency_ms, request_body, response_body)
     end
   end
 
+  defp truncate_body(nil), do: nil
+
+  defp truncate_body(body) when byte_size(body) > @max_response_body_size do
+    String.slice(body, 0, @max_response_body_size) <> "\n... [truncated]"
+  end
+
+  defp truncate_body(body), do: body
+
   defp deliver_to_channel(event, %Channel{type: "slack", config: config}) do
     payload = Adapters.Slack.format_payload(event)
+    request_body = Jason.encode!(payload, pretty: true)
     webhook_url = config["webhook_url"]
-    Adapters.Slack.deliver(webhook_url, payload)
+    result = Adapters.Slack.deliver(webhook_url, payload)
+    {result, request_body, extract_response_body(result)}
   end
 
   defp deliver_to_channel(event, %Channel{type: "pagerduty", config: config}) do
     routing_key = config["routing_key"]
     payload = Adapters.PagerDuty.format_payload(event, routing_key)
-    Adapters.PagerDuty.deliver(routing_key, payload)
+    request_body = Jason.encode!(payload, pretty: true)
+    result = Adapters.PagerDuty.deliver(routing_key, payload)
+    {result, request_body, extract_response_body(result)}
   end
 
   defp deliver_to_channel(event, %Channel{type: "email", config: config}) do
     email_payload = Adapters.Email.format_payload(event)
+
+    request_body =
+      Jason.encode!(%{to: config["to"], subject: email_payload.subject}, pretty: true)
+
     to = config["to"]
     from = config["from"] || "noreply@sentinel-cp.local"
-    Adapters.Email.deliver(to, from, email_payload.subject, email_payload.body)
+    result = Adapters.Email.deliver(to, from, email_payload.subject, email_payload.body)
+
+    response_body =
+      case result do
+        {:ok, _} -> "Email queued"
+        {:error, reason} -> inspect(reason)
+      end
+
+    {result, request_body, response_body}
   end
 
   defp deliver_to_channel(event, %Channel{type: "teams", config: config}) do
     payload = Adapters.Teams.format_payload(event)
+    request_body = Jason.encode!(payload, pretty: true)
     webhook_url = config["webhook_url"]
-    Adapters.Teams.deliver(webhook_url, payload)
+    result = Adapters.Teams.deliver(webhook_url, payload)
+    {result, request_body, extract_response_body(result)}
   end
 
   defp deliver_to_channel(event, %Channel{type: "webhook", config: config} = channel) do
     payload = Adapters.Webhook.format_payload(event)
+    request_body = Jason.encode!(payload, pretty: true)
     url = config["url"]
-    Adapters.Webhook.deliver(url, payload, channel.signing_secret)
+    result = Adapters.Webhook.deliver(url, payload, channel.signing_secret)
+    {result, request_body, extract_response_body(result)}
   end
 
   defp deliver_to_channel(_event, %Channel{type: type}) do
-    {:error, {:unknown_channel_type, type}}
+    {{:error, {:unknown_channel_type, type}}, nil, nil}
   end
 
-  defp handle_failure(attempt, reason, latency_ms) do
+  defp extract_response_body({:ok, _status}), do: nil
+
+  defp extract_response_body({:error, {:http_error, _status, body}}) when is_binary(body),
+    do: body
+
+  defp extract_response_body({:error, {:http_error, _status, body}}),
+    do: inspect(body)
+
+  defp extract_response_body({:error, _reason}), do: nil
+
+  defp handle_failure(attempt, reason, latency_ms, request_body, response_body) do
     error_msg = inspect(reason)
 
     http_status =
@@ -120,7 +163,9 @@ defmodule SentinelCp.Events.DeliveryWorker do
         status: "dead_letter",
         http_status: http_status,
         latency_ms: latency_ms,
-        error: error_msg
+        error: error_msg,
+        request_body: request_body,
+        response_body: response_body
       })
       |> Repo.update!()
 
@@ -132,13 +177,15 @@ defmodule SentinelCp.Events.DeliveryWorker do
       # Schedule retry with exponential backoff
       next_retry = DeliveryAttempt.next_retry_time(attempt.attempt_number)
 
-      {:ok, new_attempt} =
+      {:ok, _new_attempt} =
         attempt
         |> DeliveryAttempt.complete_changeset(%{
           status: "failed",
           http_status: http_status,
           latency_ms: latency_ms,
-          error: error_msg
+          error: error_msg,
+          request_body: request_body,
+          response_body: response_body
         })
         |> Repo.update()
 
@@ -155,8 +202,6 @@ defmodule SentinelCp.Events.DeliveryWorker do
         |> Repo.insert()
 
       # Schedule the retry with delay
-      delay_seconds = DateTime.diff(next_retry, DateTime.utc_now(), :second) |> max(1)
-
       %{attempt_id: retry_attempt.id}
       |> __MODULE__.new(scheduled_at: next_retry)
       |> Oban.insert()

lib/sentinel_cp_web/live/notifications_live/channel_show.ex

@@ -26,6 +26,33 @@ defmodule SentinelCpWeb.NotificationsLive.ChannelShow do
     end
   end
 
+  @impl true
+  def handle_event("send_test", _, socket) do
+    channel = socket.assigns.channel
+    project = socket.assigns.project
+
+    case Events.test_channel(channel) do
+      {:ok, _attempt} ->
+        Audit.log_user_action(
+          socket.assigns.current_user,
+          "test",
+          "notification_channel",
+          channel.id,
+          project_id: project.id
+        )
+
+        attempts = Events.list_delivery_attempts(channel_id: channel.id, limit: 20)
+
+        {:noreply,
+         socket
+         |> assign(:attempts, attempts)
+         |> put_flash(:info, "Test notification sent.")}
+
+      {:error, _} ->
+        {:noreply, put_flash(socket, :error, "Could not send test notification.")}
+    end
+  end
+
   @impl true
   def handle_event("delete", _, socket) do
     channel = socket.assigns.channel
@@ -68,6 +95,9 @@ defmodule SentinelCpWeb.NotificationsLive.ChannelShow do
           <span class="badge badge-sm badge-outline">{@channel.type}</span>
         </:badge>
         <:action>
+          <button phx-click="send_test" class="btn btn-outline btn-sm">
+            Send Test
+          </button>
           <.link navigate={edit_path(@org, @project, @channel)} class="btn btn-outline btn-sm">
             Edit
           </.link>
@@ -129,7 +159,11 @@ defmodule SentinelCpWeb.NotificationsLive.ChannelShow do
           </thead>
           <tbody>
             <tr :for={a <- @attempts}>
-              <td><.status_badge status={a.status} /></td>
+              <td>
+                <.link navigate={attempt_path(@org, @project, a)} class="link">
+                  <.status_badge status={a.status} />
+                </.link>
+              </td>
               <td>{a.attempt_number}</td>
               <td>{a.http_status || "—"}</td>
               <td>{if a.latency_ms, do: "#{a.latency_ms}ms", else: "—"}</td>
@@ -182,4 +216,10 @@ defmodule SentinelCpWeb.NotificationsLive.ChannelShow do
 
   defp edit_path(nil, project, channel),
     do: ~p"/projects/#{project.slug}/notifications/channels/#{channel.id}/edit"
+
+  defp attempt_path(%{slug: org_slug}, project, attempt),
+    do: ~p"/orgs/#{org_slug}/projects/#{project.slug}/notifications/delivery/#{attempt.id}"
+
+  defp attempt_path(nil, project, attempt),
+    do: ~p"/projects/#{project.slug}/notifications/delivery/#{attempt.id}"
 end

lib/sentinel_cp_web/live/notifications_live/delivery.ex

@@ -130,7 +130,12 @@ defmodule SentinelCpWeb.NotificationsLive.Delivery do
           <tbody>
             <tr :for={a <- @attempts}>
               <td>
-                <span class="font-mono text-sm">{(a.event && a.event.type) || "—"}</span>
+                <.link
+                  navigate={attempt_path(@org, @project, a)}
+                  class="font-mono text-sm link"
+                >
+                  {(a.event && a.event.type) || "—"}
+                </.link>
               </td>
               <td>
                 <span class="text-sm">{(a.channel && a.channel.name) || "—"}</span>
@@ -253,4 +258,10 @@ defmodule SentinelCpWeb.NotificationsLive.Delivery do
 
   defp delivery_path(nil, project),
     do: ~p"/projects/#{project.slug}/notifications/delivery"
+
+  defp attempt_path(%{slug: org_slug}, project, attempt),
+    do: ~p"/orgs/#{org_slug}/projects/#{project.slug}/notifications/delivery/#{attempt.id}"
+
+  defp attempt_path(nil, project, attempt),
+    do: ~p"/projects/#{project.slug}/notifications/delivery/#{attempt.id}"
 end