Event log: show only the events with a failed or a pending delivery (closes #390)

The event log gains three links above the list: All, Failed (N) and Pending (N), carried in a `show` query parameter (`failed`, `pending`); any other value shows every event. Failed lists the events with at least one failed delivery, Pending those with one pending or retrying, under the same 50-row limit and newest-first order as the full list. Events are picked by their deliveries' status through `idx_deliveries_status`; each count is the number of distinct matching events, read from the deliveries alone, and can exceed the 50 shown. An empty filtered list says that no event matches. The README and the comments that name the query parameters the service reads now include `show`.

Model: opus-5-5

internal/handlers/source_management.go

@@ -1094,6 +1094,15 @@ func (h *Handlers) ownedWebhook(
 	return webhook, true
 }
 
+// The event log's show query parameter and its two values: the events
+// with a failed delivery, and those with a delivery still pending or
+// retrying.
+const (
+	showParam   = "show"
+	showFailed  = "failed"
+	showPending = "pending"
+)
+
 // HandleSourceLogs shows the request/response logs for a
 // webhook.
 func (h *Handlers) HandleSourceLogs() http.HandlerFunc {
@@ -1113,17 +1122,36 @@ func (h *Handlers) HandleSourceLogs() http.HandlerFunc {
 			return
 		}
 
+		// Any other value of show lists every event, as no value
+		// does.
+		show := r.URL.Query().Get(showParam)
+
+		statuses := eventLogStatuses(show)
+		if statuses == nil {
+			show = ""
+		}
+
 		evts, total, ok := h.loadEventsWithDeliveries(
-			w, r, webhook, targets,
+			w, r, webhook, targets, statuses,
 		)
 		if !ok {
 			return
 		}
 
+		failed, pending, err := h.countFailedAndPendingEvents(webhook.ID)
+		if err != nil {
+			h.serverError(w, r, "failed to count events", err)
+
+			return
+		}
+
 		data := map[string]any{
-			tmplKeyWebhook: &webhook,
-			"Events":       evts,
-			"TotalEvents":  total,
+			tmplKeyWebhook:  &webhook,
+			"Events":        evts,
+			"TotalEvents":   total,
+			"Show":          show,
+			"FailedEvents":  failed,
+			"PendingEvents": pending,
 		}
 
 		h.renderTemplate(w, r, "source_logs.html", data)
@@ -1185,9 +1213,10 @@ func (h *Handlers) loadTargetMap(
 
 // loadEventsWithDeliveries loads the recentEventLimit newest events
 // and their deliveries from the per-webhook database, and the total
-// number of events stored. Events come back as capped projections
-// rather than database.Event rows: see eventLogColumns for why the
-// cut happens in SQL.
+// number of events stored. Given delivery statuses, both cover only
+// the events with a delivery in one of them. Events come back as
+// capped projections rather than database.Event rows: see
+// eventLogColumns for why the cut happens in SQL.
 //
 // The bool reports whether the load succeeded. It is false
 // once this has answered the request with an error, and the
@@ -1197,6 +1226,7 @@ func (h *Handlers) loadEventsWithDeliveries(
 	r *http.Request,
 	webhook database.Webhook,
 	targetMap map[string]eventLogTarget,
+	statuses []database.DeliveryStatus,
 ) ([]EventLogView, int64, bool) {
 	if !h.dbMgr.DBExists(webhook.ID) {
 		return nil, 0, true
@@ -1211,7 +1241,14 @@ func (h *Handlers) loadEventsWithDeliveries(
 		return nil, 0, false
 	}
 
-	rows, totalEvents := loadEventLogRows(webhookDB, webhook.ID)
+	rows, totalEvents, err := loadEventLogRows(
+		webhookDB, webhook.ID, statuses,
+	)
+	if err != nil {
+		h.serverError(w, r, "failed to load events", err)
+
+		return nil, 0, false
+	}
 
 	result, ok := h.eventLogViews(
 		w, r, webhookDB, webhook.ID, rows, targetMap,
@@ -1286,25 +1323,127 @@ func (h *Handlers) eventLogViews(
 
 // loadEventLogRows reads the event log projection of the
 // recentEventLimit newest events, newest first, and the total number
-// of events stored.
+// of events stored, both narrowed by statuses as eventsWithStatus
+// narrows them.
 func loadEventLogRows(
-	webhookDB *gorm.DB, webhookID string,
-) ([]eventLogRow, int64) {
-	var totalEvents int64
-
-	webhookDB.Model(&database.Event{}).Where(
-		"webhook_id = ?", webhookID,
-	).Count(&totalEvents)
+	webhookDB *gorm.DB,
+	webhookID string,
+	statuses []database.DeliveryStatus,
+) ([]eventLogRow, int64, error) {
+	totalEvents, err := countEventsWithStatus(
+		webhookDB, webhookID, statuses,
+	)
+	if err != nil {
+		return nil, 0, err
+	}
 
 	var rows []eventLogRow
 
-	webhookDB.Model(&database.Event{}).Select(
+	err = eventsWithStatus(webhookDB, webhookID, statuses).Select(
 		eventLogColumns, maxRenderedBodyBytes,
-	).Where(
-		"webhook_id = ?", webhookID,
-	).Order("created_at DESC").Limit(recentEventLimit).Find(&rows)
+	).Order("created_at DESC").Limit(recentEventLimit).Find(&rows).Error
 
-	return rows, totalEvents
+	return rows, totalEvents, err
+}
+
+// eventLogStatuses returns the delivery statuses the event log's show
+// value lists events by, or nil for one that lists every event.
+func eventLogStatuses(show string) []database.DeliveryStatus {
+	switch show {
+	case showFailed:
+		return []database.DeliveryStatus{database.DeliveryStatusFailed}
+	case showPending:
+		return []database.DeliveryStatus{
+			database.DeliveryStatusPending,
+			database.DeliveryStatusRetrying,
+		}
+	default:
+		return nil
+	}
+}
+
+// eventsWithStatus selects the webhook's events that have at least one
+// delivery in one of the statuses, or every event when statuses is nil.
+// The deliveries are found by status through idx_deliveries_status, so
+// no event body is read to decide.
+func eventsWithStatus(
+	webhookDB *gorm.DB,
+	webhookID string,
+	statuses []database.DeliveryStatus,
+) *gorm.DB {
+	events := webhookDB.Model(&database.Event{}).Where(
+		"webhook_id = ?", webhookID,
+	)
+
+	if statuses == nil {
+		return events
+	}
+
+	return events.Where(
+		"id IN (?)",
+		webhookDB.Model(&database.Delivery{}).Select("event_id").Where(
+			"status IN ?", statuses,
+		),
+	)
+}
+
+// countEventsWithStatus counts the events eventsWithStatus selects.
+// Given statuses, it counts the distinct events of the matching
+// deliveries and reads nothing but those deliveries, through
+// idx_deliveries_status, where counting the events would read every
+// event row. That is the same number, because retention deletes an
+// event's deliveries with it.
+func countEventsWithStatus(
+	webhookDB *gorm.DB,
+	webhookID string,
+	statuses []database.DeliveryStatus,
+) (int64, error) {
+	var count int64
+
+	if statuses == nil {
+		err := webhookDB.Model(&database.Event{}).Where(
+			"webhook_id = ?", webhookID,
+		).Count(&count).Error
+
+		return count, err
+	}
+
+	err := webhookDB.Model(&database.Delivery{}).Distinct("event_id").
+		Where("status IN ?", statuses).Count(&count).Error
+
+	return count, err
+}
+
+// countFailedAndPendingEvents returns how many of the webhook's events
+// the event log lists when it shows only those with a failed delivery,
+// and when it shows only those with a delivery pending or retrying.
+func (h *Handlers) countFailedAndPendingEvents(
+	webhookID string,
+) (int64, int64, error) {
+	if !h.dbMgr.DBExists(webhookID) {
+		return 0, 0, nil
+	}
+
+	webhookDB, err := h.dbMgr.GetDB(webhookID)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	failed, err := countEventsWithStatus(
+		webhookDB, webhookID, eventLogStatuses(showFailed),
+	)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	pending, err := countEventsWithStatus(
+		webhookDB, webhookID, eventLogStatuses(showPending),
+	)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	return failed, pending, nil
 }
 
 // resubmitCounts reports, for each of the page's events, how many