Show each entrypoint's last event and event count on the webhook page (closes #393)

Each entrypoint in the webhook page's entrypoint list shows when the last event arrived on its URL (relative, with the full UTC time on hover), or "never" if none ever has, and how many events arrived on it within the webhook's retention period. The last event is kept per entrypoint in a new EntrypointTotals row in the event database, written in the transaction that stores the event, so retention leaves it in place. The count is one query per page, grouped by entrypoint, over a new events index on entrypoint_id, deleted_at, resubmitted_from_id and created_at. Resubmitted copies did not arrive on the URL and count in neither. Pre-1.0: the table and index go into the schema in place.

Model: opus-5-5

internal/database/event_tier_indexes_test.go

@@ -233,6 +233,43 @@ func TestResubmitCountUsesItsIndex(t *testing.T) {
 			"(resubmitted_from_id=? AND deleted_at=?)")
 }
 
+// TestEntrypointEventsUseTheirIndex does the same for the webhook
+// page's count, for each entrypoint, of the events that arrived on its
+// URL since the retention cutoff (addEntrypointEvents in the
+// handlers), which must come from the index alone. It passes 25
+// entrypoints, as TestResubmitCountUsesItsIndex passes 25 events.
+func TestEntrypointEventsUseTheirIndex(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})
+
+	entrypoints := make([]string, 25)
+	for i := range entrypoints {
+		entrypoints[i] = uuid.New().String()
+	}
+
+	var rows []struct{ Events int }
+
+	assertPlanUses(t, db, dry.Model(&database.Event{}).
+		Select("entrypoint_id, count(*) AS events").
+		Where("entrypoint_id IN ? AND resubmitted_from_id IS NULL",
+			entrypoints).
+		Where("created_at >= ?", time.Now()).
+		Group("entrypoint_id").Find(&rows),
+		"COVERING INDEX idx_events_entrypoint_id "+
+			"(entrypoint_id=? AND deleted_at=? AND "+
+			"resubmitted_from_id=? AND created_at>?)")
+}
+
 // 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.

internal/database/model_event.go

@@ -20,12 +20,15 @@ type Event struct {
 	// has no deleted_at condition and uses the index on created_at
 	// alone. The other tables keep the unindexed BaseModel created_at.
 	// DeletedAt is also the second column of the resubmitted_from_id
-	// index, for the reason DeliveryResult gives.
-	CreatedAt time.Time      `gorm:"index;index:idx_events_deleted_at_created_at,priority:2"                                           json:"createdAt"`
-	DeletedAt gorm.DeletedAt `gorm:"index:idx_events_deleted_at_created_at,priority:1;index:idx_events_resubmitted_from_id,priority:2" json:"deletedAt,omitzero"`
+	// index, for the reason DeliveryResult gives. The entrypoint_id
+	// index, for the webhook page's entrypoint list, has it second too,
+	// resubmitted_from_id third, and created_at last, which the list
+	// compares with a range.
+	CreatedAt time.Time      `gorm:"index;index:idx_events_deleted_at_created_at,priority:2;index:idx_events_entrypoint_id,priority:4"                                           json:"createdAt"`
+	DeletedAt gorm.DeletedAt `gorm:"index:idx_events_deleted_at_created_at,priority:1;index:idx_events_resubmitted_from_id,priority:2;index:idx_events_entrypoint_id,priority:2" json:"deletedAt,omitzero"`
 
-	WebhookID    string `gorm:"type:uuid;not null" json:"webhookId"`
-	EntrypointID string `gorm:"type:uuid;not null" json:"entrypointId"`
+	WebhookID    string `gorm:"type:uuid;not null"                                           json:"webhookId"`
+	EntrypointID string `gorm:"type:uuid;not null;index:idx_events_entrypoint_id,priority:1" json:"entrypointId"`
 
 	// Request data
 	Method      string `gorm:"not null"    json:"method"`
@@ -44,7 +47,7 @@ type Event struct {
 	// existed. It is not a foreign key: the source event can be
 	// reaped by retention while its copies remain, and the id is
 	// kept as the record of where the copy came from either way.
-	ResubmittedFromID *string `gorm:"type:uuid;index:idx_events_resubmitted_from_id,priority:1" json:"resubmittedFromId,omitempty"`
+	ResubmittedFromID *string `gorm:"type:uuid;index:idx_events_resubmitted_from_id,priority:1;index:idx_events_entrypoint_id,priority:3" json:"resubmittedFromId,omitempty"`
 
 	// Relations. No model marshals the record it belongs to, so
 	// Webhook and Entrypoint are left out of the JSON.

internal/database/model_totals.go

@@ -52,6 +52,21 @@ func (TargetTotals) TableName() string {
 	return "target_totals"
 }
 
+// EntrypointTotals is one row per entrypoint, created by the first
+// event that arrives on its URL: when the newest such event arrived,
+// which retention leaves as it is. A resubmitted copy did not arrive
+// on the URL and does not change it.
+type EntrypointTotals struct {
+	EntrypointID string `gorm:"type:uuid;primaryKey"`
+
+	LastEventAt time.Time `gorm:"not null"`
+}
+
+// TableName names the table AddEntrypointTotals updates.
+func (EntrypointTotals) TableName() string {
+	return "entrypoint_totals"
+}
+
 // AddEventTotals adds each count in add to the webhook's event totals,
 // and records add.LastEventAt as when the newest event arrived if it is
 // set. Call it on the transaction that writes or deletes the events it
@@ -97,3 +112,25 @@ func AddTargetTotals(tx *gorm.DB, add TargetTotals) error {
 
 	return nil
 }
+
+// AddEntrypointTotals records add.LastEventAt as when the newest event
+// arrived on the URL of the entrypoint add.EntrypointID names, creating
+// its row the first time. Call it on the transaction that stores the
+// event.
+func AddEntrypointTotals(tx *gorm.DB, add EntrypointTotals) error {
+	err := tx.Exec(
+		`INSERT INTO entrypoint_totals (entrypoint_id, last_event_at)
+		VALUES (?, ?)
+		ON CONFLICT (entrypoint_id) DO UPDATE SET
+			last_event_at = excluded.last_event_at`,
+		add.EntrypointID, add.LastEventAt,
+	).Error
+	if err != nil {
+		return fmt.Errorf(
+			"adding to totals of entrypoint %s: %w",
+			add.EntrypointID, err,
+		)
+	}
+
+	return nil
+}

internal/database/model_webhook.go

@@ -111,6 +111,13 @@ func (w *Webhook) RetainsForever() bool {
 	return retainsForever(w.RetentionDays)
 }
 
+// RetentionCutoff returns the time before which this webhook's events
+// have expired, as the reaper computes it, and false when the webhook
+// retains them forever.
+func (w *Webhook) RetentionCutoff(now time.Time) (time.Time, bool) {
+	return retentionCutoff(now, w.RetentionDays)
+}
+
 // RetentionLabel returns the webhook's retention policy as display
 // text, so that no template has to know about the sentinel value.
 func (w *Webhook) RetentionLabel() string {

internal/database/models.go

@@ -3,7 +3,7 @@ package database
 // Migrate runs database migrations for the main application database.
 // Only configuration-tier models are stored in the main database.
 // Event-tier models (Event, Delivery, DeliveryResult, EventTotals,
-// TargetTotals) live in
+// TargetTotals, EntrypointTotals) live in
 // per-webhook dedicated databases managed by WebhookDBManager.
 func (d *Database) Migrate() error {
 	return d.db.AutoMigrate(

internal/database/webhook_db_manager.go

@@ -49,7 +49,7 @@ var ErrSidecarNotRemoved = errors.New(
 // WebhookDBManager manages per-webhook SQLite database files
 // for event storage. Each webhook gets its own dedicated
 // database containing Events, Deliveries, DeliveryResults and the
-// running totals of them (EventTotals, TargetTotals).
+// running totals of them (EventTotals, TargetTotals, EntrypointTotals).
 // Database connections are opened lazily and cached.
 type WebhookDBManager struct {
 	dataDir string
@@ -381,7 +381,7 @@ func (m *WebhookDBManager) openDB(
 	// Run migrations for event-tier models only
 	err = db.AutoMigrate(
 		&Event{}, &Delivery{}, &DeliveryResult{},
-		&EventTotals{}, &TargetTotals{},
+		&EventTotals{}, &TargetTotals{}, &EntrypointTotals{},
 	)
 	if err != nil {
 		_ = sqlDB.Close()