Add a statistics pane to the webhook page (closes #368)

Each webhook's event database keeps one row of running totals: events,
deliveries and failures, and how many of each retention removed.
Storing an event, creating a delivery, a delivery becoming failed and
the retention sweep each update it in the transaction that writes or
deletes the rows it counts. Deliveries get a finished_at column, the
last column of the status index, so the last-10-minutes and
last-24-hours figures are index-range counts. The pane is its own
template, included at the top of the page.

The schema changes in place with nothing back-filled, so an existing
database must be recreated.

Model: opus-5-5

internal/database/event_tier_indexes_test.go

@@ -93,6 +93,7 @@ func TestEventTierQueriesUseTheirIndexes(t *testing.T) {
 		deliveries []database.Delivery
 		results    []database.DeliveryResult
 		depths     []struct{ Depth int }
+		failed     struct{ Count int64 }
 	)
 
 	byStatus := "idx_deliveries_status (status=? AND deleted_at=?)"
@@ -123,7 +124,7 @@ func TestEventTierQueriesUseTheirIndexes(t *testing.T) {
 		Order("attempt_num ASC").Find(&results),
 		"idx_delivery_results_delivery_id (delivery_id=? AND deleted_at=?)")
 
-	// Retention's three deletes (reapExpired), whose subqueries are built
+	// Retention's deletes (deleteExpired), whose subqueries are built
 	// afresh for each statement as it builds them.
 	expiredEventIDs := func() *gorm.DB {
 		return dry.Model(&database.Event{}).Select("id").
@@ -135,6 +136,12 @@ func TestEventTierQueriesUseTheirIndexes(t *testing.T) {
 			Select("id").Where("event_id IN (?)", expiredEventIDs()),
 	).Delete(&database.DeliveryResult{}),
 		"idx_delivery_results_delivery_id (delivery_id=?)", byEvent, byAge)
+	assertPlanUses(t, db, dry.Unscoped().Model(&database.Delivery{}).
+		Select("count(CASE WHEN status = ? THEN 1 END) AS count",
+			database.DeliveryStatusFailed).
+		Where("event_id IN (?)", expiredEventIDs()).
+		Take(&failed),
+		"idx_deliveries_event_id (event_id=?)", byAge)
 	assertPlanUses(t, db, dry.Unscoped().Where(
 		"event_id IN (?)", expiredEventIDs(),
 	).Delete(&database.Delivery{}),
@@ -144,6 +151,54 @@ func TestEventTierQueriesUseTheirIndexes(t *testing.T) {
 	).Delete(&database.Event{}), "idx_events_created_at (created_at<?)")
 }
 
+// TestStatisticsQueriesUseTheirIndexes does the same for the webhook
+// page's statistics (readEventStats in the handlers): deliveries in
+// progress, deliveries finished and events received since a time, and
+// the newest event, which must come straight off an index rather than
+// from sorting every event.
+func TestStatisticsQueriesUseTheirIndexes(t *testing.T) {
+	t.Parallel()
+
+	mgr, lc := setupTestWebhookDBManager(t)
+	ctx := context.Background()
+	require.NoError(t, lc.Start(ctx))
+
+	defer func() { require.NoError(t, lc.Stop(ctx)) }()
+
+	db, err := mgr.GetDB(uuid.New().String())
+	require.NoError(t, err)
+
+	dry := db.Session(&gorm.Session{DryRun: true})
+	since := time.Now()
+
+	var (
+		count  int64
+		newest []time.Time
+	)
+
+	assertPlanUses(t, db, dry.Model(&database.Delivery{}).
+		Where("status IN ?", []database.DeliveryStatus{
+			database.DeliveryStatusPending,
+			database.DeliveryStatusRetrying,
+		}).Count(&count),
+		"idx_deliveries_status (status=? AND deleted_at=?)")
+	assertPlanUses(t, db, dry.Model(&database.Delivery{}).
+		Where("status = ? AND finished_at >= ?",
+			database.DeliveryStatusFailed, since).Count(&count),
+		"idx_deliveries_status "+
+			"(status=? AND deleted_at=? AND finished_at>?)")
+	assertPlanUses(t, db, dry.Model(&database.Event{}).
+		Where("created_at >= ?", since).Count(&count),
+		"idx_events_deleted_at_created_at "+
+			"(deleted_at=? AND created_at>?)")
+
+	newestEvent := dry.Model(&database.Event{}).
+		Order("created_at DESC").Limit(1).Pluck("created_at", &newest)
+	assertPlanUses(t, db, newestEvent,
+		"idx_events_deleted_at_created_at (deleted_at=?)")
+	assert.NotContains(t, queryPlan(t, db, newestEvent), "TEMP B-TREE")
+}
+
 // assertPlanUses asserts that SQLite's plan for a statement GORM built
 // in a dry run, run with the same SQL and arguments GORM would send,
 // names each of the given indexes.
@@ -152,6 +207,18 @@ func assertPlanUses(
 ) {
 	t.Helper()
 
+	plan := queryPlan(t, db, built)
+
+	for _, index := range indexes {
+		assert.Contains(t, plan, index, built.Statement.SQL.String())
+	}
+}
+
+// queryPlan returns SQLite's plan for a statement GORM built in a dry
+// run, run with the same SQL and arguments GORM would send.
+func queryPlan(t *testing.T, db, built *gorm.DB) string {
+	t.Helper()
+
 	var plan []struct{ Detail string }
 
 	require.NoError(t, db.Raw(
@@ -159,8 +226,5 @@ func assertPlanUses(
 		built.Statement.Vars...,
 	).Scan(&plan).Error)
 
-	for _, index := range indexes {
-		assert.Contains(t, fmt.Sprint(plan), index,
-			built.Statement.SQL.String())
-	}
+	return fmt.Sprint(plan)
 }