Show an event's entrypoint and request headers (closes #389)

An expanded event in the event log and the event's own page now show
the entrypoint the event arrived at (its description, "Entrypoint"
when it has none, or "deleted entrypoint"; never its URL), or for a
resubmitted copy the one the request it copies arrived at, and the
request headers as one block of text, one line per value, sorted by
name, whitespace kept. The event log leaves out headers that hold
more than the body's 32 KiB limit, stored or as text, and links to the
event's page, which shows them all. Both pages draw them through one
shared template, event_request.html, and read the webhook's
entrypoints once per page.

Model: opus-5-5

README.md

@@ -1986,7 +1986,7 @@ tags, so `AutoMigrate` creates them on a fresh database:
 
 | Table              | Columns                     | Serves |
 | ------------------ | --------------------------- | ------ |
-| `deliveries`       | `status`, `deleted_at`, `finished_at`, `target_id` | Startup recovery, the retry and pending sweeps every 60 seconds and the queue-depth sampler every 30 seconds, which select deliveries by status, the webhook page's statistics and target list and the webhook list, which count each target's deliveries by status and when they finished, and the event log, which lists and counts the events with a failed delivery or one pending or retrying |
+| `deliveries`       | `status`, `deleted_at`, `finished_at`, `target_id` | Startup recovery, the retry and pending sweeps every 60 seconds and the queue-depth sampler every 30 seconds, which select deliveries by status, and the webhook page's statistics and target list and the webhook list, which count each target's deliveries by status and when they finished |
 | `deliveries`       | `event_id`, `deleted_at`    | The event log, which loads each event's deliveries, and retention, which counts and deletes the deliveries of expired events |
 | `delivery_results` | `delivery_id`, `deleted_at` | The event log, which loads the attempts of a page's deliveries, and retention, which deletes the attempts of expired events |
 | `events`           | `deleted_at`, `created_at`  | The webhook page's statistics, which count recent events |
@@ -2589,9 +2589,8 @@ The query string is never logged; it is replaced by the fixed marker
 limiter in front of them, so a query on a fixed 200 URL would otherwise
 buy the same amplification as an invented path. Nothing debuggable is
 lost: the only query parameters this service reads are the login page's
-`next`, the page to return to, `notice`, which names the line a page
-shows after an action, and the event log's `show`, which picks the events
-it lists.
+`next`, the page to return to, and `notice`, which names the line a page
+shows after an action.
 
 Client-supplied request content does not leave the host by the other
 route either. The Sentry SDK attaches the request to every event it
@@ -3104,8 +3103,8 @@ returns to the page that was asked for.
 | `GET`  | `/hook/{id}/edit`        | Edit webhook form |
 | `POST` | `/hook/{id}/edit`        | Edit webhook submission |
 | `POST` | `/hook/{id}/delete`      | Delete webhook |
-| `GET`  | `/hook/{id}/events`      | Full Event Log. `?show=failed` lists only the events with a failed delivery, and `?show=pending` only those with a delivery pending or retrying |
-| `GET`  | `/hook/{id}/events/{eventID}` | One event's own page: its details, its whole body and every delivery of it |
+| `GET`  | `/hook/{id}/events`      | Full Event Log |
+| `GET`  | `/hook/{id}/events/{eventID}` | One event's own page: its details, the entrypoint it arrived at (for a resubmitted copy, the one the request it copies arrived at), its request headers, its whole body and every delivery of it |
 | `GET`  | `/hook/{id}/events/{eventID}/body` | Download an event's stored body. The pages show a body as text, cut at 32 KiB in the recent events and the event log, and leave a binary one out, so this is the only route that serves the stored bytes; it is offered wherever a body is cut or binary |
 | `POST` | `/hook/{id}/deliveries/{deliveryID}/replay` | Replay a finished delivery: creates a new delivery for the same event against the target's current configuration (30 per minute per bucket, then `429`) |
 | `POST` | `/hook/{id}/events/{eventID}/resubmit` | Resubmit a stored event: creates a new event copying it and fans that out to every currently active target (30 per minute per bucket, then `429`) |

internal/database/event_tier_indexes_test.go

@@ -149,62 +149,6 @@ func TestEventTierQueriesUseTheirIndexes(t *testing.T) {
 		Delete(&database.Event{}), "sqlite_autoindex_events_1 (id=?)")
 }
 
-// TestEventLogFiltersUseTheStatusIndex does the same for the event log's
-// Failed and Pending lists, of the newest events with a delivery in
-// given statuses, and for their counts (eventsWithStatus and
-// countEventsWithStatus in the handlers). The lists must also reach
-// the events table only by ID: from the matching deliveries, then from
-// the newest of those events.
-func TestEventLogFiltersUseTheStatusIndex(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)) }()
-
-	webhookID := uuid.New().String()
-
-	db, err := mgr.GetDB(webhookID)
-	require.NoError(t, err)
-
-	dry := db.Session(&gorm.Session{DryRun: true})
-	byStatus := "idx_deliveries_status (status=? AND deleted_at=?)"
-	pending := []database.DeliveryStatus{
-		database.DeliveryStatusPending,
-		database.DeliveryStatusRetrying,
-	}
-
-	var (
-		rows  []struct{ ID string }
-		count int64
-	)
-
-	matching := dry.Model(&database.Delivery{}).
-		Distinct("event_id").Where("status IN ?", pending)
-	newest := dry.Table("(?) AS matching", matching).
-		Joins("CROSS JOIN events ON events.id = matching.event_id").
-		Where(
-			"events.webhook_id = ? AND events.deleted_at IS NULL",
-			webhookID,
-		).
-		Order("events.created_at DESC").Limit(50).
-		Select("events.id AS event_id")
-
-	// Each step of the plan is printed in braces, so these name the
-	// lookup that follows each scan.
-	byID := "{SEARCH events USING INDEX sqlite_autoindex_events_1 (id=?)}"
-
-	assertPlanUses(t, db, dry.Table("(?) AS newest", newest).
-		Joins("CROSS JOIN events ON events.id = newest.event_id").
-		Select("id").Order("created_at DESC").Limit(50).Find(&rows),
-		byStatus, "{SCAN matching} "+byID, "{SCAN newest} "+byID)
-	assertPlanUses(t, db, dry.Model(&database.Delivery{}).
-		Distinct("event_id").Where("status IN ?", pending).Count(&count),
-		byStatus)
-}
-
 // TestStatisticsQueriesUseTheirIndexes does the same for the webhook
 // page's statistics (readEventStats in the handlers): deliveries in
 // progress, each target's deliveries finished since a time, which must

internal/handlers/delivery_replay.go

@@ -329,25 +329,15 @@ func replayBody(body string) *string {
 }
 
 // redirectToEventLog redirects a replay or resubmit back to the event
-// log it was triggered from, carrying the outcome as its notice. A
-// Replay form carries the list it was pressed in as show, so a replay
-// returns to the Failed or Pending list; a Resubmit form carries none,
-// so a resubmit returns to the full log, where its new event is the
-// newest.
+// log it was triggered from, carrying the outcome as its notice.
 func redirectToEventLog(
 	w http.ResponseWriter,
 	r *http.Request,
 	webhook database.Webhook,
 	code noticeCode,
 ) {
-	location := withNotice("/hook/"+webhook.ID+"/events", code)
-
-	show := r.PostFormValue(showParam)
-	if eventLogStatuses(show) != nil {
-		location += "&" + showParam + "=" + show
-	}
-
-	http.Redirect( //nolint:gosec // show is checked by eventLogStatuses
-		w, r, location, http.StatusSeeOther,
+	http.Redirect(
+		w, r, withNotice("/hook/"+webhook.ID+"/events", code),
+		http.StatusSeeOther,
 	)
 }

internal/handlers/delivery_replay_test.go

@@ -1,7 +1,6 @@
 package handlers_test
 
 import (
-	"io"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -472,66 +471,6 @@ func TestHandleDeliveryReplay_RefusesWhileEarlierReplayInFlight(
 	)
 }
 
-// TestHandleDeliveryReplay_ReturnsToTheListItWasPressedIn proves a
-// Replay pressed in the Failed list carries that list in its form and
-// returns to it, and that a show value the event log does not know
-// returns to the full log.
-func TestHandleDeliveryReplay_ReturnsToTheListItWasPressedIn(
-	t *testing.T,
-) {
-	t.Parallel()
-
-	var (
-		h     *handlers.Handlers
-		sess  *session.Session
-		db    *database.Database
-		dbMgr *database.WebhookDBManager
-	)
-
-	app := newTestApp(t, &h, &sess, &db, &dbMgr)
-	app.RequireStart()
-
-	t.Cleanup(app.RequireStop)
-
-	wh := seedWebhook(t, db)
-	tgt := seedConfiguredTarget(
-		t, db, wh.ID, database.TargetTypeHTTP,
-		`{"url":"`+replayTargetURL+`"}`,
-	)
-
-	_, original := seedFailedDelivery(t, dbMgr, wh.ID, tgt.ID)
-
-	assert.Contains(t, renderSourceLogsPageWithQuery(
-		t, h, sess, wh.ID, "?show=failed",
-	), `name="show" value="failed"`)
-
-	// The second replay is refused, as the first is still queued.
-	for _, tc := range []struct{ show, location string }{
-		{"failed", "/hook/" + wh.ID +
-			"/events?notice=replay-queued&show=failed"},
-		{"made-up", "/hook/" + wh.ID + "/events?notice=replay-in-flight"},
-	} {
-		req := postRequest(
-			"/hook/"+wh.ID+"/deliveries/"+original.ID+"/replay",
-			authenticatedCookies(
-				t, sess, deleteTestUserID, deleteTestUsername,
-			),
-			map[string]string{
-				paramSourceID:   wh.ID,
-				paramDeliveryID: original.ID,
-			},
-		)
-		req.Body = io.NopCloser(strings.NewReader("show=" + tc.show))
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-
-		w := httptest.NewRecorder()
-		h.HandleDeliveryReplay().ServeHTTP(w, req)
-
-		require.Equal(t, http.StatusSeeOther, w.Code, tc.show)
-		assert.Equal(t, tc.location, w.Header().Get("Location"), tc.show)
-	}
-}
-
 // TestHandleSourceLogs_RendersReplayControlAndBanner proves the action
 // reaches the page it belongs on: a finished delivery renders a POST
 // form carrying a CSRF token, and the outcome code a refusal redirects

internal/handlers/event_detail.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"math"
 	"net/http"
 
 	"github.com/go-chi/chi"
@@ -59,8 +60,9 @@ func (h *Handlers) HandleEventDetail() http.HandlerFunc {
 			return
 		}
 
+		// The page shows every request header.
 		views, ok := h.eventLogViews(
-			w, r, webhookDB, webhook.ID, rows, targets,
+			w, r, webhookDB, webhook.ID, rows, targets, math.MaxInt,
 		)
 		if !ok {
 			return

internal/handlers/event_log_view.go

@@ -1,10 +1,15 @@
 package handlers
 
 import (
+	"encoding/json"
+	"net/http"
+	"slices"
+	"strings"
 	"time"
 	"unicode/utf8"
 
 	"github.com/dustin/go-humanize"
+	"sneak.berlin/go/webhooker/internal/database"
 )
 
 // eventLogColumns is the event log's projection. The casts to
@@ -12,16 +17,20 @@ import (
 // bytes rather than characters, so the cap bounds the page in
 // bytes whatever the payload's encoding. Cutting in SQLite
 // rather than in Go is the point of the projection — an
-// oversized body never becomes a Go string at all.
+// oversized body or set of request headers never becomes a Go
+// string at all.
 const eventLogColumns = "id, created_at, method, content_type, " +
-	"resubmitted_from_id, " +
+	"resubmitted_from_id, entrypoint_id, " +
+	"substr(cast(headers as blob), 1, ?) AS headers, " +
+	"length(cast(headers as blob)) AS headers_bytes, " +
 	"substr(cast(body as blob), 1, ?) AS body, " +
 	"length(cast(body as blob)) AS body_bytes"
 
 // eventColumns is eventLogColumns for the event's own page, which
-// shows the whole body.
+// shows the whole body and every request header.
 const eventColumns = "id, created_at, method, content_type, " +
-	"resubmitted_from_id, " +
+	"resubmitted_from_id, entrypoint_id, headers, " +
+	"length(cast(headers as blob)) AS headers_bytes, " +
 	"cast(body as blob) AS body, " +
 	"length(cast(body as blob)) AS body_bytes"
 
@@ -40,6 +49,22 @@ type EventLogView struct {
 
 	Body BodyView
 
+	// Entrypoint names the entrypoint the event arrived at. A
+	// resubmitted copy, even a copy of a copy, did not arrive; it
+	// names the one the request it copies arrived at. The name is
+	// the entrypoint's description, "Entrypoint" when it has none,
+	// or "deleted entrypoint", never its URL, which is the
+	// entrypoint's secret.
+	Entrypoint string
+
+	// Headers is the event's request headers as text, one
+	// "Name: value" line per value, sorted by name. HeadersCut
+	// reports headers left out because they hold more than
+	// maxRenderedBodyBytes, stored or as text; only the event log
+	// leaves them out.
+	Headers    string
+	HeadersCut bool
+
 	// ResubmittedFromID names the event this one was copied
 	// from, empty for an event that arrived on the receiver.
 	ResubmittedFromID string
@@ -60,27 +85,35 @@ func (v EventLogView) ResubmittedFrom() bool {
 }
 
 // eventLogRow is one row of the event log projection, or of
-// eventColumns. In the event log its body column arrives
-// already cut to the cap by SQLite, with the true size beside
-// it.
+// eventColumns. In the event log its headers and body columns
+// arrive already cut to the cap by SQLite, each with its true
+// size beside it.
 type eventLogRow struct {
 	ID                string
 	CreatedAt         time.Time
 	Method            string
 	ContentType       string
 	ResubmittedFromID *string
+	EntrypointID      string
+	Headers           string
+	HeadersBytes      int64
 	Body              []byte
 	BodyBytes         int64
 }
 
 // view projects a loaded row of the webhook's events for
-// rendering.
-func (r *eventLogRow) view(webhookID string) EventLogView {
+// rendering. It shows the request headers when the row holds them
+// whole and their text holds at most maxHeaderBytes.
+func (r *eventLogRow) view(
+	webhookID string, maxHeaderBytes int,
+) EventLogView {
 	var from string
 	if r.ResubmittedFromID != nil {
 		from = *r.ResubmittedFromID
 	}
 
+	headers, fit := requestHeaderLines(r.Headers, maxHeaderBytes)
+
 	return EventLogView{
 		ID:          r.ID,
 		Method:      r.Method,
@@ -90,10 +123,83 @@ func (r *eventLogRow) view(webhookID string) EventLogView {
 		Body: newBodyView(
 			"/hook/"+webhookID+"/events/"+r.ID, r.Body, r.BodyBytes,
 		),
+		Headers:           strings.Join(headers, "\n"),
+		HeadersCut:        !fit || r.HeadersBytes > int64(len(r.Headers)),
 		ResubmittedFromID: from,
 	}
 }
 
+// requestHeaderLines turns an event's stored request headers, the
+// JSON the receiver writes, into one "Name: value" line per value,
+// sorted by name. Headers that do not parse, as when the event log
+// has cut them, show as none. It reports false, with no lines, when
+// the lines, each with the newline that follows it, would hold more
+// than maxBytes: a header sent many times is stored with its name
+// once but shown with it on every line.
+func requestHeaderLines(headersJSON string, maxBytes int) ([]string, bool) {
+	var headers http.Header
+
+	if json.Unmarshal([]byte(headersJSON), &headers) != nil {
+		return nil, true
+	}
+
+	names := make([]string, 0, len(headers))
+	for name := range headers {
+		names = append(names, name)
+	}
+
+	slices.Sort(names)
+
+	var lines []string
+
+	size := 0
+
+	for _, name := range names {
+		for _, value := range headers[name] {
+			line := name + ": " + value
+
+			size += len(line) + len("\n")
+			if size > maxBytes {
+				return nil, false
+			}
+
+			lines = append(lines, line)
+		}
+	}
+
+	return lines, true
+}
+
+// entrypointNames maps each of the webhook's entrypoints to the name
+// an event that arrived at it shows: its description, or "Entrypoint"
+// when it has none, as the webhook page names it. A deleted
+// entrypoint is left out.
+func (h *Handlers) entrypointNames(
+	webhookID string,
+) (map[string]string, error) {
+	var entrypoints []database.Entrypoint
+
+	err := h.db.DB().Where(
+		"webhook_id = ?", webhookID,
+	).Find(&entrypoints).Error
+	if err != nil {
+		return nil, err
+	}
+
+	names := make(map[string]string, len(entrypoints))
+
+	for i := range entrypoints {
+		name := entrypoints[i].Description
+		if name == "" {
+			name = "Entrypoint"
+		}
+
+		names[entrypoints[i].ID] = name
+	}
+
+	return names, nil
+}
+
 // trimPartialRune drops a trailing UTF-8 sequence that the
 // byte-wise cut left incomplete, so a multi-byte rune severed
 // at the cap does not surface as a mojibake tail.

internal/handlers/event_request_test.go

@@ -0,0 +1,332 @@
+package handlers_test
+
+import (
+	"encoding/json"
+	"net/http"
+	"slices"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gorm.io/gorm/clause"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// arrivedAt is how a page names the entrypoint an event arrived at.
+func arrivedAt(name string) string {
+	return `Arrived at <span class="text-gray-900">` + name + `</span>`
+}
+
+// copiedRequestArrivedAt is how a page names, for a resubmitted copy,
+// the entrypoint the request it copies arrived at.
+func copiedRequestArrivedAt(name string) string {
+	return `The request it copies arrived at <span class="text-gray-900">` +
+		name + `</span>`
+}
+
+// headerBox is how a page shows an event's request header lines: as
+// one block of text in a single box.
+func headerBox(lines ...string) string {
+	return `<pre class="rounded-md border border-gray-200 bg-white p-2 ` +
+		`text-xs text-gray-700 overflow-x-auto whitespace-pre-wrap ` +
+		`break-all">` + strings.Join(lines, "\n") + `</pre>`
+}
+
+// showHeadersLink is the event log's link to an event's own page for
+// request headers it leaves out.
+func showHeadersLink(webhookID, eventID string) string {
+	return `<a href="/hook/` + webhookID + `/events/` + eventID +
+		`" class="btn-small">Show the request headers</a>`
+}
+
+// entrypoint records one of the fixture webhook's entrypoints.
+func (f *recentEventsFixture) entrypoint(
+	t *testing.T, description string,
+) *database.Entrypoint {
+	t.Helper()
+
+	ep := &database.Entrypoint{
+		WebhookID:   f.webhook.ID,
+		Path:        uuid.NewString(),
+		Description: description,
+		Active:      true,
+	}
+
+	require.NoError(t, f.db.DB().Omit(clause.Associations).Create(ep).Error)
+
+	return ep
+}
+
+// eventAt records an event that arrived at the entrypoint with the
+// given request headers, stored as JSON as the receiver stores them.
+func (f *recentEventsFixture) eventAt(
+	t *testing.T,
+	ep *database.Entrypoint,
+	headersJSON string,
+	receivedAt time.Time,
+) *database.Event {
+	t.Helper()
+
+	event := &database.Event{
+		WebhookID:    f.webhook.ID,
+		EntrypointID: ep.ID,
+		Method:       http.MethodPost,
+		Headers:      headersJSON,
+		Body:         "{}",
+		BodyBytes:    2,
+		ContentType:  contentTypeJSON,
+	}
+	event.CreatedAt = receivedAt
+
+	require.NoError(t, f.webhookDB.Omit(
+		clause.Associations,
+	).Create(event).Error)
+
+	return event
+}
+
+// TestEventRequest_EachEventShowsItsOwnEntrypointAndHeaders proves two
+// events that arrived at two entrypoints each show their own
+// entrypoint and request headers, in the event log and on their own
+// pages, with the headers sorted by name, escaped and keeping their
+// whitespace, and never the entrypoint's URL.
+func TestEventRequest_EachEventShowsItsOwnEntrypointAndHeaders(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	f := newRecentEventsFixture(t)
+	billing := f.entrypoint(t, "Billing sender")
+	unnamed := f.entrypoint(t, "")
+
+	// Stored in reverse name order.
+	older := f.eventAt(t, billing,
+		`{"X-Shop-Event":["order.created"],`+
+			`"User-Agent":["shop/1  build\t7"],"Accept":["*/*"]}`,
+		time.Now().Add(-time.Minute))
+	newer := f.eventAt(t, unnamed,
+		`{"X-Shop-Event":["order.paid"],"X-Note":["<b>hi</b>"]}`,
+		time.Now())
+
+	olderShows := func(t *testing.T, page string) {
+		t.Helper()
+
+		assert.Contains(t, page, arrivedAt("Billing sender"))
+		assert.Contains(t, page, headerBox(
+			"Accept: */*",
+			"User-Agent: shop/1  build\t7",
+			"X-Shop-Event: order.created",
+		), "headers are sorted by name")
+		assert.NotContains(t, page, "order.paid")
+		assert.NotContains(t, page, billing.Path)
+	}
+
+	newerShows := func(t *testing.T, page string) {
+		t.Helper()
+
+		assert.Contains(t, page, arrivedAt("Entrypoint"))
+		assert.Contains(t, page, headerBox(
+			"X-Note: &lt;b&gt;hi&lt;/b&gt;",
+			"X-Shop-Event: order.paid",
+		))
+		assert.NotContains(t, page, "<b>hi</b>")
+		assert.NotContains(t, page, "order.created")
+		assert.NotContains(t, page, unnamed.Path)
+	}
+
+	// The log lists the newer event first, so everything between
+	// the two events' first mentions belongs to the newer one.
+	_, rest, found := strings.Cut(renderSourceLogsPage(
+		t, f.h, f.sess, f.webhook.ID,
+	), newer.ID)
+	require.True(t, found)
+
+	newerPart, olderPart, found := strings.Cut(rest, older.ID)
+	require.True(t, found)
+
+	newerShows(t, newerPart)
+	olderShows(t, olderPart)
+
+	w := serveEventPage(t, f.h, f.sess, f.webhook.ID, newer.ID)
+	require.Equal(t, http.StatusOK, w.Code)
+	newerShows(t, w.Body.String())
+
+	w = serveEventPage(t, f.h, f.sess, f.webhook.ID, older.ID)
+	require.Equal(t, http.StatusOK, w.Code)
+	olderShows(t, w.Body.String())
+}
+
+// TestEventRequest_DeletedEntrypoint proves an event whose entrypoint
+// has since been deleted says so in the event log and on its own page.
+func TestEventRequest_DeletedEntrypoint(t *testing.T) {
+	t.Parallel()
+
+	f := newRecentEventsFixture(t)
+	ep := f.entrypoint(t, "Retired sender")
+	event := f.eventAt(t, ep, `{}`, time.Now())
+
+	require.NoError(t, f.db.DB().Delete(ep).Error)
+
+	page := renderSourceLogsPage(t, f.h, f.sess, f.webhook.ID)
+	assert.Contains(t, page, arrivedAt("deleted entrypoint"))
+	assert.NotContains(t, page, "Retired sender")
+
+	w := serveEventPage(t, f.h, f.sess, f.webhook.ID, event.ID)
+	require.Equal(t, http.StatusOK, w.Code)
+	assert.Contains(t, w.Body.String(), arrivedAt("deleted entrypoint"))
+	assert.NotContains(t, w.Body.String(), "Retired sender")
+}
+
+// TestEventRequest_ResubmittedCopy proves a resubmitted copy and a copy
+// of that copy each say the request they copy arrived at the
+// entrypoint, in the event log and on their own pages, and never that
+// they did.
+func TestEventRequest_ResubmittedCopy(t *testing.T) {
+	t.Parallel()
+
+	f := newRecentEventsFixture(t)
+	ep := f.entrypoint(t, "Billing sender")
+	original := f.eventAt(t, ep, `{}`, time.Now().Add(-2*time.Minute))
+	copied := f.eventAt(t, ep, `{}`, time.Now().Add(-time.Minute))
+	copyOfCopy := f.eventAt(t, ep, `{}`, time.Now())
+
+	require.NoError(t, f.webhookDB.Model(copied).Update(
+		"resubmitted_from_id", original.ID,
+	).Error)
+	require.NoError(t, f.webhookDB.Model(copyOfCopy).Update(
+		"resubmitted_from_id", copied.ID,
+	).Error)
+
+	// The log lists the newest event first, and each event's Resubmit
+	// form comes before its entrypoint, so cutting the page at the
+	// copy's and the original's forms leaves each event's entrypoint
+	// in its own part.
+	copyOfCopyPart, rest, found := strings.Cut(
+		renderSourceLogsPage(t, f.h, f.sess, f.webhook.ID),
+		"/events/"+copied.ID+"/resubmit",
+	)
+	require.True(t, found)
+
+	copyPart, originalPart, found := strings.Cut(
+		rest, "/events/"+original.ID+"/resubmit",
+	)
+	require.True(t, found)
+
+	for _, part := range []string{copyOfCopyPart, copyPart} {
+		assert.Contains(t, part, copiedRequestArrivedAt("Billing sender"))
+		assert.NotContains(t, part, arrivedAt("Billing sender"))
+	}
+
+	assert.Contains(t, originalPart, arrivedAt("Billing sender"))
+	assert.NotContains(t, originalPart,
+		copiedRequestArrivedAt("Billing sender"))
+
+	for _, event := range []*database.Event{copied, copyOfCopy} {
+		w := serveEventPage(t, f.h, f.sess, f.webhook.ID, event.ID)
+		require.Equal(t, http.StatusOK, w.Code)
+		assert.Contains(t, w.Body.String(),
+			copiedRequestArrivedAt("Billing sender"))
+		assert.NotContains(t, w.Body.String(), arrivedAt("Billing sender"))
+	}
+}
+
+// TestEventRequest_HeadersOverTheLimit proves the event log leaves out
+// request headers that hold more than it shows of a body, whether
+// stored or as lines, and links to the event's own page, which shows
+// them all.
+func TestEventRequest_HeadersOverTheLimit(t *testing.T) {
+	t.Parallel()
+
+	// The receiver stores each "<" as six bytes of JSON, so this
+	// header is over the limit stored but not as a line.
+	const lessThans = bodyCap/6 + 1
+
+	// A header sent many times is stored with its name once, and
+	// shown with it on every line.
+	repeatedName := "X-Repeated-" + strings.Repeat("r", 1000)
+
+	tests := map[string]struct {
+		headers http.Header
+		line    string
+	}{
+		"stored": {
+			headers: http.Header{"X-Long": {strings.Repeat("<", lessThans)}},
+			line:    "X-Long: " + strings.Repeat("&lt;", lessThans),
+		},
+		"as lines": {
+			headers: http.Header{repeatedName: slices.Repeat([]string{""}, 41)},
+			line:    repeatedName + ": ",
+		},
+	}
+
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			headersJSON, err := json.Marshal(tc.headers)
+			require.NoError(t, err)
+
+			f := newRecentEventsFixture(t)
+			ep := f.entrypoint(t, "Billing sender")
+			event := f.eventAt(t, ep, string(headersJSON), time.Now())
+
+			page := renderSourceLogsPage(t, f.h, f.sess, f.webhook.ID)
+			assert.Contains(t, page, showHeadersLink(f.webhook.ID, event.ID))
+			assert.NotContains(t, page, tc.line)
+			assert.Less(t, len(page), 4*bodyCap)
+
+			w := serveEventPage(t, f.h, f.sess, f.webhook.ID, event.ID)
+			require.Equal(t, http.StatusOK, w.Code)
+			assert.Contains(t, w.Body.String(), tc.line)
+			assert.NotContains(t, w.Body.String(), "Show the request headers")
+		})
+	}
+}
+
+// TestEventRequest_ManyShortHeaderLines proves that for many short
+// request header lines the event log writes no more than its limit,
+// apart from escaping: lines that fill the limit show as one block of
+// text, and one line more is left out with a link to the event's own
+// page.
+func TestEventRequest_ManyShortHeaderLines(t *testing.T) {
+	t.Parallel()
+
+	// Each "A: " line and the newline after it hold four bytes, so
+	// this many lines fill the limit exactly. Each line in its own
+	// element would make the page many times the limit.
+	const fill = bodyCap / len("A: \n")
+
+	tests := map[string]struct {
+		lines int
+		shown bool
+	}{
+		"filling the limit":  {lines: fill, shown: true},
+		"one over the limit": {lines: fill + 1, shown: false},
+	}
+
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			headersJSON, err := json.Marshal(http.Header{
+				"A": slices.Repeat([]string{""}, tc.lines),
+			})
+			require.NoError(t, err)
+
+			f := newRecentEventsFixture(t)
+			ep := f.entrypoint(t, "Billing sender")
+			event := f.eventAt(t, ep, string(headersJSON), time.Now())
+
+			page := renderSourceLogsPage(t, f.h, f.sess, f.webhook.ID)
+			box := headerBox(slices.Repeat([]string{"A: "}, tc.lines)...)
+			link := showHeadersLink(f.webhook.ID, event.ID)
+
+			assert.Equal(t, tc.shown, strings.Contains(page, box))
+			assert.Equal(t, !tc.shown, strings.Contains(page, link))
+			assert.Less(t, len(page), 4*bodyCap)
+		})
+	}
+}

internal/handlers/export_test.go

@@ -75,7 +75,7 @@ func (s *Handlers) LoadEventLogViewsForTest(
 	webhook database.Webhook,
 ) []EventLogView {
 	views, _, _ := s.loadEventsWithDeliveries(
-		w, newRequestForTest(), webhook, nil, nil,
+		w, newRequestForTest(), webhook, nil,
 	)
 
 	return views

internal/handlers/handlers.go

@@ -167,12 +167,12 @@ func New(
 		),
 		"source_edit.html": parsePageTemplate("source_edit.html"),
 		"source_logs.html": parsePageTemplate(
-			"source_logs.html", "event_body.html", "delivery_row.html",
-			"delivery_attempts.html",
+			"source_logs.html", "event_request.html", "event_body.html",
+			"delivery_row.html", "delivery_attempts.html",
 		),
 		"event_detail.html": parsePageTemplate(
-			"event_detail.html", "event_body.html", "delivery_row.html",
-			"delivery_attempts.html",
+			"event_detail.html", "event_request.html", "event_body.html",
+			"delivery_row.html", "delivery_attempts.html",
 		),
 		"target_edit.html": parsePageTemplate("target_edit.html"),
 		"error.html":       parsePageTemplate("error.html"),

internal/handlers/source_logs_test.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"net/http"
 	"net/http/httptest"
-	"slices"
 	"strings"
 	"testing"
 	"time"
@@ -187,152 +186,6 @@ func TestHandleSourceLogs_ShowsFiftyNewestEvents(t *testing.T) {
 	assert.Contains(t, body, "50 most recent of 51 events")
 }
 
-// TestHandleSourceLogs_ShowsEventsByDeliveryStatus proves that the
-// Failed list holds exactly the events with a failed delivery, the
-// Pending list exactly those with a delivery pending or retrying, each
-// once, and any other show value every event; that each link, and the
-// line beside the heading, counts the events its list holds; and that
-// the shown link is marked.
-func TestHandleSourceLogs_ShowsEventsByDeliveryStatus(t *testing.T) {
-	t.Parallel()
-
-	f := newRecentEventsFixture(t)
-	target := seedTarget(t, f.db, f.webhook.ID, database.TargetTypeLog)
-	now := time.Now()
-
-	const (
-		failed    = database.DeliveryStatusFailed
-		delivered = database.DeliveryStatusDelivered
-		pending   = database.DeliveryStatusPending
-		retrying  = database.DeliveryStatusRetrying
-	)
-
-	// Each event is named by its content type. The first failed and
-	// was then replayed and delivered. The second failed, and so did
-	// its replay, and the fifth has one delivery pending and another
-	// retrying: each must still be listed and counted once.
-	events := []struct {
-		contentType string
-		deliveries  []database.DeliveryStatus
-	}{
-		{"application/x-failed", []database.DeliveryStatus{failed, delivered}},
-		{"application/x-failed-twice", []database.DeliveryStatus{failed, failed}},
-		{"application/x-pending", []database.DeliveryStatus{pending}},
-		{"application/x-retrying", []database.DeliveryStatus{retrying}},
-		{"application/x-pending-retrying", []database.DeliveryStatus{pending, retrying}},
-		{"application/x-delivered", []database.DeliveryStatus{delivered}},
-		{"application/x-no-delivery", nil},
-	}
-
-	all := make([]string, len(events))
-
-	for i, e := range events {
-		event := f.event(
-			t, e.contentType, "{}", now.Add(time.Duration(i)*time.Second),
-		)
-
-		for _, status := range e.deliveries {
-			f.delivery(t, event, target.ID, status)
-		}
-
-		all[i] = e.contentType
-	}
-
-	for _, tc := range []struct {
-		query   string
-		current string
-		heading string
-		listed  []string
-	}{
-		{"", "All", "7 total events", all},
-		{"?show=failed", "Failed (2)", "2 events with a failed delivery",
-			[]string{"application/x-failed", "application/x-failed-twice"}},
-		{"?show=pending", "Pending (3)",
-			"3 events with a delivery pending or retrying", []string{
-				"application/x-pending", "application/x-retrying",
-				"application/x-pending-retrying",
-			}},
-		{"?show=unknown", "All", "7 total events", all},
-	} {
-		body := renderSourceLogsPageWithQuery(
-			t, f.h, f.sess, f.webhook.ID, tc.query,
-		)
-
-		// One row per listed event, so with each listed event shown
-		// no event is listed twice.
-		assert.Equal(t, len(tc.listed),
-			strings.Count(body, `role="button"`), tc.query)
-
-		for _, contentType := range all {
-			assert.Equal(t,
-				slices.Contains(tc.listed, contentType),
-				strings.Contains(body, ">"+contentType+"<"),
-				tc.query+" "+contentType)
-		}
-
-		assert.Contains(t, body, ">"+tc.heading+"<", tc.query)
-		assert.Contains(t, body, "Failed (2)", tc.query)
-		assert.Contains(t, body, "Pending (3)", tc.query)
-		assert.Equal(t, 1, strings.Count(body, "aria-current"), tc.query)
-		assert.Contains(t, body,
-			`aria-current="page">`+tc.current+"</a>", tc.query)
-	}
-}
-
-// TestHandleSourceLogs_FilteredListShowsFiftyNewest proves a filtered
-// list holds the 50 newest matching events, as the full log does,
-// while its link and heading count every matching event.
-func TestHandleSourceLogs_FilteredListShowsFiftyNewest(t *testing.T) {
-	t.Parallel()
-
-	f := newRecentEventsFixture(t)
-	target := seedTarget(t, f.db, f.webhook.ID, database.TargetTypeLog)
-	base := time.Now().Add(-time.Hour)
-
-	for i := range 51 {
-		event := f.event(
-			t, fmt.Sprintf("application/x-failed-%02d", i), "{}",
-			base.Add(time.Duration(i)*time.Second),
-		)
-		f.delivery(t, event, target.ID, database.DeliveryStatusFailed)
-	}
-
-	// The newest event has no failed delivery.
-	f.event(t, "application/x-no-delivery", "{}", time.Now())
-
-	body := renderSourceLogsPageWithQuery(
-		t, f.h, f.sess, f.webhook.ID, "?show=failed",
-	)
-
-	assert.Equal(t, 50, strings.Count(body, `role="button"`))
-	assert.NotContains(t, body, "application/x-failed-00")
-	assert.NotContains(t, body, "application/x-no-delivery")
-	assert.Contains(t, body, "Failed (51)")
-	assert.Contains(t, body,
-		"50 most recent of 51 events with a failed delivery")
-}
-
-// TestHandleSourceLogs_EmptyFilteredList proves an empty filtered list
-// says that no event matches rather than that none was recorded.
-func TestHandleSourceLogs_EmptyFilteredList(t *testing.T) {
-	t.Parallel()
-
-	f := newRecentEventsFixture(t)
-	target := seedTarget(t, f.db, f.webhook.ID, database.TargetTypeLog)
-
-	f.delivery(
-		t, f.event(t, contentTypeJSON, "{}", time.Now()),
-		target.ID, database.DeliveryStatusDelivered,
-	)
-
-	assert.Contains(t, renderSourceLogsPageWithQuery(
-		t, f.h, f.sess, f.webhook.ID, "?show=failed",
-	), "No event has a failed delivery.")
-	assert.Contains(t, renderSourceLogsPageWithQuery(
-		t, f.h, f.sess, f.webhook.ID, "?show=pending",
-	), "No event has a delivery pending or retrying.")
-}
-
 // TestHandleSourceLogs_OnlyNewestStartsExpanded proves that of the
 // events in the log only the newest starts expanded.
 func TestHandleSourceLogs_OnlyNewestStartsExpanded(t *testing.T) {

internal/handlers/source_management.go

@@ -1110,15 +1110,6 @@ 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 {
@@ -1138,36 +1129,17 @@ 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, statuses,
+			w, r, webhook, targets,
 		)
 		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,
-			"Show":          show,
-			"FailedEvents":  failed,
-			"PendingEvents": pending,
+			tmplKeyWebhook: &webhook,
+			"Events":       evts,
+			"TotalEvents":  total,
 		}
 
 		h.renderTemplate(w, r, "source_logs.html", data)
@@ -1229,10 +1201,9 @@ 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. 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.
+// number of events stored. 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
@@ -1242,7 +1213,6 @@ 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
@@ -1257,24 +1227,21 @@ func (h *Handlers) loadEventsWithDeliveries(
 		return nil, 0, false
 	}
 
-	rows, totalEvents, err := loadEventLogRows(
-		webhookDB, webhook.ID, statuses,
-	)
-	if err != nil {
-		h.serverError(w, r, "failed to load events", err)
-
-		return nil, 0, false
-	}
+	rows, totalEvents := loadEventLogRows(webhookDB, webhook.ID)
 
 	result, ok := h.eventLogViews(
 		w, r, webhookDB, webhook.ID, rows, targetMap,
+		maxRenderedBodyBytes,
 	)
 
 	return result, totalEvents, ok
 }
 
 // eventLogViews projects loaded events for rendering, each with
-// its deliveries and how many times it has been resubmitted. Like
+// its deliveries, how many times it has been resubmitted and the
+// entrypoint it arrived at (for a resubmitted copy, the one the
+// request it copies arrived at), and with its request headers only
+// when their text holds at most maxHeaderBytes. Like
 // loadEventsWithDeliveries, it reports false once it has answered
 // the request with an error.
 func (h *Handlers) eventLogViews(
@@ -1284,6 +1251,7 @@ func (h *Handlers) eventLogViews(
 	webhookID string,
 	rows []eventLogRow,
 	targetMap map[string]eventLogTarget,
+	maxHeaderBytes int,
 ) ([]EventLogView, bool) {
 	result := make([]EventLogView, len(rows))
 	eventDeliveries := make([][]database.Delivery, len(rows))
@@ -1293,7 +1261,7 @@ func (h *Handlers) eventLogViews(
 	eventIDs := make([]string, len(rows))
 
 	for i := range rows {
-		result[i] = rows[i].view(webhookID)
+		result[i] = rows[i].view(webhookID, maxHeaderBytes)
 		eventIDs[i] = rows[i].ID
 
 		webhookDB.Where(
@@ -1327,11 +1295,25 @@ func (h *Handlers) eventLogViews(
 		return nil, false
 	}
 
+	entrypoints, err := h.entrypointNames(webhookID)
+	if err != nil {
+		h.serverError(w, r, "failed to load entrypoints", err)
+
+		return nil, false
+	}
+
 	for i := range rows {
 		result[i].Deliveries = h.newDeliveryViews(
 			eventDeliveries[i], targetMap, attempts,
 		)
 		result[i].ResubmitCount = resubmits[rows[i].ID]
+
+		name, ok := entrypoints[rows[i].EntrypointID]
+		if !ok {
+			name = "deleted entrypoint"
+		}
+
+		result[i].Entrypoint = name
 	}
 
 	return result, true
@@ -1339,142 +1321,25 @@ func (h *Handlers) eventLogViews(
 
 // loadEventLogRows reads the event log projection of the
 // recentEventLimit newest events, newest first, and the total number
-// of events stored, both narrowed by statuses as eventsWithStatus
-// narrows them.
+// of events stored.
 func loadEventLogRows(
-	webhookDB *gorm.DB,
-	webhookID string,
-	statuses []database.DeliveryStatus,
-) ([]eventLogRow, int64, error) {
-	totalEvents, err := countEventsWithStatus(
-		webhookDB, webhookID, statuses,
-	)
-	if err != nil {
-		return nil, 0, err
-	}
+	webhookDB *gorm.DB, webhookID string,
+) ([]eventLogRow, int64) {
+	var totalEvents int64
+
+	webhookDB.Model(&database.Event{}).Where(
+		"webhook_id = ?", webhookID,
+	).Count(&totalEvents)
 
 	var rows []eventLogRow
 
-	err = eventsWithStatus(webhookDB, webhookID, statuses).Select(
-		eventLogColumns, maxRenderedBodyBytes,
-	).Order("created_at DESC").Limit(recentEventLimit).Find(&rows).Error
+	webhookDB.Model(&database.Event{}).Select(
+		eventLogColumns, maxRenderedBodyBytes, maxRenderedBodyBytes,
+	).Where(
+		"webhook_id = ?", webhookID,
+	).Order("created_at DESC").Limit(recentEventLimit).Find(&rows)
 
-	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, or, given statuses,
-// the recentEventLimit newest of those with at least one delivery in
-// one of them.
-//
-// Given statuses, its cost follows the matching deliveries. SQLite
-// never reorders a CROSS JOIN, so it reads each join's left side
-// first: the distinct event IDs of the matching deliveries, through
-// idx_deliveries_status; then each of those events by ID, sorted to
-// keep the newest; then the rows of only the events kept, so no other
-// event's body is read. With a plain "id IN (matching deliveries)"
-// condition instead, SQLite, which keeps no statistics on these
-// tables, walks every event newest first.
-func eventsWithStatus(
-	webhookDB *gorm.DB,
-	webhookID string,
-	statuses []database.DeliveryStatus,
-) *gorm.DB {
-	if statuses == nil {
-		return webhookDB.Model(&database.Event{}).Where(
-			"webhook_id = ?", webhookID,
-		)
-	}
-
-	matching := webhookDB.Model(&database.Delivery{}).
-		Distinct("event_id").Where("status IN ?", statuses)
-
-	newest := webhookDB.Table("(?) AS matching", matching).
-		Joins("CROSS JOIN events ON events.id = matching.event_id").
-		Where(
-			"events.webhook_id = ? AND events.deleted_at IS NULL",
-			webhookID,
-		).
-		Order("events.created_at DESC").Limit(recentEventLimit).
-		Select("events.id AS event_id")
-
-	return webhookDB.Table("(?) AS newest", newest).
-		Joins("CROSS JOIN events ON events.id = newest.event_id")
-}
-
-// countEventsWithStatus counts the webhook's events with at least one
-// delivery in one of the statuses, or every event when statuses is
-// nil. 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
+	return rows, totalEvents
 }
 
 // resubmitCounts reports, for each of the page's events, how many

internal/handlers/target_paused_test.go

@@ -91,8 +91,7 @@ func TestPausedTarget_ShownUntilBreakerCloses(t *testing.T) {
 	assert.Contains(t, log, "t-http: delivered")
 	assert.Regexp(t, waiting+cooldownEnds, log)
 	assert.Contains(t, log, waiting+backoffEnds)
-	// No delivery shows as retrying; the Pending link's title says it.
-	assert.NotRegexp(t, `t-http: retrying|>retrying<`, log)
+	assert.NotContains(t, log, "retrying")
 
 	page := eventPage(t, h, sess, wh.ID, retrying.ID)
 	assert.Regexp(t, waiting+cooldownEnds, page)

internal/middleware/middleware.go

@@ -279,9 +279,8 @@ func (lrw *loggingResponseWriter) Unwrap() http.ResponseWriter {
 // this branch as bounded as the pattern branches below.
 //
 // Nothing debuggable is lost. The only query parameters the service
-// reads are the login page's `next`, the page to return to,
-// `notice`, which names the line a page shows after an action, and
-// the event log's `show`, which picks the events it lists. The
+// reads are the login page's `next`, the page to return to, and
+// `notice`, which names the line a page shows after an action. The
 // alternatives that would preserve more (a key count, a key
 // allowlist) all require parsing an attacker-sized query on every
 // request, which is work an unauthenticated client would then be

internal/server/alpine_browser_test.go

@@ -943,15 +943,15 @@ func checkEventSelection(
 }
 
 // checkEventKeyboard loads the event log and checks that Tab from the
-// page's Pending link, the last link above the list, reaches the row of
-// the newest event, the first after it, and that Enter then collapses
-// that event, which starts expanded, and Space expands it again.
+// page's Back link reaches the row of the newest event, the first after
+// it, and that Enter then collapses that event, which starts expanded,
+// and Space expands it again.
 func checkEventKeyboard(
 	ctx context.Context, t *testing.T, url, eventID string,
 ) {
 	t.Helper()
 
-	pending := `//a[starts-with(text(), "Pending")]`
+	back := `//a[contains(text(), "Back to")]`
 	expanded := `form[action$="/` + eventID + `/resubmit"]`
 
 	var focused string
@@ -959,12 +959,12 @@ func checkEventKeyboard(
 	require.NoError(t, chromedp.Run(
 		ctx,
 		loadPage(url),
-		chromedp.Focus(pending, chromedp.BySearch),
+		chromedp.Focus(back, chromedp.BySearch),
 		chromedp.KeyEvent(kb.Tab),
 		chromedp.Evaluate(`document.activeElement.textContent`, &focused),
 	))
 	require.Contains(t, focused, eventID,
-		"Tab from the Pending link does not reach the event's row")
+		"Tab from the Back link does not reach the event's row")
 
 	require.NoError(t, chromedp.Run(ctx, chromedp.KeyEvent(kb.Enter)))
 	assert.True(t, hidden(ctx, expanded), "Enter does not collapse the event")

internal/server/sentry.go

@@ -219,8 +219,8 @@ func keptSentryHeaders(headers map[string]string) map[string]string {
 // sentryKeepsHeader reports whether a request header is routing or
 // content metadata rather than client-chosen payload. Referer is kept
 // on the reasoning that it is browser-set, that the only query
-// parameters in this service's own URLs are the login page's `next`,
-// `notice` and the event log's `show`, and that Referrer-Policy is set to
+// parameters in this service's own URLs are the login page's `next`
+// and `notice`, and that Referrer-Policy is set to
 // strict-origin-when-cross-origin. X-Request-Id ties the event to the
 // local access log line, which holds the rest of the detail.
 func sentryKeepsHeader(name string) bool {

templates/event_detail.html

@@ -50,6 +50,15 @@
         </dl>
     </div>
 
+    <div class="card mt-6">
+        <div class="p-4 border-b border-gray-200">
+            <h2 class="text-lg font-medium text-gray-900">Request</h2>
+        </div>
+        <div class="p-4">
+            {{template "event_request" .}}
+        </div>
+    </div>
+
     <div class="card mt-6">
         <div class="p-4 border-b border-gray-200">
             <h2 class="text-lg font-medium text-gray-900">Body</h2>

templates/event_request.html

@@ -0,0 +1,22 @@
+{{define "event_request"}}
+<!-- The entrypoint an event arrived at and its request headers, as
+     handlers.EventLogView carries them: the same in the event log and
+     the event's own page. The entrypoint's URL is never shown. A
+     resubmitted copy, even a copy of a copy, did not arrive at an
+     entrypoint; the request it copies did. -->
+<div class="space-y-2 text-xs">
+    {{if .ResubmittedFrom}}
+    <p class="text-gray-500">The request it copies arrived at <span class="text-gray-900">{{.Entrypoint}}</span></p>
+    {{else}}
+    <p class="text-gray-500">Arrived at <span class="text-gray-900">{{.Entrypoint}}</span></p>
+    {{end}}
+    {{if .HeadersCut}}
+    <p class="text-gray-500">The request headers are larger than the event log shows. <a href="{{.Body.EventURL}}" class="btn-small">Show the request headers</a></p>
+    {{else if .Headers}}
+    <p class="text-gray-500">Request headers</p>
+    <pre class="rounded-md border border-gray-200 bg-white p-2 text-xs text-gray-700 overflow-x-auto whitespace-pre-wrap break-all">{{.Headers}}</pre>
+    {{else}}
+    <p class="text-gray-500">No request headers.</p>
+    {{end}}
+</div>
+{{end}}

templates/source_logs.html

@@ -8,14 +8,7 @@
         <a href="/hook/{{.Webhook.ID}}" class="btn-small">&larr; Back to {{.Webhook.Name}}</a>
         <div class="flex justify-between items-center mt-2">
             <h1 class="text-2xl font-medium text-gray-900">Full Event Log</h1>
-            <!-- Under a filter, this counts the events the filter lists. -->
-            <span class="text-sm text-gray-500">{{if gt .TotalEvents (len .Events)}}{{len .Events}} most recent of {{.TotalEvents}} events{{else}}{{.TotalEvents}}{{if not .Show}} total{{end}} event{{if ne .TotalEvents 1}}s{{end}}{{end}}{{if eq .Show "failed"}} with a failed delivery{{else if eq .Show "pending"}} with a delivery pending or retrying{{end}}</span>
-        </div>
-        <!-- Plain links, so they work without the page's script library. The current one is marked. -->
-        <div class="mt-3 flex flex-wrap gap-2">
-            <a href="/hook/{{.Webhook.ID}}/events" class="btn-small{{if eq .Show ""}} bg-primary-50 border-primary-500{{end}}"{{if eq .Show ""}} aria-current="page"{{end}}>All</a>
-            <a href="/hook/{{.Webhook.ID}}/events?show=failed" title="Events with at least one failed delivery" class="btn-small{{if eq .Show "failed"}} bg-primary-50 border-primary-500{{end}}"{{if eq .Show "failed"}} aria-current="page"{{end}}>Failed ({{.FailedEvents}})</a>
-            <a href="/hook/{{.Webhook.ID}}/events?show=pending" title="Events with a delivery still pending or retrying" class="btn-small{{if eq .Show "pending"}} bg-primary-50 border-primary-500{{end}}"{{if eq .Show "pending"}} aria-current="page"{{end}}>Pending ({{.PendingEvents}})</a>
+            <span class="text-sm text-gray-500">{{if gt .TotalEvents (len .Events)}}{{len .Events}} most recent of {{.TotalEvents}} events{{else}}{{.TotalEvents}} total event{{if ne .TotalEvents 1}}s{{end}}{{end}}</span>
         </div>
     </div>
 
@@ -62,6 +55,9 @@
                             <button type="submit" class="btn-small" title="Submit this event again as a new event, to every currently active target">Resubmit</button>
                         </form>
                     </div>
+                    <div class="mb-3">
+                        {{template "event_request" .}}
+                    </div>
                     {{template "event_body" .Body}}
 
                     {{if .Deliveries}}
@@ -80,8 +76,6 @@
                                     {{if and .Status.Terminal (not .Target.Deleted)}}
                                     <form method="POST" action="/hook/{{$.Webhook.ID}}/deliveries/{{.ID}}/replay" class="inline">
                                         <input type="hidden" name="csrf_token" value="{{$.CSRFToken}}">
-                                        <!-- The list to return to. -->
-                                        <input type="hidden" name="show" value="{{$.Show}}">
                                         <button type="submit" class="btn-small" title="Send this event to the target again">Replay</button>
                                     </form>
                                     {{end}}
@@ -98,7 +92,7 @@
                 </div>
             </div>
             {{else}}
-            <div class="p-12 text-center text-sm text-gray-500">{{if eq $.Show "failed"}}No event has a failed delivery.{{else if eq $.Show "pending"}}No event has a delivery pending or retrying.{{else}}No events recorded yet.{{end}}</div>
+            <div class="p-12 text-center text-sm text-gray-500">No events recorded yet.</div>
             {{end}}
         </div>
     </div>