Derive the image's version from the .git in the build context (closes #366)

upaas uploads its clone as a tar context, which .dockerignore does not
filter, so its builds already carried .git; the binary said "unknown"
because the VERSION build arg defaulted to "unknown". The old .git/
exclusion kept .git out of a directory-context build only. .dockerignore
now lets .git through without its config, which can carry a credential,
and leaves out no tracked file (an excluded one would read as deleted and
mark the version -dirty). The VERSION build arg loses its "unknown"
default, so script/version derives the version inside the build; a given
VERSION still takes precedence.

The builder stage installs git, trusts the copied checkout whoever owns
its files, and fails when its context carries .git and the version still
comes out "unknown". The CI fingerprint is now the commit being checked.

Model: opus-5-5

.dockerignore

@@ -1,16 +1,20 @@
+# .git is sent so the build can derive the version it stamps into the binary
+# (script/version). Its config, which can hold a remote URL carrying a
+# credential and which `git describe` does not need, is left out of a
+# directory context. A context sent as a tar is not filtered by this file, so
+# it carries .git/config unless its sender leaves it out.
+.git/config
+
+# No tracked file may be listed here: git in the build would see it as
+# deleted and mark the version -dirty.
+#
 # .ci-fingerprint is deliberately NOT excluded: it is the CI cache barrier
 # that keeps the check stages from replaying a cached pass. See the lint
 # stage of the Dockerfile.
-.git/
 bin/
-# Third-party browser assets are fetched and hash-verified inside the build by
-# script/fetch-assets. Excluding any host copy keeps a developer's working tree
-# from supplying the bytes that get shipped. The script and its
-# static/vendor.sha256 manifest stay in the context.
+# Extracted from 3p/ by `make assets` inside the build; a host copy is not
+# needed. The tarball in 3p/ must stay in the context.
 static/js/alpine.min.js
-*.md
-LICENSE
-.editorconfig
 .env
 .env.*
 *.db

.gitea/workflows/check.yml

@@ -12,9 +12,8 @@ jobs:
       - name: Checkout
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 2024-10-23
         with:
-          # The fingerprint step below needs history to find the last commit
-          # that touched the Docker build context, and the superseded-status
-          # step needs it to walk ancestors (it aborts on a shallow clone).
+          # The superseded-status step needs history to walk ancestors (it
+          # aborts on a shallow clone).
           fetch-depth: 0
 
       - name: Mark superseded run statuses
@@ -28,16 +27,11 @@ jobs:
         run: script/ci-mark-superseded
 
       - name: Fingerprint the build context
-        # `.dockerignore` keeps docs out of the build context, so a docs-only
-        # commit legitimately replays the whole image from cache and stays
-        # cheap. Every other commit writes a new fingerprint into the context,
-        # which invalidates the `COPY . .` layer of both check stages: a
-        # commit that was never linted, formatted-checked, tested and built
-        # cannot report success from cache.
-        run: |
-          set -eu
-          fp="$(git log -1 --format=%H -- . ':!*.md' ':!LICENSE' ':!.editorconfig')"
-          printf '%s\n' "${fp:-$GITHUB_SHA}" > .ci-fingerprint
+        # Writes the hash of the commit being checked into the context, which
+        # invalidates the `COPY . .` layer of both check stages: a commit
+        # that was never linted, format-checked, tested and built cannot
+        # report success from cache.
+        run: git rev-parse HEAD > .ci-fingerprint
 
       - name: Build Docker image (runs make check)
         run: script/cibuild

.gitignore

@@ -46,7 +46,6 @@ temp/
 # CI cache barrier, written into the build context by the check workflow
 .ci-fingerprint
 
-# Third-party browser assets, fetched and hash-verified by
-# script/fetch-assets against static/vendor.sha256. Not committed:
-# REPO_POLICIES.md forbids minified bundles in version control.
-/static/js/alpine.min.js 
+# Alpine.js, extracted by `make assets` from its tarball in 3p/, which is
+# what is committed.
+/static/js/alpine.min.js

Dockerfile

@@ -12,8 +12,8 @@ WORKDIR /src
 COPY go.mod go.sum ./
 RUN go mod download
 
-# Copy source code. In CI the context also carries .ci-fingerprint, whose
-# value changes with every commit that touches the build context (see
+# Copy source code. In CI the context also carries .ci-fingerprint, which
+# holds the hash of the commit being checked (see
 # .gitea/workflows/check.yml). That invalidates this layer, so the checks
 # below cannot report success by replaying a cached pass. Do not add it to
 # .dockerignore.
@@ -38,8 +38,13 @@ FROM golang:1.26.1-bookworm@sha256:4465644228bc2857a954b092167e12aa59c006a349228
 COPY --from=lint /src/go.sum /dev/null
 
 # jq is a runtime dependency of script/ci-mark-superseded, which the test
-# suite executes.
-RUN apt-get update && apt-get install -y --no-install-recommends make curl ca-certificates jq && rm -rf /var/lib/apt/lists/*
+# suite executes. git is what script/version derives the version with.
+RUN apt-get update && apt-get install -y --no-install-recommends make curl ca-certificates jq git && rm -rf /var/lib/apt/lists/*
+
+# A build context sent as a tar archive keeps its files' owners, and git
+# refuses to read a checkout owned by another user. Trust this one
+# whoever owns it.
+RUN git config --system --add safe.directory /build
 
 WORKDIR /build
 
@@ -51,25 +56,26 @@ RUN go mod download
 # the lint stage above.
 COPY . .
 
-# Fetch the third-party browser assets the UI serves. They are not committed
-# (REPO_POLICIES.md forbids minified bundles in version control) and
-# .dockerignore keeps any host copy out of the build context, so this step is
-# the only way they enter the image. Each download is checked against a
-# hardcoded sha256 and the build fails on mismatch; make test re-checks the
-# hashes against the bytes go:embed actually put in the binary.
-RUN script/fetch-assets
-
-# Run tests and build
+# Run tests and build. Both first run script/assets, which extracts Alpine.js
+# from its tarball in 3p/.
 RUN make test
 
-# Version stamped into the binary. .dockerignore excludes .git/, so
-# nothing in this stage can derive it: script/docker resolves it on the
-# host and passes it in. The default is what a bare `docker build .`
-# with no --build-arg gets, and it names no tag the tree may not be at.
+# Version stamped into the binary: the VERSION build arg when one is
+# given, otherwise what script/version derives from the .git the build
+# context carries, so any `docker build .` of a clone stamps its commit.
+# With neither, as from a source tarball, it is "unknown".
 #
-# Declared here, below the test and asset steps, so a changed version
-# does not invalidate their cached layers.
-ARG VERSION=unknown
+# Declared here, below the test step, so a changed version does not
+# invalidate its cached layer.
+ARG VERSION
+
+# A context that carries .git must not stamp "unknown": that means git is
+# missing here or could not read the checkout, and the image could not be
+# traced back to its commit.
+RUN if [ -d .git ] && [ "$(make version VERSION="$VERSION")" = unknown ]; then \
+        echo "version is unknown although the build context carries .git" >&2; \
+        exit 1; \
+    fi
 
 RUN make build VERSION="$VERSION"
 
@@ -88,7 +94,9 @@ RUN CGO_ENABLED=1 make build VERSION="$VERSION" GO_LDFLAGS='-extldflags "-static
 # alpine:3.21, 2026-03-17
 FROM alpine:3.21@sha256:c3f8e73fdb79deaebaa2037150150191b9dcbfba68b4a46d70103204c53f4709
 
-RUN apk --no-cache add ca-certificates
+# su-exec 0.2-r3 (Alpine 3.21), 2026-09-29: the entrypoint runs the app
+# as webhooker with it.
+RUN apk --no-cache add ca-certificates su-exec=0.2-r3
 
 # Create non-root user
 RUN addgroup -g 1000 -S webhooker && \
@@ -99,13 +107,17 @@ WORKDIR /app
 # Copy binary from builder
 COPY --from=builder /build/bin/webhooker /app/webhooker
 
+# Not under /app, which belongs to webhooker: this script runs as root.
+COPY deploy/docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
+
 # Create data directory for all SQLite databases (main app DB +
 # per-webhook event DBs). DATA_DIR defaults to /var/lib/webhooker.
 RUN mkdir -p /var/lib/webhooker
 
 RUN chown -R webhooker:webhooker /app /var/lib/webhooker
 
-USER webhooker
+# No USER: the entrypoint starts as root to make the data directory
+# webhooker's, then runs the app as webhooker.
 
 EXPOSE 8080
 
@@ -124,4 +136,5 @@ ENV BIND_ADDRESS=0.0.0.0
 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
     CMD wget --no-verbose --tries=1 --spider http://localhost:8080/.well-known/healthcheck || exit 1
 
+ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
 CMD ["/app/webhooker"]

Makefile

@@ -4,12 +4,12 @@
 .DEFAULT_GOAL := check
 
 # Version stamped into the binary. Derived from git by script/version;
-# override it (`make build VERSION=v1.2.3`) where git metadata is
-# unavailable, which is how the Dockerfile passes its build arg in.
+# override it (`make build VERSION=v1.2.3`) to stamp a given value, which is
+# how the Dockerfile passes its build arg in.
 VERSION ?= $(shell script/version)
 
-# An empty override (`make build VERSION=`, or a `--build-arg VERSION=`
-# landing on the Dockerfile's `make build VERSION="$VERSION"`) means unset,
+# An empty override (`make build VERSION=`, or the Dockerfile's `make build
+# VERSION="$VERSION"` when no VERSION build arg was given) means unset,
 # exactly as it does in script/version -- stamping "" would leave the binary
 # reporting no version and the footer back on its "dev" fallback. `override`
 # is required: a plain assignment loses to the command-line definition it
@@ -28,7 +28,7 @@ setup:
 	@script/setup
 
 assets:
-	@script/fetch-assets
+	@script/assets
 
 test:
 	@script/test
@@ -45,13 +45,13 @@ fmt-check:
 check:
 	@script/check
 
-build:
+build: assets
 	go build -ldflags '$(strip -X main.version=$(VERSION) $(GO_LDFLAGS))' -o bin/webhooker ./cmd/webhooker
 
 run: build
 	./bin/webhooker
 
-dev:
+dev: assets
 	go run ./cmd/webhooker
 
 deps:

TODO.md

@@ -387,7 +387,7 @@ point of the branch.
 - 2026-03-05 security headers middleware, session regeneration on
   login, request body size limits (#41)
 - 2026-03-04 tests for delivery, middleware, and session packages
-  (#32); removed globals.Buildarch (#31)
+  (#32); removed the build-architecture global (#31)
 - 2026-03-04 1.0 MVP merge: Webhook/Entrypoint/Target rename, core
   delivery engine with bounded worker pool and circuit breaker,
   parallel fan-out, per-webhook event databases, management UI (#16)

deploy/docker-entrypoint.sh

@@ -0,0 +1,22 @@
+#!/bin/sh
+# deploy/docker-entrypoint.sh: the image's ENTRYPOINT. A bind-mounted
+# data directory keeps its owner from the host, often root, and the app
+# could not write to it. Started as root, this creates DATA_DIR if
+# needed, gives it and everything in it to webhooker, sets its mode, and
+# runs the command as webhooker, so the app never runs as root. Started
+# as another user, it only runs the command.
+set -eu
+
+main() {
+    if [ "$(id -u)" != 0 ]; then
+        exec "$@"
+    fi
+
+    dir="${DATA_DIR:-/var/lib/webhooker}"
+    mkdir -p "$dir"
+    find "$dir" ! -user webhooker -exec chown -h webhooker:webhooker {} +
+    chmod 750 "$dir"
+    exec su-exec webhooker "$@"
+}
+
+main "$@"

go.mod

@@ -4,6 +4,7 @@ go 1.26.1
 
 require (
 	github.com/99designs/basicauth-go v0.0.0-20230316000542-bf6f9cbbf0f8
+	github.com/dustin/go-humanize v1.0.1
 	github.com/getsentry/sentry-go v0.25.0
 	github.com/go-chi/chi v1.5.5
 	github.com/go-chi/cors v1.2.1
@@ -29,7 +30,6 @@ require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
-	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/gorilla/securecookie v1.1.2 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect

internal/config/config.go

@@ -75,6 +75,11 @@ const (
 	// internet-exposed endpoint.
 	defaultReceiverRateLimit = 120
 
+	// defaultTrustedProxies is TRUSTED_PROXIES when it is unset: the
+	// RFC 1918 private ranges, which a reverse proxy reaching the
+	// process over a Docker network or a private LAN connects from.
+	defaultTrustedProxies = "10.0.0.0/8,172.16.0.0/12,192.168.0.0/16"
+
 	// maxPort is the highest valid TCP port number. The lower
 	// bound (at least 1) is enforced by envPositiveInt.
 	maxPort = 65535
@@ -172,13 +177,14 @@ type Config struct {
 
 	// TrustedProxies is the set of networks whose members are
 	// allowed to speak for the client with X-Forwarded-For, the
-	// only forwarded header read. It is empty unless
-	// TRUSTED_PROXIES is set, and empty means no peer is
-	// trusted: forwarded headers are then ignored entirely and
-	// clients are identified by the connection's own address.
-	// Members can choose their own rate-limit key, so this must
-	// name proxy hosts only, never a block that also covers
-	// clients.
+	// only forwarded header read. Unless TRUSTED_PROXIES is set it
+	// is the RFC 1918 private ranges (defaultTrustedProxies); a set
+	// value replaces them. If any client can reach the process, or
+	// the proxy in front of it, from an RFC 1918 source address
+	// (directly, or through anything that can rewrite source
+	// addresses, such as NAT or a published container port), it
+	// must be set to the proxy's address alone, or every rate limit
+	// can be bypassed by those clients.
 	TrustedProxies []netip.Prefix
 
 	// AllowedEgressCIDRs is the set of networks a delivery target
@@ -460,14 +466,15 @@ func parseCIDR(entry string) (netip.Prefix, error) {
 
 // envPrefixList returns the value of the named environment variable
 // parsed as a comma-separated list of CIDR blocks (bare addresses
-// allowed). An unset, empty, or blank value yields an empty list. A
-// set value containing an unparseable entry is a hard error naming
-// the key and the bad entry, so startup fails loudly rather than
-// silently running with a list the operator did not intend.
-func envPrefixList(key string) ([]netip.Prefix, error) {
+// allowed). An unset, empty, or blank value is read as defaultValue
+// instead. A set value containing an unparseable entry is a hard
+// error naming the key and the bad entry, so startup fails loudly
+// rather than silently running with a list the operator did not
+// intend.
+func envPrefixList(key, defaultValue string) ([]netip.Prefix, error) {
 	v := strings.TrimSpace(os.Getenv(key))
 	if v == "" {
-		return nil, nil
+		v = defaultValue
 	}
 
 	var prefixes []netip.Prefix
@@ -681,12 +688,12 @@ func loadFromEnv() (*Config, error) {
 		return nil, err
 	}
 
-	trustedProxies, err := envPrefixList("TRUSTED_PROXIES")
+	trustedProxies, err := envPrefixList("TRUSTED_PROXIES", defaultTrustedProxies)
 	if err != nil {
 		return nil, err
 	}
 
-	allowedEgressCIDRs, err := envPrefixList("ALLOWED_EGRESS_CIDRS")
+	allowedEgressCIDRs, err := envPrefixList("ALLOWED_EGRESS_CIDRS", "")
 	if err != nil {
 		return nil, err
 	}
@@ -760,50 +767,6 @@ func (c *Config) warnEgressAllowlist(log *slog.Logger) {
 	)
 }
 
-// warnSharedRateLimitBucket logs a startup warning whenever
-// TRUSTED_PROXIES is empty, in any environment.
-//
-// With no trusted proxies every rate limiter keys on the connecting
-// peer's address. Whether that is harmless or dangerous depends on
-// what is in front of the process, which this code cannot observe:
-// with nothing in front, the peer is the client and the limits are
-// per-client as intended; behind a reverse proxy the peer is the proxy
-// for every request, so all clients share one bucket per limiter.
-//
-// The login endpoint no longer spends budget on arrival — it verifies
-// credentials first and charges only failures — so a shared bucket
-// cannot deny the operator a correct password. What it does collapse
-// is the failure counting: one client's wrong passwords throttle
-// everyone else's wrong passwords, and the receiver's limits become
-// service-wide ceilings.
-//
-// The warning is deliberately not gated on WEBHOOKER_ENVIRONMENT:
-// behind a proxy every client shares one bucket in dev and prod alike.
-//
-// The default of trusting nobody is deliberate — trusting forwarded
-// headers from arbitrary peers lets any client choose its own bucket —
-// so this warns rather than failing startup or changing the key.
-func (c *Config) warnSharedRateLimitBucket(log *slog.Logger) {
-	if len(c.TrustedProxies) > 0 {
-		return
-	}
-
-	log.Warn(
-		"TRUSTED_PROXIES is empty: every rate limit keys on the "+
-			"connecting peer's address. With nothing proxying to "+
-			"this process that is the client itself and the limits "+
-			"are per-client as intended. Behind a reverse proxy the "+
-			"peer is the proxy on every request, so all clients "+
-			"share one bucket per limit: the receiver limits become "+
-			"service-wide ceilings, and one client's failed logins "+
-			"throttle every other client's failed logins — a "+
-			"correct password still gets in. If anything proxies to "+
-			"this process, set TRUSTED_PROXIES to its address.",
-		"environment", c.Environment,
-		"trustedProxies", len(c.TrustedProxies),
-	)
-}
-
 // New creates a Config by reading environment variables.
 //
 //nolint:revive // lc parameter is required by fx even if unused.
@@ -849,7 +812,6 @@ func New(lc fx.Lifecycle, params ConfigParams) (*Config, error) {
 		"hasMetricsAuth", s.MetricsAuthEnabled(),
 	)
 
-	s.warnSharedRateLimitBucket(log)
 	s.warnEgressAllowlist(log)
 
 	return s, nil

internal/config/config_test.go

@@ -551,6 +551,11 @@ func testReceiverRateLimitSuccess(
 }
 
 func TestTrustedProxies(t *testing.T) {
+	// Unset, the RFC 1918 private ranges are trusted, so a reverse
+	// proxy on a Docker network or a private LAN is covered without
+	// configuration.
+	defaultProxies := []string{cidrPrivateV4, "172.16.0.0/12", "192.168.0.0/16"}
+
 	tests := []struct {
 		name        string
 		set         bool
@@ -559,18 +564,21 @@ func TestTrustedProxies(t *testing.T) {
 		expected    []string
 	}{
 		{
-			// The default must be "trust nobody": an empty list
-			// means forwarded headers are ignored, never that
-			// every peer may speak for the client.
 			name:     caseUnsetUsesDefault,
 			set:      false,
-			expected: []string{},
+			expected: defaultProxies,
 		},
 		{
-			name:     "blank value trusts nothing",
+			name:     "blank value uses default",
 			set:      true,
 			value:    "  ",
-			expected: []string{},
+			expected: defaultProxies,
+		},
+		{
+			name:     "set value replaces the default entirely",
+			set:      true,
+			value:    "203.0.113.7",
+			expected: []string{"203.0.113.7/32"},
 		},
 		{
 			name:  caseValidValueParsed,
@@ -845,101 +853,6 @@ func TestEgressAllowlistWarning(t *testing.T) {
 	}
 }
 
-// TestSharedRateLimitBucketWarning covers the startup warning that
-// tells an operator a deployment behind a reverse proxy shares one
-// rate-limit bucket between every client, which turns the receiver
-// limits into service-wide ceilings and collapses login failure
-// counting. It must fire whenever TRUSTED_PROXIES is empty, in any
-// environment, because behind a proxy every client shares one bucket
-// in dev and prod alike. It stays quiet once proxies are named.
-func TestSharedRateLimitBucketWarning(t *testing.T) {
-	tests := []struct {
-		name           string
-		environment    string
-		trustedProxies string
-		expectWarning  bool
-	}{
-		{
-			name:          "prod without trusted proxies warns",
-			environment:   config.EnvironmentProd,
-			expectWarning: true,
-		},
-		{
-			name:           "prod with trusted proxies is quiet",
-			environment:    config.EnvironmentProd,
-			trustedProxies: cidrPrivateV4,
-			expectWarning:  false,
-		},
-		{
-			name:          "dev without trusted proxies warns",
-			environment:   config.EnvironmentDev,
-			expectWarning: true,
-		},
-		{
-			name:           "dev with trusted proxies is quiet",
-			environment:    config.EnvironmentDev,
-			trustedProxies: cidrPrivateV4,
-			expectWarning:  false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Cannot use t.Parallel() here because t.Setenv
-			// is incompatible with parallel subtests.
-			t.Setenv("WEBHOOKER_ENVIRONMENT", tt.environment)
-
-			if tt.trustedProxies == "" {
-				require.NoError(
-					t, os.Unsetenv("TRUSTED_PROXIES"),
-				)
-			} else {
-				t.Setenv("TRUSTED_PROXIES", tt.trustedProxies)
-			}
-
-			var buf bytes.Buffer
-
-			log := slog.New(slog.NewJSONHandler(
-				&buf, &slog.HandlerOptions{
-					Level: slog.LevelDebug,
-				},
-			))
-
-			require.NoError(
-				t,
-				config.WarnSharedRateLimitBucketForTest(log),
-			)
-
-			if !tt.expectWarning {
-				assert.Empty(t, buf.String())
-
-				return
-			}
-
-			logged := buf.String()
-
-			assert.Contains(t, logged, `"level":"WARN"`)
-			assert.Contains(t, logged, "TRUSTED_PROXIES")
-			assert.Contains(t, logged, "share one bucket")
-			assert.Contains(
-				t, logged, "throttle every other client's failed logins",
-			)
-			// The warning must not claim a lockout the login
-			// endpoint no longer permits: credentials are verified
-			// before any budget is spent.
-			assert.Contains(
-				t, logged, "a correct password still gets in",
-			)
-			// The text must stay accurate for a developer with
-			// nothing in front of the process, where an empty
-			// list costs nothing.
-			assert.Contains(
-				t, logged, "nothing proxying to this process",
-			)
-		})
-	}
-}
-
 // metricsEnv describes what one subtest below puts in the
 // environment for a single METRICS_ variable. A variable that is
 // set to the empty string and one that is not set at all are

internal/config/export_test.go

@@ -6,21 +6,6 @@ import "log/slog"
 // the external config_test package so each helper can be covered by
 // its own table-driven test without weakening the package API.
 
-// WarnSharedRateLimitBucketForTest loads a Config from the current
-// environment and emits its startup warnings to log. The real logger
-// writes to stdout, so this lets the warning's firing condition be
-// asserted against a handler the test controls.
-func WarnSharedRateLimitBucketForTest(log *slog.Logger) error {
-	c, err := loadFromEnv()
-	if err != nil {
-		return err
-	}
-
-	c.warnSharedRateLimitBucket(log)
-
-	return nil
-}
-
 // WarnEgressAllowlistForTest loads a Config from the current
 // environment and emits its egress-allowlist startup warning to
 // log, so a test can assert both that the warning fires only when

internal/database/bootstrap_banner_test.go

@@ -3,6 +3,8 @@ package database_test
 import (
 	"bytes"
 	"context"
+	"log/slog"
+	"path/filepath"
 	"strings"
 	"testing"
 
@@ -83,3 +85,37 @@ func TestFirstBoot_PrintsTheAdminPasswordAsABanner(t *testing.T) {
 		t, ok, "the printed password must open the seeded account",
 	)
 }
+
+// TestNewDatabase_IsLoggedWithItsPath is the log half of
+// https://git.eeqj.de/sneak/webhooker/issues/359. A DATA_DIR that is
+// unexpectedly empty boots exactly like a first start, so the start
+// that creates the database must say so, and where. Opening that
+// database again must not.
+func TestNewDatabase_IsLoggedWithItsPath(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+
+	open := func() string {
+		var out bytes.Buffer
+
+		db, err := database.Open(dir, slog.New(slog.NewTextHandler(&out, nil)))
+		require.NoError(t, err)
+		require.NoError(t, db.Close())
+
+		return out.String()
+	}
+
+	const created = `level=WARN msg="created a new, empty database"`
+
+	first := open()
+	second := open()
+
+	assert.Contains(
+		t, first,
+		created+" path="+filepath.Join(dir, database.MainDBFileName),
+	)
+	assert.NotContains(
+		t, second, created, "an existing database is not new",
+	)
+}

internal/database/database.go

@@ -8,6 +8,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"io/fs"
 	"log/slog"
 	"os"
 	"path/filepath"
@@ -199,6 +200,12 @@ func (d *Database) connectTo(dataDir string) error {
 	// Construct the main application database path inside DATA_DIR.
 	dbPath := filepath.Join(dataDir, MainDBFileName)
 
+	// Checked before opening, which creates the file. A DATA_DIR that
+	// is unexpectedly empty -- its volume not mounted, say -- looks
+	// exactly like a first start, so a new database is a warning.
+	_, statErr := os.Stat(dbPath)
+	created := errors.Is(statErr, fs.ErrNotExist)
+
 	// Opened through OpenSQLite so this handle carries the same WAL
 	// journaling, busy timeout, immediate-transaction locking, and pool
 	// bounds as every other database file. See sqlite_open.go.
@@ -229,7 +236,12 @@ func (d *Database) connectTo(dataDir string) error {
 	}
 
 	d.db = db
-	d.log.Info("connected to database", "path", dbPath)
+
+	if created {
+		d.log.Warn("created a new, empty database", "path", dbPath)
+	} else {
+		d.log.Info("connected to database", "path", dbPath)
+	}
 
 	// Run migrations
 	return d.migrate()

internal/database/event_tier_indexes_test.go

@@ -93,11 +93,11 @@ func TestEventTierQueriesUseTheirIndexes(t *testing.T) {
 		deliveries []database.Delivery
 		results    []database.DeliveryResult
 		depths     []struct{ Depth int }
+		removed    []database.TargetTotals
 	)
 
 	byStatus := "idx_deliveries_status (status=? AND deleted_at=?)"
 	byEvent := "idx_deliveries_event_id (event_id=? AND deleted_at=?)"
-	byAge := "idx_events_deleted_at_created_at (deleted_at=? AND created_at<?)"
 
 	// The delivery engine: recovery and the retry sweep, the sweep for
 	// stranded pending deliveries, and the queue depth count.
@@ -123,25 +123,80 @@ 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
-	// afresh for each statement as it builds them.
-	expiredEventIDs := func() *gorm.DB {
-		return dry.Model(&database.Event{}).Select("id").
-			Where("created_at < ?", cutoff)
-	}
+	// Retention (reapExpired, deleteEvents): one batch of expired
+	// events, then their attempts, deliveries and the events.
+	var expired []string
 
+	assertPlanUses(t, db, dry.Unscoped().Model(&database.Event{}).
+		Where("created_at < ?", cutoff).
+		Limit(database.ExportReapBatchSize).Pluck("id", &expired),
+		"idx_events_created_at (created_at<?)")
 	assertPlanUses(t, db, dry.Unscoped().Where(
-		"delivery_id IN (?)", dry.Model(&database.Delivery{}).
-			Select("id").Where("event_id IN (?)", expiredEventIDs()),
+		"delivery_id IN (?)", dry.Unscoped().Model(&database.Delivery{}).
+			Select("id").Where("event_id IN ?", ids),
 	).Delete(&database.DeliveryResult{}),
-		"idx_delivery_results_delivery_id (delivery_id=?)", byEvent, byAge)
-	assertPlanUses(t, db, dry.Unscoped().Where(
-		"event_id IN (?)", expiredEventIDs(),
-	).Delete(&database.Delivery{}),
-		"idx_deliveries_event_id (event_id=?)", byAge)
-	assertPlanUses(t, db, dry.Unscoped().Where(
-		"created_at < ?", cutoff,
-	).Delete(&database.Event{}), "idx_events_created_at (created_at<?)")
+		"idx_delivery_results_delivery_id (delivery_id=?)",
+		"idx_deliveries_event_id (event_id=?)")
+	assertPlanUses(t, db, dry.Unscoped().Model(&database.Delivery{}).
+		Select("target_id, count(*) AS deliveries_removed, "+
+			"count(CASE WHEN status = ? THEN 1 END) AS failed_removed",
+			database.DeliveryStatusFailed).
+		Where("event_id IN ?", ids).Group("target_id").Find(&removed),
+		"idx_deliveries_event_id (event_id=?)")
+	assertPlanUses(t, db, dry.Unscoped().Where("event_id IN ?", ids).
+		Delete(&database.Delivery{}), "idx_deliveries_event_id (event_id=?)")
+	assertPlanUses(t, db, dry.Unscoped().Where("id IN ?", ids).
+		Delete(&database.Event{}), "sqlite_autoindex_events_1 (id=?)")
+}
+
+// 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
+// come from the index alone, and events received since a time.
+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
+		byTarget []struct{ TargetID string }
+	)
+
+	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{}).
+		Select("target_id, "+
+			"count(CASE WHEN status = ? THEN 1 END) AS delivered, "+
+			"count(CASE WHEN status = ? THEN 1 END) AS failed",
+			database.DeliveryStatusDelivered,
+			database.DeliveryStatusFailed).
+		Where("status IN ? AND finished_at >= ?",
+			[]database.DeliveryStatus{
+				database.DeliveryStatusDelivered,
+				database.DeliveryStatusFailed,
+			}, since).
+		Group("target_id").Find(&byTarget),
+		"COVERING INDEX 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>?)")
 }
 
 // assertPlanUses asserts that SQLite's plan for a statement GORM built

internal/database/export_test.go

@@ -5,6 +5,7 @@ import (
 	"io"
 	"log/slog"
 	"os"
+	"testing"
 	"time"
 
 	"go.uber.org/fx"
@@ -28,6 +29,10 @@ func NewTestRetentionReaper(
 	}
 }
 
+// ExportReapBatchSize exposes how many expired events one retention
+// transaction deletes.
+const ExportReapBatchSize = reapBatchSize
+
 // ExportSweep runs a single retention sweep synchronously for tests.
 func (r *RetentionReaper) ExportSweep(ctx context.Context) {
 	r.sweep(ctx)
@@ -79,3 +84,14 @@ func (d *Database) ExportSetBannerOut(w io.Writer) {
 func DummyPasswordHashForTest() string {
 	return dummyPasswordHash()
 }
+
+// HashAtShippedCostForTest makes HashPassword hash at the shipped
+// memory cost until t ends. t must not run in parallel with other
+// tests, which would hash at that cost alongside it.
+func HashAtShippedCostForTest(t *testing.T) {
+	t.Helper()
+
+	hashAtShippedCostInTest = true
+
+	t.Cleanup(func() { hashAtShippedCostInTest = false })
+}

internal/database/model_delivery.go

@@ -1,6 +1,10 @@
 package database
 
-import "gorm.io/gorm"
+import (
+	"time"
+
+	"gorm.io/gorm"
+)
 
 // DeliveryStatus represents the status of a delivery
 type DeliveryStatus string
@@ -37,7 +41,7 @@ type Delivery struct {
 	BaseModel
 
 	EventID  string         `gorm:"type:uuid;not null;index:idx_deliveries_event_id,priority:1"       json:"eventId"`
-	TargetID string         `gorm:"type:uuid;not null"                                                json:"targetId"`
+	TargetID string         `gorm:"type:uuid;not null;index:idx_deliveries_status,priority:4"         json:"targetId"`
 	Status   DeliveryStatus `gorm:"not null;default:'pending';index:idx_deliveries_status,priority:1" json:"status"`
 
 	// DeletedAt repeats the BaseModel field only to be the second column
@@ -45,6 +49,13 @@ type Delivery struct {
 	// gives.
 	DeletedAt gorm.DeletedAt `gorm:"index:idx_deliveries_event_id,priority:2;index:idx_deliveries_status,priority:2" json:"deletedAt,omitzero"`
 
+	// FinishedAt is when the delivery became delivered or failed, and
+	// nil while it is pending or retrying. It and then TargetID end the
+	// status index, so the webhook page counts each target's deliveries
+	// that finished in a recent window by reading just that window from
+	// the index.
+	FinishedAt *time.Time `gorm:"index:idx_deliveries_status,priority:3" json:"finishedAt,omitempty"`
+
 	// Relations
 	Event           Event            `json:"event,omitzero"`
 	Target          Target           `json:"target,omitzero"`

internal/database/model_event.go

@@ -31,6 +31,11 @@ type Event struct {
 	Body        string `gorm:"type:text"   json:"body"`
 	ContentType string `json:"contentType"`
 
+	// BodyBytes is the size of Body in bytes, recorded when the event
+	// is stored so the recent events list can show it without reading
+	// the body.
+	BodyBytes int64 `gorm:"not null" json:"bodyBytes"`
+
 	// ResubmittedFromID names the event this one was copied from by
 	// an operator resubmit. It is nil for an event that arrived on
 	// the receiver, which is every event created before the column

internal/database/model_totals.go

@@ -0,0 +1,99 @@
+package database
+
+import (
+	"fmt"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+// The running totals in a webhook's event database keep the webhook
+// page's lifetime figures right after retention has removed the rows
+// they count, and let the page show them without counting every row.
+// Each total changes in the transaction that writes or deletes the
+// rows it counts.
+
+// EventTotals is the single row counting a webhook's events: every
+// event ever stored, how many of them retention has deleted, and when
+// the newest arrived, which retention leaves as it is.
+type EventTotals struct {
+	ID int64 `gorm:"primaryKey"`
+
+	Events        int64 `gorm:"not null"`
+	EventsRemoved int64 `gorm:"not null"`
+
+	// LastEventAt is when the newest event arrived, or nil before the
+	// first.
+	LastEventAt *time.Time
+}
+
+// TableName names the table AddEventTotals updates.
+func (EventTotals) TableName() string {
+	return "event_totals"
+}
+
+// TargetTotals is one row per target counting its deliveries: every
+// delivery ever created, how many became delivered and how many
+// failed, and how many deliveries and failed deliveries retention has
+// deleted. The webhook's delivery figures are these rows summed.
+type TargetTotals struct {
+	TargetID string `gorm:"type:uuid;primaryKey"`
+
+	Deliveries int64 `gorm:"not null"`
+	Delivered  int64 `gorm:"not null"`
+	Failed     int64 `gorm:"not null"`
+
+	DeliveriesRemoved int64 `gorm:"not null"`
+	FailedRemoved     int64 `gorm:"not null"`
+}
+
+// TableName names the table AddTargetTotals updates.
+func (TargetTotals) TableName() string {
+	return "target_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
+// counts.
+func AddEventTotals(tx *gorm.DB, add EventTotals) error {
+	err := tx.Exec(
+		`UPDATE event_totals SET
+			events = events + ?,
+			events_removed = events_removed + ?,
+			last_event_at = coalesce(?, last_event_at)`,
+		add.Events, add.EventsRemoved, add.LastEventAt,
+	).Error
+	if err != nil {
+		return fmt.Errorf("adding to event totals: %w", err)
+	}
+
+	return nil
+}
+
+// AddTargetTotals adds each count in add to the totals of the target
+// add.TargetID names, creating its row the first time. Call it on the
+// transaction that writes or deletes the deliveries it counts.
+func AddTargetTotals(tx *gorm.DB, add TargetTotals) error {
+	err := tx.Exec(
+		`INSERT INTO target_totals (target_id, deliveries, delivered,
+			failed, deliveries_removed, failed_removed)
+		VALUES (?, ?, ?, ?, ?, ?)
+		ON CONFLICT (target_id) DO UPDATE SET
+			deliveries = deliveries + excluded.deliveries,
+			delivered = delivered + excluded.delivered,
+			failed = failed + excluded.failed,
+			deliveries_removed =
+				deliveries_removed + excluded.deliveries_removed,
+			failed_removed = failed_removed + excluded.failed_removed`,
+		add.TargetID, add.Deliveries, add.Delivered,
+		add.Failed, add.DeliveriesRemoved, add.FailedRemoved,
+	).Error
+	if err != nil {
+		return fmt.Errorf(
+			"adding to totals of target %s: %w", add.TargetID, err,
+		)
+	}
+
+	return nil
+}

internal/database/model_user.go

@@ -1,13 +1,58 @@
 package database
 
+import (
+	"errors"
+	"fmt"
+
+	"gorm.io/gorm"
+)
+
+// MaxUsernameBytes is the longest username, in bytes, that a user may
+// have. The same number appears in the check constraint on
+// User.Username, because a struct tag cannot reference a constant.
+//
+// A login stores the username in the session cookie, and both
+// securecookie and browsers refuse a cookie value past about 4096
+// bytes. That value is the session base64-encoded twice, so it holds
+// 4096 × 3/4 × 3/4 = 2304 bytes of session, and the signature,
+// timestamp and the session's other values take about 270 of those: a
+// username longer than about 2030 bytes can never log in. The limit is
+// about half that, so the session can carry more values later without
+// locking out an account whose username is already at the limit.
+const MaxUsernameBytes = 1024
+
+// ErrUsernameTooLong is returned when a user is saved with a username
+// longer than MaxUsernameBytes.
+var ErrUsernameTooLong = errors.New("username is too long")
+
 // User represents a user of the webhooker service
+//
+//nolint:lll // a struct tag cannot wrap
 type User struct {
 	BaseModel
 
-	Username string `gorm:"uniqueIndex;not null" json:"username"`
-	Password string `gorm:"not null"             json:"-"` // Argon2 hashed
+	Username string `gorm:"uniqueIndex;not null;check:length(CAST(username AS BLOB)) <= 1024" json:"username"`
+	Password string `gorm:"not null"                                                          json:"-"` // Argon2 hashed
 
 	// Relations
 	Webhooks []Webhook `json:"webhooks,omitempty"`
 	APIKeys  []APIKey  `json:"apiKeys,omitempty"`
 }
+
+// BeforeSave rejects a username longer than MaxUsernameBytes when a whole
+// User is created or saved, so those calls get ErrUsernameTooLong rather
+// than the database's constraint error. A column update such as
+// Update("username", ...) is caught only by the check constraint, as is
+// any path that writes the table without this model.
+func (u *User) BeforeSave(_ *gorm.DB) error {
+	if len(u.Username) > MaxUsernameBytes {
+		return fmt.Errorf(
+			"%w: %d bytes, limit is %d",
+			ErrUsernameTooLong,
+			len(u.Username),
+			MaxUsernameBytes,
+		)
+	}
+
+	return nil
+}

internal/database/model_user_test.go

@@ -0,0 +1,65 @@
+package database_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// usernameAtLimit is exactly MaxUsernameBytes long, built from a
+// two-byte character. A check that counted characters rather than bytes
+// would see half the length and let the one-byte-longer name through.
+func usernameAtLimit() string {
+	return strings.Repeat("é", database.MaxUsernameBytes/2)
+}
+
+func TestUserCreate_RejectsOverlongUsername(t *testing.T) {
+	t.Parallel()
+
+	db := startedTestDB(t)
+
+	err := db.Create(&database.User{
+		Username: usernameAtLimit() + "x",
+		Password: "hash",
+	}).Error
+
+	require.ErrorIs(t, err, database.ErrUsernameTooLong)
+}
+
+func TestUserCreate_AcceptsUsernameAtLimit(t *testing.T) {
+	t.Parallel()
+
+	db := startedTestDB(t)
+
+	require.NoError(t, db.Create(&database.User{
+		Username: usernameAtLimit(),
+		Password: "hash",
+	}).Error)
+}
+
+// TestUsersTable_EnforcesUsernameLimitWithoutTheModel inserts with raw
+// SQL, as a path that bypassed User.BeforeSave would, so only the
+// table's check constraint stands between it and an over-long
+// username. Accepting the name at the limit and refusing the next byte
+// also pins the constraint's number to MaxUsernameBytes.
+func TestUsersTable_EnforcesUsernameLimitWithoutTheModel(t *testing.T) {
+	t.Parallel()
+
+	db := startedTestDB(t)
+
+	insert := "INSERT INTO users (id, username, password) VALUES (?, ?, ?)"
+
+	require.NoError(t, db.Exec(
+		insert, uuid.New().String(), usernameAtLimit(), "hash",
+	).Error)
+
+	err := db.Exec(
+		insert, uuid.New().String(), usernameAtLimit()+"x", "hash",
+	).Error
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "CHECK constraint failed")
+}

internal/database/models.go

@@ -2,7 +2,8 @@ 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) live in
+// Event-tier models (Event, Delivery, DeliveryResult, EventTotals,
+// TargetTotals) live in
 // per-webhook dedicated databases managed by WebhookDBManager.
 func (d *Database) Migrate() error {
 	return d.db.AutoMigrate(

internal/database/password.go

@@ -9,6 +9,7 @@ import (
 	"math/big"
 	"strings"
 	"sync"
+	"testing"
 
 	"golang.org/x/crypto/argon2"
 )
@@ -63,10 +64,30 @@ func DefaultPasswordConfig() *PasswordConfig {
 	}
 }
 
-// HashPassword generates an Argon2id hash of the password
+// testArgon2Memory is the Argon2id memory cost, in KiB, that a test
+// binary hashes with: 1 MB instead of the shipped 64 MB. Every test
+// that starts a database hashes the bootstrap admin password, dozens
+// of them run in parallel, and under the race detector each 64 MB hash
+// holds about 150 MB. VerifyPassword reads the cost from the hash it
+// checks, so verification follows.
+const testArgon2Memory = 1024
+
+// hashAtShippedCostInTest makes a test binary hash at the shipped
+// memory cost. Only TestHashPassword_ShippedParameters sets it.
+//
+//nolint:gochecknoglobals // set by one test, see above
+var hashAtShippedCostInTest bool
+
+// HashPassword generates an Argon2id hash of the password. A binary
+// built by go test hashes at testArgon2Memory; one built by go build
+// always hashes at the defaults.
 func HashPassword(password string) (string, error) {
 	config := DefaultPasswordConfig()
 
+	if testing.Testing() && !hashAtShippedCostInTest {
+		config.Memory = testArgon2Memory
+	}
+
 	// Generate a salt
 	salt := make([]byte, config.SaltLen)
 

internal/database/password_test.go

@@ -192,6 +192,39 @@ func TestHashPasswordUniqueness(t *testing.T) {
 	}
 }
 
+// TestHashPassword_ShippedParameters hashes and verifies through
+// HashPassword at the shipped Argon2id parameters. Every other test
+// hashes at the lower memory cost a test binary uses, so this is the
+// one that keeps production hashing covered. One hash and one
+// verification: each costs 64 MB.
+//
+//nolint:paralleltest // changes the hashing cost for the whole binary
+func TestHashPassword_ShippedParameters(t *testing.T) {
+	database.HashAtShippedCostForTest(t)
+
+	password := "correct horse battery staple"
+
+	hash, err := database.HashPassword(password)
+	if err != nil {
+		t.Fatalf("hashing with the shipped parameters: %v", err)
+	}
+
+	const shipped = "$argon2id$v=19$m=65536,t=1,p=4$"
+
+	if !strings.HasPrefix(hash, shipped) {
+		t.Errorf("hash = %q, want prefix %q", hash, shipped)
+	}
+
+	valid, err := database.VerifyPassword(password, hash)
+	if err != nil {
+		t.Fatalf("VerifyPassword() error = %v", err)
+	}
+
+	if !valid {
+		t.Error("VerifyPassword() returned false for correct password")
+	}
+}
+
 // TestVerifyDummyPassword_DoesRealWork covers the anti-enumeration
 // path. Login charges an unknown username a verification against a
 // dummy hash so that a nonexistent account is not answered in

internal/database/retention.go

@@ -18,6 +18,19 @@ import (
 // computation.
 const hoursPerDay = 24
 
+// reapBatchSize is how many expired events one retention transaction
+// deletes. A transaction holds the event database's write lock, which
+// the receiver and the delivery workers wait for, so a large prune is
+// split into transactions each short enough to finish well inside the
+// busy timeout.
+const reapBatchSize = 1000
+
+// reapBatchPause is how long retention waits after one batch before
+// starting the next. A writer waiting for the write lock checks for it
+// again after at most 100 ms, so a longer pause lets it in between two
+// batches instead of only after the whole prune.
+const reapBatchPause = 200 * time.Millisecond
+
 // RetentionReaperParams holds the fx dependencies for the
 // RetentionReaper.
 type RetentionReaperParams struct {
@@ -187,13 +200,15 @@ func (r *RetentionReaper) sweep(ctx context.Context) {
 			continue
 		}
 
-		r.reapWebhook(wh.ID, wh.RetentionDays)
+		r.reapWebhook(ctx, wh.ID, wh.RetentionDays)
 	}
 }
 
 // reapWebhook removes every expired event (and its dependents) from a
-// single webhook's database.
+// single webhook's database, or as many as it reaches before ctx is
+// cancelled.
 func (r *RetentionReaper) reapWebhook(
+	ctx context.Context,
 	webhookID string,
 	retentionDays int,
 ) {
@@ -213,7 +228,7 @@ func (r *RetentionReaper) reapWebhook(
 		return
 	}
 
-	deleted, err := reapExpired(db, cutoff)
+	deleted, err := reapExpired(ctx, db, cutoff)
 	if err != nil {
 		r.log.Error(
 			"retention sweep: failed to reap expired events",
@@ -265,57 +280,107 @@ func retentionCutoff(
 	), true
 }
 
-// reapExpired hard-deletes, in foreign-key-safe order, the delivery
-// results, deliveries, and events associated with events older than
-// cutoff. Deletes are unscoped so rows are physically removed rather
-// than soft-deleted, reclaiming disk. It returns the number of events
-// deleted.
-func reapExpired(db *gorm.DB, cutoff time.Time) (int64, error) {
-	// Fresh subqueries are built per statement to avoid reusing a
-	// mutated builder across executions.
-	expiredEventIDs := func() *gorm.DB {
-		return db.Model(&Event{}).
-			Select("id").
-			Where("created_at < ?", cutoff)
-	}
-	expiredDeliveryIDs := func() *gorm.DB {
-		return db.Model(&Delivery{}).
-			Select("id").
-			Where("event_id IN (?)", expiredEventIDs())
-	}
+// reapExpired hard-deletes the events older than cutoff, with their
+// deliveries and delivery results, reapBatchSize events per
+// transaction with reapBatchPause between transactions, until none is
+// left. Once ctx is cancelled it returns after the batch in hand,
+// leaving the rest to the next sweep, so stopping the app does not
+// wait for a long prune. It returns the number of events deleted.
+func reapExpired(
+	ctx context.Context, db *gorm.DB, cutoff time.Time,
+) (int64, error) {
+	var total int64
 
-	// 1. Delivery results whose delivery belongs to an expired event.
-	res := db.Unscoped().
-		Where("delivery_id IN (?)", expiredDeliveryIDs()).
-		Delete(&DeliveryResult{})
-	if res.Error != nil {
-		return 0, fmt.Errorf(
-			"deleting expired delivery results: %w",
-			res.Error,
-		)
-	}
+	for {
+		var eventIDs []string
 
-	// 2. Deliveries belonging to an expired event.
-	del := db.Unscoped().
-		Where("event_id IN (?)", expiredEventIDs()).
-		Delete(&Delivery{})
-	if del.Error != nil {
-		return 0, fmt.Errorf(
-			"deleting expired deliveries: %w",
-			del.Error,
-		)
-	}
+		err := db.Transaction(func(tx *gorm.DB) error {
+			err := tx.Unscoped().Model(&Event{}).
+				Where("created_at < ?", cutoff).
+				Limit(reapBatchSize).
+				Pluck("id", &eventIDs).Error
+			if err != nil {
+				return fmt.Errorf("selecting expired events: %w", err)
+			}
 
-	// 3. The expired events themselves.
-	ev := db.Unscoped().
-		Where("created_at < ?", cutoff).
-		Delete(&Event{})
-	if ev.Error != nil {
-		return 0, fmt.Errorf(
-			"deleting expired events: %w",
-			ev.Error,
-		)
-	}
+			if len(eventIDs) == 0 {
+				return nil
+			}
 
-	return ev.RowsAffected, nil
+			return deleteEvents(tx, eventIDs)
+		})
+		if err != nil {
+			return total, err
+		}
+
+		total += int64(len(eventIDs))
+
+		if len(eventIDs) < reapBatchSize {
+			return total, nil
+		}
+
+		select {
+		case <-ctx.Done():
+			return total, nil
+		case <-time.After(reapBatchPause):
+		}
+	}
+}
+
+// deleteEvents hard-deletes the given events and, in foreign-key-safe
+// order before them, their delivery results and deliveries, then adds
+// what it deleted to the running totals. It runs on reapExpired's
+// transaction, so the totals change exactly when the rows do. Deletes
+// are unscoped so rows are physically removed rather than
+// soft-deleted, reclaiming disk.
+func deleteEvents(tx *gorm.DB, eventIDs []string) error {
+	// 1. The delivery results of the events' deliveries.
+	err := tx.Unscoped().
+		Where("delivery_id IN (?)", tx.Unscoped().Model(&Delivery{}).
+			Select("id").
+			Where("event_id IN ?", eventIDs)).
+		Delete(&DeliveryResult{}).Error
+	if err != nil {
+		return fmt.Errorf("deleting expired delivery results: %w", err)
+	}
+
+	// 2. The events' deliveries, after counting them, and the failed
+	// ones among them, per target. The status is tested in the select
+	// list rather than the WHERE clause: there, SQLite would read every
+	// failed delivery the webhook has through the status index,
+	// instead of only these through the event_id index.
+	var removed []TargetTotals
+
+	err = tx.Unscoped().Model(&Delivery{}).
+		Select("target_id, count(*) AS deliveries_removed, "+
+			"count(CASE WHEN status = ? THEN 1 END) AS failed_removed",
+			DeliveryStatusFailed).
+		Where("event_id IN ?", eventIDs).
+		Group("target_id").
+		Find(&removed).Error
+	if err != nil {
+		return fmt.Errorf("counting expired deliveries: %w", err)
+	}
+
+	err = tx.Unscoped().
+		Where("event_id IN ?", eventIDs).
+		Delete(&Delivery{}).Error
+	if err != nil {
+		return fmt.Errorf("deleting expired deliveries: %w", err)
+	}
+
+	// 3. The events themselves.
+	ev := tx.Unscoped().Where("id IN ?", eventIDs).Delete(&Event{})
+	if ev.Error != nil {
+		return fmt.Errorf("deleting expired events: %w", ev.Error)
+	}
+
+	for i := range removed {
+		err = AddTargetTotals(tx, removed[i])
+		if err != nil {
+			return err
+		}
+	}
+
+	return AddEventTotals(tx, EventTotals{EventsRemoved: ev.RowsAffected})
 }

internal/database/totals_test.go

@@ -0,0 +1,410 @@
+package database_test
+
+import (
+	"context"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// readEventTotals reads a webhook database's row of event totals,
+// asserting that it has exactly one.
+func readEventTotals(t *testing.T, db *gorm.DB) database.EventTotals {
+	t.Helper()
+
+	var rows []database.EventTotals
+
+	require.NoError(t, db.Find(&rows).Error)
+	require.Len(t, rows, 1)
+
+	return rows[0]
+}
+
+// readTargetTotals reads a webhook database's target totals, keyed by
+// target.
+func readTargetTotals(
+	t *testing.T, db *gorm.DB,
+) map[string]database.TargetTotals {
+	t.Helper()
+
+	var rows []database.TargetTotals
+
+	require.NoError(t, db.Find(&rows).Error)
+
+	byTarget := make(map[string]database.TargetTotals, len(rows))
+	for _, row := range rows {
+		byTarget[row.TargetID] = row
+	}
+
+	return byTarget
+}
+
+// TestWebhookDBManager_TotalsSurviveReopen verifies that a new event
+// database starts with one row of zero event totals and no target
+// totals, that adding to a target twice adds to the one row, and that
+// opening the database again keeps everything added.
+func TestWebhookDBManager_TotalsSurviveReopen(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)
+
+	fresh := readEventTotals(t, db)
+	assert.Equal(t, database.EventTotals{ID: fresh.ID}, fresh)
+	assert.Empty(t, readTargetTotals(t, db))
+
+	first, second := uuid.New().String(), uuid.New().String()
+
+	require.NoError(t, database.AddEventTotals(db, database.EventTotals{
+		Events: 2,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: first, Deliveries: 2, Delivered: 1,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: first, Failed: 1,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: second, Deliveries: 1,
+	}))
+
+	// Drop the cached connection so the next open reopens the file,
+	// as a restart would.
+	require.NoError(t, mgr.CloseAll())
+
+	db, err = mgr.GetDB(webhookID)
+	require.NoError(t, err)
+
+	assert.Equal(t, database.EventTotals{ID: fresh.ID, Events: 2},
+		readEventTotals(t, db))
+	assert.Equal(t, map[string]database.TargetTotals{
+		first: {
+			TargetID: first, Deliveries: 2, Delivered: 1, Failed: 1,
+		},
+		second: {TargetID: second, Deliveries: 1},
+	}, readTargetTotals(t, db))
+}
+
+// seedExpiredEvents stores count events created at the given time,
+// each with a delivered delivery to one target and a failed delivery
+// to the other, and one attempt for each delivery.
+func seedExpiredEvents(
+	t *testing.T,
+	db *gorm.DB,
+	webhookID string,
+	count int,
+	createdAt time.Time,
+	delivered, failed string,
+) {
+	t.Helper()
+
+	events := make([]database.Event, count)
+	deliveries := make([]database.Delivery, 0, 2*count)
+
+	for i := range events {
+		events[i] = database.Event{
+			WebhookID:    webhookID,
+			EntrypointID: uuid.New().String(),
+			Method:       http.MethodPost,
+		}
+		events[i].ID = uuid.New().String()
+		events[i].CreatedAt = createdAt
+
+		deliveries = append(deliveries,
+			database.Delivery{
+				EventID:  events[i].ID,
+				TargetID: delivered,
+				Status:   database.DeliveryStatusDelivered,
+			},
+			database.Delivery{
+				EventID:  events[i].ID,
+				TargetID: failed,
+				Status:   database.DeliveryStatusFailed,
+			},
+		)
+	}
+
+	require.NoError(t, db.CreateInBatches(events, 500).Error)
+	require.NoError(t, db.CreateInBatches(deliveries, 500).Error)
+
+	results := make([]database.DeliveryResult, len(deliveries))
+	for i := range deliveries {
+		results[i] = database.DeliveryResult{
+			DeliveryID: deliveries[i].ID, AttemptNum: 1,
+		}
+	}
+
+	require.NoError(t, db.CreateInBatches(results, 500).Error)
+}
+
+// seedBareEvents stores count events created at the given time, with
+// no deliveries.
+func seedBareEvents(
+	t *testing.T,
+	db *gorm.DB,
+	webhookID string,
+	count int,
+	createdAt time.Time,
+) {
+	t.Helper()
+
+	events := make([]database.Event, count)
+	for i := range events {
+		events[i] = database.Event{
+			WebhookID:    webhookID,
+			EntrypointID: uuid.New().String(),
+			Method:       http.MethodPost,
+		}
+		events[i].CreatedAt = createdAt
+	}
+
+	require.NoError(t, db.CreateInBatches(events, 500).Error)
+}
+
+// TestRetentionReaper_PrunesMoreThanOneBatch verifies that a prune
+// larger than one transaction's batch removes every expired event with
+// its deliveries and delivery results, keeps the recent event, and
+// adds what it removed to the event and target totals, so the totals
+// within retention match the rows still stored.
+func TestRetentionReaper_PrunesMoreThanOneBatch(t *testing.T) {
+	t.Parallel()
+
+	env := setupRetentionTest(t)
+
+	webhookID := createWebhook(t, env.mainDB.DB(), 30)
+
+	db, err := env.mgr.GetDB(webhookID)
+	require.NoError(t, err)
+
+	expired := database.ExportReapBatchSize + 1
+	delivered, failed := uuid.New().String(), uuid.New().String()
+	seedExpiredEvents(t, db, webhookID, expired,
+		time.Now().Add(-40*24*time.Hour), delivered, failed)
+
+	// One recent event, delivered to the first target.
+	recent := seedEventChain(t, db, webhookID, time.Now())
+	require.NoError(t, db.Model(&database.Delivery{}).
+		Where("id = ?", recent.deliveryID).
+		Update("target_id", delivered).Error)
+
+	// The totals storing those rows would have left.
+	n := int64(expired)
+	require.NoError(t, database.AddEventTotals(db, database.EventTotals{
+		Events: n + 1,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: delivered, Deliveries: n + 1, Delivered: n + 1,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: failed, Deliveries: n, Failed: n,
+	}))
+
+	env.reaper.ExportSweep(context.Background())
+
+	// Only the recent event's rows are left.
+	for _, model := range []any{
+		&database.Event{}, &database.Delivery{}, &database.DeliveryResult{},
+	} {
+		var count int64
+
+		require.NoError(t, db.Model(model).Count(&count).Error)
+		assert.Equal(t, int64(1), count, "%T rows left", model)
+	}
+
+	assertChainPresent(t, db, recent)
+
+	eventTotals := readEventTotals(t, db)
+	assert.Equal(t, database.EventTotals{
+		ID: eventTotals.ID, Events: n + 1, EventsRemoved: n,
+	}, eventTotals)
+
+	targetTotals := readTargetTotals(t, db)
+	assert.Equal(t, map[string]database.TargetTotals{
+		delivered: {
+			TargetID: delivered, Deliveries: n + 1, Delivered: n + 1,
+			DeliveriesRemoved: n,
+		},
+		failed: {
+			TargetID: failed, Deliveries: n, Failed: n,
+			DeliveriesRemoved: n, FailedRemoved: n,
+		},
+	}, targetTotals)
+
+	// A sweep with nothing left to remove changes nothing.
+	env.reaper.ExportSweep(context.Background())
+
+	assert.Equal(t, eventTotals, readEventTotals(t, db))
+	assert.Equal(t, targetTotals, readTargetTotals(t, db))
+}
+
+// TestRetentionReaper_WriteDuringPruneSucceeds verifies that a prune
+// of several batches lets other writers in between its batches: an
+// event stored once the first batch is deleted is stored while expired
+// events are still left, not only after the prune has finished.
+func TestRetentionReaper_WriteDuringPruneSucceeds(t *testing.T) {
+	t.Parallel()
+
+	env := setupRetentionTest(t)
+
+	webhookID := createWebhook(t, env.mainDB.DB(), 30)
+
+	db, err := env.mgr.GetDB(webhookID)
+	require.NoError(t, err)
+
+	// Three batches of expired events, with nothing else stored: only
+	// the number of batches matters here.
+	expired := 3 * database.ExportReapBatchSize
+	seedBareEvents(t, db, webhookID, expired,
+		time.Now().Add(-40*24*time.Hour))
+
+	cutoff := time.Now().Add(-30 * 24 * time.Hour)
+	countExpired := func() int64 {
+		var count int64
+
+		require.NoError(t, db.Model(&database.Event{}).
+			Where("created_at < ?", cutoff).
+			Count(&count).Error)
+
+		return count
+	}
+
+	pruned := make(chan struct{})
+
+	go func() {
+		defer close(pruned)
+
+		env.reaper.ExportSweep(context.Background())
+	}()
+
+	t.Cleanup(func() { <-pruned })
+
+	// Every stored event is expired until the write below.
+	require.Eventually(t, func() bool {
+		var count int64
+
+		err := db.Model(&database.Event{}).Count(&count).Error
+
+		return err == nil && count < int64(expired)
+	}, 10*time.Second, 10*time.Millisecond)
+
+	event := &database.Event{
+		WebhookID:    webhookID,
+		EntrypointID: uuid.New().String(),
+		Method:       http.MethodPost,
+	}
+	require.NoError(t, db.Create(event).Error)
+
+	assert.Positive(t, countExpired(),
+		"the event was stored only after the whole prune")
+
+	<-pruned
+
+	assert.Zero(t, countExpired())
+
+	var stored database.Event
+
+	require.NoError(t, db.First(&stored, "id = ?", event.ID).Error)
+}
+
+// TestRetentionReaper_StopDuringPruneLeavesTheRest verifies that
+// stopping the reaper during a prune of several batches returns
+// between two batches, well inside the stop timeout, leaving the
+// remaining expired events for the next sweep, and that the totals
+// match the rows left.
+func TestRetentionReaper_StopDuringPruneLeavesTheRest(t *testing.T) {
+	t.Parallel()
+
+	env := setupRetentionTest(t)
+
+	webhookID := createWebhook(t, env.mainDB.DB(), 30)
+
+	db, err := env.mgr.GetDB(webhookID)
+	require.NoError(t, err)
+
+	// Two batches and one more of expired events, a few of them with a
+	// delivered and a failed delivery for the target totals to count.
+	// Most carry nothing else, to keep the test quick.
+	const withDeliveries = 10
+
+	expiredAt := time.Now().Add(-40 * 24 * time.Hour)
+	delivered, failed := uuid.New().String(), uuid.New().String()
+	seedExpiredEvents(t, db, webhookID, withDeliveries, expiredAt,
+		delivered, failed)
+	seedBareEvents(t, db, webhookID,
+		2*database.ExportReapBatchSize+1-withDeliveries, expiredAt)
+
+	n := int64(2*database.ExportReapBatchSize + 1)
+	require.NoError(t, database.AddEventTotals(db, database.EventTotals{
+		Events: n,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: delivered, Deliveries: withDeliveries,
+		Delivered: withDeliveries,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: failed, Deliveries: withDeliveries,
+		Failed: withDeliveries,
+	}))
+
+	env.reaper.ExportSetInterval(time.Millisecond)
+	env.reaper.ExportStart()
+
+	// Stop once the first batch is deleted. The stop lands in the pause
+	// after it, or at worst during the second batch, so at least the
+	// last event is left.
+	require.Eventually(t, func() bool {
+		var count int64
+
+		err := db.Model(&database.Event{}).Count(&count).Error
+
+		return err == nil && count < n
+	}, 10*time.Second, 10*time.Millisecond)
+
+	// The app's stop timeout.
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	require.NoError(t, env.reaper.ExportStop(ctx))
+
+	var events int64
+
+	require.NoError(t, db.Model(&database.Event{}).Count(&events).Error)
+	assert.Positive(t, events, "the stop waited for the whole prune")
+
+	eventTotals := readEventTotals(t, db)
+	assert.Equal(t, events, eventTotals.Events-eventTotals.EventsRemoved)
+
+	targetTotals := readTargetTotals(t, db)
+	require.Len(t, targetTotals, 2)
+
+	for target, totals := range targetTotals {
+		var deliveries, failures int64
+
+		require.NoError(t, db.Model(&database.Delivery{}).
+			Where("target_id = ?", target).
+			Count(&deliveries).Error)
+		require.NoError(t, db.Model(&database.Delivery{}).
+			Where("target_id = ? AND status = ?",
+				target, database.DeliveryStatusFailed).
+			Count(&failures).Error)
+
+		assert.Equal(t, deliveries,
+			totals.Deliveries-totals.DeliveriesRemoved, target)
+		assert.Equal(t, failures, totals.Failed-totals.FailedRemoved,
+			target)
+	}
+}

internal/database/webhook_db_manager.go

@@ -35,7 +35,8 @@ var errInvalidCachedDBType = errors.New(
 
 // WebhookDBManager manages per-webhook SQLite database files
 // for event storage. Each webhook gets its own dedicated
-// database containing Events, Deliveries, and DeliveryResults.
+// database containing Events, Deliveries, DeliveryResults and the
+// running totals of them (EventTotals, TargetTotals).
 // Database connections are opened lazily and cached.
 type WebhookDBManager struct {
 	dataDir string
@@ -295,6 +296,7 @@ func (m *WebhookDBManager) openDB(
 	// Run migrations for event-tier models only
 	err = db.AutoMigrate(
 		&Event{}, &Delivery{}, &DeliveryResult{},
+		&EventTotals{}, &TargetTotals{},
 	)
 	if err != nil {
 		_ = sqlDB.Close()
@@ -305,6 +307,18 @@ func (m *WebhookDBManager) openDB(
 		)
 	}
 
+	// A new database gets its row of event totals, all zero. Target
+	// totals rows are created by the first delivery to each target.
+	err = db.FirstOrCreate(&EventTotals{}).Error
+	if err != nil {
+		_ = sqlDB.Close()
+
+		return nil, fmt.Errorf(
+			"creating event totals for webhook database %s: %w",
+			webhookID, err,
+		)
+	}
+
 	m.log.Info(
 		"opened per-webhook database",
 		"webhook_id", webhookID,

internal/delivery/delivery_totals_test.go

@@ -0,0 +1,177 @@
+package delivery_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// targetTotals reads one target's totals from a webhook database, all
+// zero when it has no row.
+func targetTotals(
+	t *testing.T, db *gorm.DB, targetID string,
+) database.TargetTotals {
+	t.Helper()
+
+	var rows []database.TargetTotals
+
+	require.NoError(t, db.Where("target_id = ?", targetID).
+		Find(&rows).Error)
+
+	if len(rows) == 0 {
+		return database.TargetTotals{TargetID: targetID}
+	}
+
+	return rows[0]
+}
+
+// TestUpdateDeliveryStatus_FinishTimeAndTargetTotals pins what a status
+// write records for the webhook page's statistics: the time a delivery
+// finished, set only when it becomes delivered or failed, and one more
+// on its target's delivered or failed total.
+func TestUpdateDeliveryStatus_FinishTimeAndTargetTotals(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		status    database.DeliveryStatus
+		finished  bool
+		delivered int64
+		failed    int64
+	}{
+		{database.DeliveryStatusRetrying, false, 0, 0},
+		{database.DeliveryStatusDelivered, true, 1, 0},
+		{database.DeliveryStatusFailed, true, 0, 1},
+	}
+
+	for _, tt := range tests {
+		t.Run(string(tt.status), func(t *testing.T) {
+			t.Parallel()
+
+			db := testWebhookDB(t)
+			e := testEngine(t, 1)
+			event := seedEvent(t, db, `{}`)
+			targetID := uuid.New().String()
+			d := seedDelivery(
+				t, db, event.ID, targetID,
+				database.DeliveryStatusPending,
+			)
+
+			before := time.Now()
+
+			require.NoError(t, e.ExportUpdateDeliveryStatus(
+				db, &d, tt.status,
+			))
+
+			var stored database.Delivery
+
+			require.NoError(t, db.First(&stored, "id = ?", d.ID).Error)
+			assert.Equal(t, tt.status, stored.Status)
+
+			if tt.finished {
+				require.NotNil(t, stored.FinishedAt)
+				assert.False(t, stored.FinishedAt.Before(before))
+			} else {
+				assert.Nil(t, stored.FinishedAt)
+			}
+
+			assert.Equal(t, database.TargetTotals{
+				TargetID:  targetID,
+				Delivered: tt.delivered,
+				Failed:    tt.failed,
+			}, targetTotals(t, db, targetID))
+		})
+	}
+}
+
+// TestUpdateDeliveryStatus_DeletedDeliveryIsNotCounted covers a
+// delivery retention deleted while the engine still held it. Failing
+// it afterwards writes no row, so it adds no failure either: retention
+// has already counted what it removed.
+func TestUpdateDeliveryStatus_DeletedDeliveryIsNotCounted(t *testing.T) {
+	t.Parallel()
+
+	db := testWebhookDB(t)
+	e := testEngine(t, 1)
+	event := seedEvent(t, db, `{}`)
+	targetID := uuid.New().String()
+	d := seedDelivery(
+		t, db, event.ID, targetID,
+		database.DeliveryStatusRetrying,
+	)
+
+	require.NoError(t, db.Unscoped().
+		Delete(&database.Delivery{}, "id = ?", d.ID).Error)
+
+	require.NoError(t, e.ExportUpdateDeliveryStatus(
+		db, &d, database.DeliveryStatusFailed,
+	))
+
+	assert.Equal(t, database.TargetTotals{TargetID: targetID},
+		targetTotals(t, db, targetID))
+}
+
+// TestUpdateDeliveryStatus_FinishedDeliveryIsNotSettledAgain covers a
+// delivery settled a second time, as recovery can do when a worker has
+// settled it since recovery read it. Neither status writes over the
+// first, and the totals do not move.
+func TestUpdateDeliveryStatus_FinishedDeliveryIsNotSettledAgain(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	finished := []database.DeliveryStatus{
+		database.DeliveryStatusDelivered,
+		database.DeliveryStatusFailed,
+	}
+
+	for _, first := range finished {
+		t.Run(string(first), func(t *testing.T) {
+			t.Parallel()
+
+			db := testWebhookDB(t)
+			e := testEngine(t, 1)
+			event := seedEvent(t, db, `{}`)
+			targetID := uuid.New().String()
+			d := seedDelivery(
+				t, db, event.ID, targetID,
+				database.DeliveryStatusRetrying,
+			)
+
+			// The delivery as recovery read it, before the worker
+			// settled it.
+			readBefore := d
+
+			require.NoError(t, e.ExportUpdateDeliveryStatus(
+				db, &d, first,
+			))
+
+			var settled database.Delivery
+
+			require.NoError(t, db.First(&settled, "id = ?", d.ID).Error)
+			require.NotNil(t, settled.FinishedAt)
+
+			totals := targetTotals(t, db, targetID)
+
+			for _, again := range finished {
+				stale := readBefore
+
+				require.NoError(t, e.ExportUpdateDeliveryStatus(
+					db, &stale, again,
+				))
+			}
+
+			var stored database.Delivery
+
+			require.NoError(t, db.First(&stored, "id = ?", d.ID).Error)
+			assert.Equal(t, first, stored.Status)
+			require.NotNil(t, stored.FinishedAt)
+			assert.True(t, settled.FinishedAt.Equal(*stored.FinishedAt))
+			assert.Equal(t, totals, targetTotals(t, db, targetID))
+		})
+	}
+}

internal/delivery/engine.go

@@ -531,6 +531,11 @@ func (e *Engine) processRetryTask(
 		return
 	}
 
+	// Set before anything below can fail the delivery: the failure is
+	// added to this target's totals.
+	d.EventID = task.EventID
+	d.TargetID = task.TargetID
+
 	if d.Status != database.DeliveryStatusRetrying {
 		e.log.Debug(
 			"skipping retry for delivery "+
@@ -562,8 +567,6 @@ func (e *Engine) processRetryTask(
 	}
 
 	target := buildTargetFromTask(task)
-	d.EventID = task.EventID
-	d.TargetID = task.TargetID
 	d.Event = event
 	d.Target = target
 
@@ -1554,8 +1557,9 @@ func (e *Engine) updateDeliveryStatus(
 	targetType database.TargetType,
 	status database.DeliveryStatus,
 ) error {
-	err := webhookDB.Model(d).
-		Update("status", status).Error
+	err := webhookDB.Transaction(func(tx *gorm.DB) error {
+		return writeDeliveryStatus(tx, d, status)
+	})
 	if err != nil {
 		return fmt.Errorf(
 			"updating delivery %s to status %s: %w",
@@ -1574,6 +1578,43 @@ func (e *Engine) updateDeliveryStatus(
 	return nil
 }
 
+// writeDeliveryStatus writes a delivery's new status. A delivery that
+// becomes delivered or failed also gets the time it finished, and is
+// added to its target's delivered or failed total. That write changes
+// only a delivery not yet delivered or failed, and the total moves
+// only when it changed a row: retention may have deleted the delivery
+// while the engine was working on it, and a recovery path may settle
+// a delivery that a worker has already settled.
+func writeDeliveryStatus(
+	tx *gorm.DB,
+	d *database.Delivery,
+	status database.DeliveryStatus,
+) error {
+	if !status.Terminal() {
+		return tx.Model(d).Update("status", status).Error
+	}
+
+	res := tx.Model(d).
+		Where("status NOT IN ?", []database.DeliveryStatus{
+			database.DeliveryStatusDelivered,
+			database.DeliveryStatusFailed,
+		}).
+		Updates(map[string]any{
+			"status":      status,
+			"finished_at": time.Now(),
+		})
+	if res.Error != nil || res.RowsAffected == 0 {
+		return res.Error
+	}
+
+	add := database.TargetTotals{TargetID: d.TargetID, Delivered: 1}
+	if status == database.DeliveryStatusFailed {
+		add = database.TargetTotals{TargetID: d.TargetID, Failed: 1}
+	}
+
+	return database.AddTargetTotals(tx, add)
+}
+
 // settleStatus moves a delivery to its outcome status and reports a
 // failed write through bookkeepingFailed, which leaves the row
 // recoverable. It exists so the target call sites read as one

internal/delivery/engine_test.go

@@ -57,7 +57,10 @@ func testWebhookDB(t *testing.T) *gorm.DB {
 		&database.Event{},
 		&database.Delivery{},
 		&database.DeliveryResult{},
+		&database.EventTotals{},
+		&database.TargetTotals{},
 	))
+	require.NoError(t, db.Create(&database.EventTotals{}).Error)
 
 	return db
 }

internal/delivery/export_test.go

@@ -40,11 +40,6 @@ const (
 	ExportPendingSweepMinAge = pendingSweepMinAge
 )
 
-// ExportIsBlockedIP exposes isBlockedIP for testing.
-func ExportIsBlockedIP(ip net.IP) bool {
-	return isBlockedIP(ip)
-}
-
 // NewTestGuard builds an SSRF Guard from an explicit egress
 // allowlist, without going through config. Passing no prefixes
 // yields the default guard, which blocks every private/reserved
@@ -70,6 +65,11 @@ func ExportBlockedNetworks() []*net.IPNet {
 	return blockedNetworks
 }
 
+// ExportBlockedPublicNetworks exposes blockedPublicNetworks.
+func ExportBlockedPublicNetworks() []*net.IPNet {
+	return blockedPublicNetworks
+}
+
 // ExportIsForwardableHeader exposes isForwardableHeader.
 func ExportIsForwardableHeader(name string) bool {
 	return isForwardableHeader(name)
@@ -150,6 +150,16 @@ func (e *Engine) ExportDeliverSlack(
 	)
 }
 
+// ExportUpdateDeliveryStatus exposes updateDeliveryStatus. It passes no
+// target type, so no metric moves.
+func (e *Engine) ExportUpdateDeliveryStatus(
+	webhookDB *gorm.DB,
+	d *database.Delivery,
+	status database.DeliveryStatus,
+) error {
+	return e.updateDeliveryStatus(webhookDB, d, "", status)
+}
+
 // ExportProcessNewTask exposes processNewTask.
 func (e *Engine) ExportProcessNewTask(
 	ctx context.Context, task *Task,

internal/delivery/ssrf.go

@@ -25,8 +25,16 @@ var (
 	errNoIPs      = errors.New(
 		"hostname resolved to no IP addresses",
 	)
-	errBlockedIP = errors.New(
-		"blocked private, reserved or cloud metadata address",
+	// ErrBlockedPrivateOrReservedIP reports an address in the
+	// default blocklist's private and reserved ranges,
+	// blockedNetworks.
+	ErrBlockedPrivateOrReservedIP = errors.New(
+		"blocked private or reserved address",
+	)
+	// errBlockedPublicMetadata reports a public address on the
+	// default blocklist, one in blockedPublicNetworks.
+	errBlockedPublicMetadata = errors.New(
+		"blocked cloud metadata address",
 	)
 	errBlockedMetadata = errors.New(
 		"blocked link-local or cloud instance metadata " +
@@ -37,15 +45,32 @@ var (
 	)
 )
 
-// blockedNetworks is the default blocklist: the private and
-// reserved IP ranges, plus the public cloud metadata addresses,
-// that are blocked to prevent SSRF attacks. An operator can
-// permit specific blocks out of this set with
-// ALLOWED_EGRESS_CIDRS; see Guard.
+// blockedNetworks and blockedPublicNetworks together are the
+// default blocklist: the private and reserved IP ranges, plus
+// the public cloud metadata addresses, that are blocked to
+// prevent SSRF attacks. An operator can permit specific blocks
+// out of this set with ALLOWED_EGRESS_CIDRS; see Guard.
+//
+// blockedNetworks holds the private and reserved IP ranges.
 //
 //nolint:gochecknoglobals // package-level network list is appropriate here
 var blockedNetworks []*net.IPNet
 
+// blockedPublicNetworks holds the default blocklist's public
+// addresses, kept apart from blockedNetworks so that they are
+// refused as cloud metadata addresses, never as private or
+// reserved ones.
+//
+// A public address belongs on the default blocklist only if it
+// hands credentials, user data or bootstrap material to whatever
+// can reach it, without the caller presenting anything; it goes
+// in this list. A provider's other public addresses are not
+// refused, since reaching them can be legitimate and no list of
+// them could be complete.
+//
+//nolint:gochecknoglobals // package-level network list is appropriate here
+var blockedPublicNetworks []*net.IPNet
+
 // alwaysBlockedNetworks are the ranges no configuration can
 // open: the link-local blocks and the cloud instance metadata
 // endpoints that live outside them. Reaching one is credential
@@ -81,8 +106,8 @@ var blockedNetworks []*net.IPNet
 // when it clears both halves. Nothing in this list can be
 // reopened, so putting a public address here leaves the operator
 // no escape hatch at all — the condition ALLOWED_EGRESS_CIDRS
-// exists to remove. Default-block it in blockedNetworks instead,
-// which an allowlist can override.
+// exists to remove. Default-block it in blockedPublicNetworks
+// instead, which an allowlist can override.
 //
 // This is a criterion, not an enumeration of every metadata
 // address in existence.
@@ -123,6 +148,9 @@ func init() {
 		"::1/128",
 		"fc00::/7",
 		"fe80::/10",
+	})
+
+	blockedPublicNetworks = mustParseCIDRs([]string{
 		// Azure WireServer, a public address that serves VM credentials.
 		"168.63.129.16/32",
 	})
@@ -218,13 +246,6 @@ func matchesAny(networks []*net.IPNet, ip net.IP) bool {
 	return false
 }
 
-// isBlockedIP checks whether an IP address falls within
-// the default blocklist, before any operator allowlist is
-// considered.
-func isBlockedIP(ip net.IP) bool {
-	return matchesAny(blockedNetworks, ip)
-}
-
 // Guard makes every SSRF decision in the process.
 //
 // It holds the operator's ALLOWED_EGRESS_CIDRS allowlist and
@@ -325,7 +346,8 @@ func (g *Guard) allows(ip net.IP) bool {
 //     consulted, so no configured CIDR reaches link-local or a
 //     cloud metadata endpoint at a non-public address.
 //  2. The allowlist is consulted next, so a listed private
-//     network becomes reachable.
+//     network, or a listed public address on the default
+//     blocklist, becomes reachable.
 //  3. Everything else keeps the default blocklist's answer.
 func (g *Guard) checkIP(ip net.IP) error {
 	if matchesAny(alwaysBlockedNetworks, ip) {
@@ -338,9 +360,15 @@ func (g *Guard) checkIP(ip net.IP) error {
 		return nil
 	}
 
-	if isBlockedIP(ip) {
+	if matchesAny(blockedNetworks, ip) {
 		return fmt.Errorf(
-			"target IP %s: %w", ip, errBlockedIP,
+			"target IP %s: %w", ip, ErrBlockedPrivateOrReservedIP,
+		)
+	}
+
+	if matchesAny(blockedPublicNetworks, ip) {
+		return fmt.Errorf(
+			"target IP %s: %w", ip, errBlockedPublicMetadata,
 		)
 	}
 

internal/delivery/ssrf_allowlist_test.go

@@ -23,6 +23,10 @@ const (
 	metadataIP  = "169.254.169.254"
 	metadataURL = "http://" + metadataIP + "/latest/meta-data/"
 
+	// linkLocalIPv4 is the IPv4 link-local block, which holds
+	// metadataIP.
+	linkLocalIPv4 = "169.254.0.0/16"
+
 	// loopbackHookURL is a target on this host: blocked by
 	// default, reachable only once an operator allowlists
 	// loopback.
@@ -237,7 +241,7 @@ func linkLocalRefusedCases() []metadataAlwaysRefusedCase {
 		},
 		{
 			name:   "whole link-local block",
-			allow:  "169.254.0.0/16",
+			allow:  linkLocalIPv4,
 			target: metadataURL,
 		},
 		{
@@ -412,6 +416,9 @@ func TestGuardAllowlist_AzureWireServerReopenable(t *testing.T) {
 		"WireServer must be refused by the default blocklist, "+
 			"which an allowlist can override",
 	)
+	require.NotErrorIs(t, err, delivery.ErrBlockedPrivateOrReservedIP,
+		"WireServer is public, not private or reserved",
+	)
 
 	assertDialRefused(t, defaultGuard, target)
 
@@ -496,7 +503,7 @@ func TestAlwaysBlockedNetworks_PinnedSet(t *testing.T) {
 	want := []string{
 		// IPv4 link-local: the 169.254.169.254 metadata
 		// service on AWS, Azure and others.
-		"169.254.0.0/16",
+		linkLocalIPv4,
 		// IPv6 link-local.
 		"fe80::/10",
 		// AWS IPv6 IMDS, inside the ULA space an operator may
@@ -526,6 +533,90 @@ func TestAlwaysBlockedNetworks_PinnedSet(t *testing.T) {
 	assert.Equal(t, want, got)
 }
 
+// TestDefaultBlocklist_PinnedSet pins each list of the default
+// blocklist on its own, the private and reserved ranges in
+// blockedNetworks and the public addresses in
+// blockedPublicNetworks, so moving an entry from one list to the
+// other fails it. For the first address of each entry it then
+// checks that the default guard refuses it, and that listing the
+// entry in ALLOWED_EGRESS_CIDRS opens it unless the unconditional
+// set holds that address.
+func TestDefaultBlocklist_PinnedSet(t *testing.T) {
+	t.Parallel()
+
+	// public marks an entry of blockedPublicNetworks; every other
+	// entry belongs in blockedNetworks.
+	tests := []struct {
+		cidr       string
+		public     bool
+		reopenable bool
+	}{
+		{cidr: "127.0.0.0/8", reopenable: true},
+		{cidr: "10.0.0.0/8", reopenable: true},
+		{cidr: "172.16.0.0/12", reopenable: true},
+		{cidr: "192.168.0.0/16", reopenable: true},
+		{cidr: linkLocalIPv4, reopenable: false},
+		{cidr: "0.0.0.0/8", reopenable: true},
+		{cidr: "100.64.0.0/10", reopenable: true},
+		{cidr: "192.0.0.0/24", reopenable: true},
+		{cidr: "192.0.2.0/24", reopenable: true},
+		{cidr: "198.18.0.0/15", reopenable: true},
+		{cidr: "198.51.100.0/24", reopenable: true},
+		{cidr: "203.0.113.0/24", reopenable: true},
+		{cidr: "224.0.0.0/4", reopenable: true},
+		{cidr: "240.0.0.0/4", reopenable: true},
+		{cidr: "::1/128", reopenable: true},
+		{cidr: "fc00::/7", reopenable: true},
+		{cidr: "fe80::/10", reopenable: false},
+		{cidr: "168.63.129.16/32", public: true, reopenable: true},
+	}
+
+	wantPrivate := make([]string, 0, len(tests))
+	wantPublic := make([]string, 0, len(tests))
+
+	for _, tt := range tests {
+		if tt.public {
+			wantPublic = append(wantPublic, tt.cidr)
+		} else {
+			wantPrivate = append(wantPrivate, tt.cidr)
+		}
+	}
+
+	gotPrivate := make([]string, 0, len(tests))
+	for _, n := range delivery.ExportBlockedNetworks() {
+		gotPrivate = append(gotPrivate, n.String())
+	}
+
+	gotPublic := make([]string, 0, len(tests))
+	for _, n := range delivery.ExportBlockedPublicNetworks() {
+		gotPublic = append(gotPublic, n.String())
+	}
+
+	assert.ElementsMatch(t, wantPrivate, gotPrivate, "blockedNetworks")
+	assert.ElementsMatch(t, wantPublic, gotPublic, "blockedPublicNetworks")
+
+	for _, tt := range tests {
+		t.Run(tt.cidr, func(t *testing.T) {
+			t.Parallel()
+
+			prefix := netip.MustParsePrefix(tt.cidr)
+			ip := net.IP(prefix.Addr().AsSlice())
+
+			require.Error(t,
+				delivery.NewTestGuard().ExportCheckIP(ip),
+				"the default guard must refuse %s", ip,
+			)
+
+			err := delivery.NewTestGuard(prefix).ExportCheckIP(ip)
+			if tt.reopenable {
+				assert.NoError(t, err, "listing %s must open it", tt.cidr)
+			} else {
+				assert.Error(t, err, "listing %s must not open it", tt.cidr)
+			}
+		})
+	}
+}
+
 // requireLoopback fails the test unless rawURL's host is a
 // loopback address, so the allowlist test cannot silently stop
 // exercising a blocked range.

internal/delivery/ssrf_test.go

@@ -10,7 +10,7 @@ import (
 	"sneak.berlin/go/webhooker/internal/delivery"
 )
 
-func TestIsBlockedIP_PrivateRanges(t *testing.T) {
+func TestGuardCheckIP_PrivateRanges(t *testing.T) {
 	t.Parallel()
 
 	tests := []struct {
@@ -56,12 +56,14 @@ func TestIsBlockedIP_PrivateRanges(t *testing.T) {
 				"failed to parse IP %s", tt.ip,
 			)
 
+			refused := delivery.NewTestGuard().ExportCheckIP(ip) != nil
+
 			assert.Equal(t,
 				tt.blocked,
-				delivery.ExportIsBlockedIP(ip),
-				"isBlockedIP(%s) = %v, want %v",
+				refused,
+				"default guard refuses %s = %v, want %v",
 				tt.ip,
-				delivery.ExportIsBlockedIP(ip),
+				refused,
 				tt.blocked,
 			)
 		})

internal/delivery/terminal_state_test.go

@@ -418,6 +418,38 @@ func TestProcessRetryTask_TargetDeleted_MakesNoAttempt(
 	assert.Zero(t, s.Engine.ExportInflightHeld())
 }
 
+// TestProcessRetryTask_TargetDeleted_CountsFailureOnTarget verifies
+// that the failure of a retry abandoned because its target is gone is
+// added to that target's own totals, not to a row with no target.
+func TestProcessRetryTask_TargetDeleted_CountsFailureOnTarget(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	s := newISetup(t)
+
+	var hits atomic.Int64
+
+	task, targetID := tRetryChainSetup(
+		t, s, "gone-counted", &hits,
+	)
+
+	require.NoError(t, s.MainDB.Delete(
+		&database.Target{}, "id = ?", targetID,
+	).Error)
+
+	s.Engine.ExportProcessRetryTask(
+		context.Background(), &task,
+	)
+
+	var rows []database.TargetTotals
+
+	require.NoError(t, s.WebhookDB.Find(&rows).Error)
+	assert.Equal(t, []database.TargetTotals{
+		{TargetID: targetID, Failed: 1},
+	}, rows)
+}
+
 // TestProcessRetryTask_TargetPresent_StillDelivers is the guard's
 // mutation check: a liveness check that refused every retry would pass
 // the test above and break every retry there is.

internal/gormlog/gormlog.go

@@ -7,7 +7,7 @@
 // SQL — parameters and all — for every statement that returns an
 // error, including gorm.ErrRecordNotFound. Two of this service's
 // lookups miss by design on unauthenticated routes: the entrypoint
-// lookup on /webhook/{uuid}, whose path segment the client picks
+// lookup on /h/{uuid}, whose path segment the client picks
 // outright, and the user lookup behind the login form, whose username
 // the client picks outright. Under the default logger each of those
 // misses printed an unbounded, attacker-chosen string, at no level the

internal/handlers/auth.go

@@ -2,19 +2,56 @@ package handlers
 
 import (
 	"net/http"
+	"net/url"
 	"strconv"
+	"strings"
+	"unicode"
 
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/logfield"
+	"sneak.berlin/go/webhooker/internal/middleware"
 )
 
+// loginDestination returns where a successful login sends the
+// browser: next when it is a path on this site, otherwise "/", which
+// leads to the webhook list.
+//
+// A browser reads "//host" as another site, reads "\" as "/", and
+// drops tabs and newlines before reading at all. So the value must
+// start with exactly one "/" and hold no "\" or control character
+// anywhere: http.Redirect cleans "/a/../\host" down to "/\host". It
+// is checked after percent-decoding, so an encoded form of any of
+// these is refused too.
+func loginDestination(next string) string {
+	if len(next) > middleware.MaxNextBytes {
+		return "/"
+	}
+
+	decoded, err := url.PathUnescape(next)
+	if err != nil ||
+		!strings.HasPrefix(decoded, "/") ||
+		strings.HasPrefix(decoded, "//") ||
+		strings.Contains(decoded, `\`) ||
+		strings.ContainsFunc(decoded, unicode.IsControl) {
+		return "/"
+	}
+
+	return next
+}
+
 // HandleLoginPage returns a handler for the login page (GET)
 func (h *Handlers) HandleLoginPage() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
+		next := loginDestination(
+			r.URL.Query().Get(middleware.NextParam),
+		)
+
 		// Check if already logged in
 		sess, err := h.session.Get(r)
 		if err == nil && h.session.IsAuthenticated(sess) {
-			http.Redirect(w, r, "/", http.StatusSeeOther)
+			http.Redirect( //nolint:gosec // checked by loginDestination
+				w, r, next, http.StatusSeeOther,
+			)
 
 			return
 		}
@@ -22,6 +59,7 @@ func (h *Handlers) HandleLoginPage() http.HandlerFunc {
 		// Render login page
 		data := map[string]any{
 			tmplKeyError: "",
+			tmplKeyNext:  next,
 		}
 
 		h.renderTemplate(w, r, "login.html", data)
@@ -77,8 +115,13 @@ func (h *Handlers) HandleLoginSubmit() http.HandlerFunc {
 			"user_id", user.ID,
 		)
 
-		// Redirect to home page
-		http.Redirect(w, r, "/", http.StatusSeeOther)
+		// The form value is the client's to set, so it is checked
+		// again here rather than trusted from the rendered page.
+		http.Redirect( //nolint:gosec // checked by loginDestination
+			w, r,
+			loginDestination(r.PostFormValue(middleware.NextParam)),
+			http.StatusSeeOther,
+		)
 	}
 }
 
@@ -91,6 +134,9 @@ func (h *Handlers) renderLoginError(
 ) {
 	data := map[string]any{
 		tmplKeyError: msg,
+		tmplKeyNext: loginDestination(
+			r.PostFormValue(middleware.NextParam),
+		),
 	}
 
 	w.WriteHeader(status)
@@ -103,9 +149,10 @@ func (h *Handlers) renderLoginError(
 // The credential check runs BEFORE any rate-limit budget is
 // consulted, and only a failed check spends budget. That is what
 // keeps the single administrative path reachable: behind the reverse
-// proxy this deployment requires, with TRUSTED_PROXIES unset, every
-// client shares one bucket, so a limiter spent on arrival lets any
-// stranger deny the operator's own correct password indefinitely.
+// proxy this deployment requires, when TRUSTED_PROXIES does not cover
+// it, every client shares one bucket, so a limiter spent on arrival
+// lets any stranger deny the operator's own correct password
+// indefinitely.
 //
 // Verifying first means every login POST costs an Argon2id hash, so
 // the work is taken under a bounded number of verification slots.

internal/handlers/auth_test.go

@@ -25,7 +25,7 @@ const (
 
 	// sharedProxyPeer is the whole point of this file. Production is
 	// required to run behind a TLS-terminating reverse proxy, and
-	// TRUSTED_PROXIES defaults to empty, so every client — attacker
+	// when TRUSTED_PROXIES does not cover it every client — attacker
 	// and operator alike — reaches the process from the proxy's
 	// address and shares one rate-limit bucket. Both parties in
 	// these tests therefore use the same RemoteAddr.
@@ -115,11 +115,11 @@ func floodFailures(
 // done-criterion of https://git.eeqj.de/sneak/webhooker/issues/150.
 //
 // The attacker and the operator share one rate-limit bucket, because
-// behind the mandated reverse proxy with TRUSTED_PROXIES unset every
-// client keys on the proxy's address. The attacker floods the
-// operator's own username — a single-admin product has a predictable
-// one — far past the failure limit. The operator must still be able
-// to log in with the correct password.
+// behind the mandated reverse proxy, when TRUSTED_PROXIES does not
+// cover it, every client keys on the proxy's address. The attacker
+// floods the operator's own username — a single-admin product has a
+// predictable one — far past the failure limit. The operator must
+// still be able to log in with the correct password.
 //
 // This fails if credentials stop being verified ahead of the limiter.
 func TestLogin_StrangersFloodCannotLockOutTheOperator(t *testing.T) {
@@ -453,3 +453,229 @@ func TestLogin_SuccessCreatesSession(t *testing.T) {
 		"the issued cookie must carry an authenticated session",
 	)
 }
+
+// TestLogin_ReturnsOnlyToAPathOnThisSite is the security half of
+// https://git.eeqj.de/sneak/webhooker/issues/384: the page a login
+// returns to is client-chosen, so anything that is not a path on this
+// site, plain or percent-encoded, must land on "/", the webhook list.
+func TestLogin_ReturnsOnlyToAPathOnThisSite(t *testing.T) {
+	t.Parallel()
+
+	var (
+		h  *handlers.Handlers
+		db *database.Database
+	)
+
+	app := newTestApp(t, &h, &db)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	seedOperator(t, db)
+
+	cases := []struct{ next, want string }{
+		{"/hook/abc/events?page=2", "/hook/abc/events?page=2"},
+		{"", "/"},
+		{"https://evil.example/", "/"},
+		{"https%3A%2F%2Fevil.example%2F", "/"},
+		{"//evil.example/", "/"},
+		{"%2F%2Fevil.example/", "/"},
+		{"/%2Fevil.example/", "/"},
+		{`/\evil.example/`, "/"},
+		{"%2F%5Cevil.example/", "/"},
+		{"/%5Cevil.example/", "/"},
+		{`/a/../\evil.example/`, "/"},
+		{"/\t/evil.example/", "/"},
+		{"/%09/evil.example/", "/"},
+		{"/\n/evil.example/", "/"},
+		{"/%0A/evil.example/", "/"},
+		{"/\r/evil.example/", "/"},
+		{"/%0D/evil.example/", "/"},
+		{"/%00/evil.example/", "/"},
+		{"/%7F/evil.example/", "/"},
+		{"%252F%252Fevil.example/", "/"},
+		{"https%253A%252F%252Fevil.example%252F", "/"},
+		{"/" + strings.Repeat("a", 4096), "/"},
+	}
+
+	for _, c := range cases {
+		form := url.Values{}
+		form.Set("username", operatorUser)
+		form.Set("password", operatorPassword)
+		form.Set("next", c.next)
+
+		req := httptest.NewRequestWithContext(
+			context.Background(),
+			http.MethodPost,
+			"/pages/login",
+			strings.NewReader(form.Encode()),
+		)
+		req.Header.Set(
+			"Content-Type", "application/x-www-form-urlencoded",
+		)
+		req.RemoteAddr = sharedProxyPeer
+
+		w := httptest.NewRecorder()
+		h.HandleLoginSubmit().ServeHTTP(w, req)
+
+		assert.Equal(t, http.StatusSeeOther, w.Code, "next %q", c.next)
+		assert.Equal(
+			t, c.want, w.Header().Get("Location"), "next %q", c.next,
+		)
+	}
+}
+
+// TestLogin_WrongPasswordKeepsTheRequestedPage: after a wrong
+// password the login page is shown again with the same next, so the
+// next attempt still returns to the page that was asked for.
+func TestLogin_WrongPasswordKeepsTheRequestedPage(t *testing.T) {
+	t.Parallel()
+
+	var (
+		h  *handlers.Handlers
+		db *database.Database
+	)
+
+	app := newTestApp(t, &h, &db)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	seedOperator(t, db)
+
+	form := url.Values{}
+	form.Set("username", operatorUser)
+	form.Set("password", "wrong")
+	form.Set("next", "/hook/abc")
+
+	req := httptest.NewRequestWithContext(
+		context.Background(),
+		http.MethodPost,
+		"/pages/login",
+		strings.NewReader(form.Encode()),
+	)
+	req.Header.Set(
+		"Content-Type", "application/x-www-form-urlencoded",
+	)
+	req.RemoteAddr = sharedProxyPeer
+
+	w := httptest.NewRecorder()
+	h.HandleLoginSubmit().ServeHTTP(w, req)
+
+	assert.Equal(t, http.StatusUnauthorized, w.Code)
+	assert.Contains(
+		t, w.Body.String(), `name="next" value="/hook/abc"`,
+	)
+}
+
+// loginPageGet renders the login page as a GET with the given next
+// value and cookies.
+func loginPageGet(
+	h *handlers.Handlers, next string, cookies []*http.Cookie,
+) *httptest.ResponseRecorder {
+	req := httptest.NewRequestWithContext(
+		context.Background(), http.MethodGet,
+		"/pages/login?"+url.Values{"next": {next}}.Encode(), nil,
+	)
+
+	for _, c := range cookies {
+		req.AddCookie(c)
+	}
+
+	w := httptest.NewRecorder()
+	h.HandleLoginPage().ServeHTTP(w, req)
+
+	return w
+}
+
+// TestLoginPage_CarriesOnlyAPathOnThisSite covers the login page
+// itself: its form carries the requested page only when it is a path
+// on this site, and a browser already logged in goes straight there,
+// or to "/" when it is not.
+func TestLoginPage_CarriesOnlyAPathOnThisSite(t *testing.T) {
+	t.Parallel()
+
+	var (
+		h    *handlers.Handlers
+		sess *session.Session
+	)
+
+	app := newTestApp(t, &h, &sess)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	assert.Contains(
+		t, loginPageGet(h, "/hook/abc", nil).Body.String(),
+		`name="next" value="/hook/abc"`,
+	)
+	assert.Contains(
+		t, loginPageGet(h, "//evil.example/", nil).Body.String(),
+		`name="next" value="/"`,
+	)
+
+	cookies := authenticatedCookies(t, sess, "test-user-id", "testuser")
+
+	cases := []struct{ next, want string }{
+		{"/hook/abc", "/hook/abc"},
+		{"//evil.example/", "/"},
+		{`/\evil.example/`, "/"},
+	}
+
+	for _, c := range cases {
+		w := loginPageGet(h, c.next, cookies)
+
+		assert.Equal(t, http.StatusSeeOther, w.Code, "next %q", c.next)
+		assert.Equal(
+			t, c.want, w.Header().Get("Location"), "next %q", c.next,
+		)
+	}
+}
+
+// TestLoginPage_HasNoLinkToItself: the navigation bar on the login
+// page offers no link to the login page.
+func TestLoginPage_HasNoLinkToItself(t *testing.T) {
+	t.Parallel()
+
+	var h *handlers.Handlers
+
+	app := newTestApp(t, &h)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	w := loginPageGet(h, "", nil)
+
+	require.Equal(t, http.StatusOK, w.Code)
+	assert.NotContains(t, w.Body.String(), `href="/pages/login"`)
+}
+
+// TestLogin_UsernameAtLimitCanLogIn shows that a username of exactly
+// database.MaxUsernameBytes still fits in the session cookie. Past
+// what the cookie can carry, a correct login answers 500.
+func TestLogin_UsernameAtLimitCanLogIn(t *testing.T) {
+	t.Parallel()
+
+	var (
+		h  *handlers.Handlers
+		db *database.Database
+	)
+
+	app := newTestApp(t, &h, &db)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	username := strings.Repeat("a", database.MaxUsernameBytes)
+
+	hash, err := database.HashPassword(operatorPassword)
+	require.NoError(t, err)
+	require.NoError(t, db.DB().Create(&database.User{
+		Username: username,
+		Password: hash,
+	}).Error)
+
+	w := submitLogin(h, sharedProxyPeer, username, operatorPassword)
+
+	assert.Equal(t, http.StatusSeeOther, w.Code)
+}

internal/handlers/delivery_replay.go

@@ -299,8 +299,9 @@ func countInFlightDeliveries(
 	return count, err
 }
 
-// createReplayDelivery writes the new pending delivery row and returns
-// the task that carries it to the delivery engine.
+// createReplayDelivery writes the new pending delivery row, adds it to
+// its target's totals in the same transaction, and returns the task
+// that carries it to the delivery engine.
 //
 // The row is written with associations omitted, and neither Event nor
 // Target is populated on it: GORM's SaveBeforeAssociations would
@@ -319,7 +320,16 @@ func createReplayDelivery(
 		Status:   database.DeliveryStatusPending,
 	}
 
-	err := webhookDB.Omit(clause.Associations).Create(dlv).Error
+	err := webhookDB.Transaction(func(tx *gorm.DB) error {
+		err := tx.Omit(clause.Associations).Create(dlv).Error
+		if err != nil {
+			return err
+		}
+
+		return database.AddTargetTotals(tx, database.TargetTotals{
+			TargetID: dlv.TargetID, Deliveries: 1,
+		})
+	})
 	if err != nil {
 		return delivery.Task{}, err
 	}
@@ -362,7 +372,7 @@ func (h *Handlers) finishReplay(
 	webhook database.Webhook,
 	code replayOutcomeCode,
 ) {
-	dest := "/source/" + webhook.ID + "/logs?" +
+	dest := "/hook/" + webhook.ID + "/events?" +
 		replayOutcomeParam + "=" + string(code)
 
 	// The page is read from the form rather than the query string:

internal/handlers/delivery_replay_test.go

@@ -138,7 +138,7 @@ func postReplay(
 	t.Helper()
 
 	req := postRequest(
-		"/source/"+webhookID+"/deliveries/"+
+		"/hook/"+webhookID+"/deliveries/"+
 			deliveryID+"/replay",
 		authenticatedCookies(
 			t, sess, deleteTestUserID, deleteTestUsername,
@@ -212,7 +212,7 @@ func TestHandleDeliveryReplay_AppendsDeliveryAndLeavesOriginal(
 	require.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?replay=queued",
+		"/hook/"+wh.ID+"/events?replay=queued",
 		w.Header().Get("Location"),
 	)
 
@@ -362,7 +362,7 @@ func TestHandleDeliveryReplay_RefusesDeletedTarget(t *testing.T) {
 	require.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?replay=target-deleted",
+		"/hook/"+wh.ID+"/events?replay=target-deleted",
 		w.Header().Get("Location"),
 	)
 
@@ -390,7 +390,7 @@ func TestHandleDeliveryReplay_RefusesDeletedTarget(t *testing.T) {
 	require.Equal(t, http.StatusSeeOther, missing.Code)
 	assert.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?replay=target-missing",
+		"/hook/"+wh.ID+"/events?replay=target-missing",
 		missing.Header().Get("Location"),
 	)
 }
@@ -431,7 +431,7 @@ func TestHandleDeliveryReplay_RefusesWhileEarlierReplayInFlight(
 	require.Equal(t, http.StatusSeeOther, first.Code)
 	require.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?replay=queued",
+		"/hook/"+wh.ID+"/events?replay=queued",
 		first.Header().Get("Location"),
 	)
 
@@ -439,7 +439,7 @@ func TestHandleDeliveryReplay_RefusesWhileEarlierReplayInFlight(
 	require.Equal(t, http.StatusSeeOther, second.Code)
 	assert.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?replay=in-flight",
+		"/hook/"+wh.ID+"/events?replay=in-flight",
 		second.Header().Get("Location"),
 	)
 
@@ -465,7 +465,7 @@ func TestHandleDeliveryReplay_RefusesWhileEarlierReplayInFlight(
 	require.Equal(t, http.StatusSeeOther, pending.Code)
 	assert.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?replay=not-terminal",
+		"/hook/"+wh.ID+"/events?replay=not-terminal",
 		pending.Header().Get("Location"),
 	)
 }
@@ -501,7 +501,7 @@ func TestHandleSourceLogs_RendersReplayControlAndBanner(t *testing.T) {
 
 	assert.Contains(
 		t, body,
-		`action="/source/`+wh.ID+`/deliveries/`+
+		`action="/hook/`+wh.ID+`/deliveries/`+
 			original.ID+`/replay"`,
 	)
 	assert.Contains(t, body, `method="POST"`)

internal/handlers/event_body_test.go

@@ -64,8 +64,8 @@ func fetchEventBody(
 	req := httptest.NewRequestWithContext(
 		context.Background(),
 		http.MethodGet,
-		"/source/"+url.PathEscape(sourceID)+
-			"/logs/"+url.PathEscape(eventID)+"/body",
+		"/hook/"+url.PathEscape(sourceID)+
+			"/events/"+url.PathEscape(eventID)+"/body",
 		nil,
 	)
 
@@ -490,7 +490,7 @@ func TestHandleSourceLogs_TruncationMarkerLinksToDownload(
 	page := renderSourceLogsPage(t, h, sess, big.ID)
 	assert.Contains(
 		t, page,
-		"/source/"+big.ID+"/logs/"+bigEvt.ID+"/body",
+		"/hook/"+big.ID+"/events/"+bigEvt.ID+"/body",
 	)
 
 	small := seedWebhook(t, db)
@@ -501,6 +501,6 @@ func TestHandleSourceLogs_TruncationMarkerLinksToDownload(
 	page = renderSourceLogsPage(t, h, sess, small.ID)
 	assert.NotContains(
 		t, page,
-		"/source/"+small.ID+"/logs/"+smallEvt.ID+"/body",
+		"/hook/"+small.ID+"/events/"+smallEvt.ID+"/body",
 	)
 }

internal/handlers/event_resubmit.go

@@ -257,7 +257,7 @@ func (h *Handlers) finishResubmit(
 	webhook database.Webhook,
 	code resubmitOutcomeCode,
 ) {
-	dest := "/source/" + webhook.ID + "/logs?" +
+	dest := "/hook/" + webhook.ID + "/events?" +
 		resubmitOutcomeParam + "=" + string(code)
 
 	// The page is read from the form rather than the query string:

internal/handlers/event_resubmit_test.go

@@ -65,7 +65,7 @@ func postResubmit(
 	t.Helper()
 
 	req := postRequest(
-		"/source/"+webhookID+"/events/"+eventID+"/resubmit",
+		"/hook/"+webhookID+"/events/"+eventID+"/resubmit",
 		authenticatedCookies(
 			t, sess, deleteTestUserID, deleteTestUsername,
 		),
@@ -154,7 +154,7 @@ func TestHandleEventResubmit_DeliversToTargetCreatedAfterTheEvent(
 	require.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?resubmit=queued",
+		"/hook/"+wh.ID+"/events?resubmit=queued",
 		w.Header().Get("Location"),
 	)
 
@@ -204,6 +204,7 @@ func assertEventCopy(
 	assert.Equal(t, original.Method, fresh.Method)
 	assert.Equal(t, original.Headers, fresh.Headers)
 	assert.Equal(t, original.Body, fresh.Body)
+	assert.Equal(t, int64(len(original.Body)), fresh.BodyBytes)
 	assert.Equal(t, original.ContentType, fresh.ContentType)
 	assert.Equal(t, original.EntrypointID, fresh.EntrypointID)
 	assert.Equal(t, original.WebhookID, fresh.WebhookID)
@@ -281,7 +282,7 @@ func TestHandleEventResubmit_IsRepeatable(t *testing.T) {
 		require.Equal(t, http.StatusSeeOther, w.Code)
 		assert.Equal(
 			t,
-			"/source/"+wh.ID+"/logs?resubmit=queued",
+			"/hook/"+wh.ID+"/events?resubmit=queued",
 			w.Header().Get("Location"),
 			"a resubmit must not be refused while an earlier "+
 				"one is in flight",
@@ -435,7 +436,7 @@ func TestHandleEventResubmit_SkipsInactiveTarget(t *testing.T) {
 	require.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?resubmit=queued",
+		"/hook/"+wh.ID+"/events?resubmit=queued",
 		w.Header().Get("Location"),
 		"an inactive target is skipped, not an error",
 	)
@@ -481,7 +482,7 @@ func TestHandleEventResubmit_NoActiveTargetsStillStoresEvent(
 	require.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?resubmit=no-targets",
+		"/hook/"+wh.ID+"/events?resubmit=no-targets",
 		w.Header().Get("Location"),
 	)
 
@@ -597,7 +598,7 @@ func TestHandleSourceLogs_ShowsResubmitProvenance(t *testing.T) {
 	)
 	assert.Contains(
 		t, body,
-		"/source/"+wh.ID+"/events/"+original.ID+"/resubmit",
+		"/hook/"+wh.ID+"/events/"+original.ID+"/resubmit",
 		"the log must offer the resubmit action per event",
 	)
 }

internal/handlers/export_test.go

@@ -4,7 +4,9 @@ import (
 	"html/template"
 	"log/slog"
 	"net/http"
+	"time"
 
+	"gorm.io/gorm"
 	"sneak.berlin/go/webhooker/internal/database"
 )
 
@@ -69,6 +71,29 @@ func (s *Handlers) LoadEventLogViewsForTest(
 	return views
 }
 
+// WebhookStatsForTest returns the figures the statistics pane on a
+// webhook's page shows, from the webhook's entrypoints and targets
+// loaded as that page loads them.
+func (s *Handlers) WebhookStatsForTest(webhookID string) *WebhookStats {
+	var entrypoints []database.Entrypoint
+
+	s.db.DB().Where("webhook_id = ?", webhookID).Find(&entrypoints)
+
+	var targets []database.Target
+
+	s.db.DB().Where("webhook_id = ?", webhookID).Find(&targets)
+
+	return s.loadWebhookStats(webhookID, entrypoints, targets)
+}
+
+// FinishedByTargetForTest exposes finishedByTarget for use in the
+// handlers_test package.
+func FinishedByTargetForTest(
+	webhookDB *gorm.DB, since time.Time,
+) ([]TargetFinished, error) {
+	return finishedByTarget(webhookDB, since)
+}
+
 // AddTemplateForTest registers a template under a page name so that
 // the handlers_test package can drive the render path with a
 // template of its own.

internal/handlers/gormlogbound_test.go

@@ -306,7 +306,7 @@ func postWebhook(
 	t.Helper()
 
 	req := httptest.NewRequestWithContext(
-		context.Background(), http.MethodPost, "/webhook/x",
+		context.Background(), http.MethodPost, "/h/x",
 		strings.NewReader("{}"),
 	)
 

internal/handlers/handlers.go

@@ -28,7 +28,7 @@ const (
 	// maxBodyShift is the bit shift for 1 MB body limit.
 	maxBodyShift = 20
 	// recentEventLimit is the number of recent events to show.
-	recentEventLimit = 20
+	recentEventLimit = 50
 	// paginationPerPage is the number of items per page.
 	paginationPerPage = 25
 
@@ -36,6 +36,9 @@ const (
 	tmplKeyError = "Error"
 	// tmplKeyWebhook is the template data key for a webhook.
 	tmplKeyWebhook = "Webhook"
+	// tmplKeyNext is the template data key for the page to return
+	// to after login.
+	tmplKeyNext = "Next"
 )
 
 // errInvalidPassword is returned when a password does not match.
@@ -91,18 +94,22 @@ type Handlers struct {
 
 // parsePageTemplate parses a page-specific template set from the
 // embedded FS. Each page template is combined with the shared
-// base, htmlheader, and navbar templates. The page file must be
-// listed first so that its root action ({{template "base" .}})
-// becomes the template set's entry point.
-func parsePageTemplate(pageFile string) *template.Template {
+// base, htmlheader, and navbar templates, and with any further files
+// the page includes. The page file must be listed first so that its
+// root action ({{template "base" .}}) becomes the template set's entry
+// point.
+func parsePageTemplate(
+	pageFile string, included ...string,
+) *template.Template {
+	files := append([]string{
+		pageFile,
+		"base.html",
+		"htmlheader.html",
+		"navbar.html",
+	}, included...)
+
 	return template.Must(
-		template.ParseFS(
-			templates.Templates,
-			pageFile,
-			"base.html",
-			"htmlheader.html",
-			"navbar.html",
-		),
+		template.ParseFS(templates.Templates, files...),
 	)
 }
 
@@ -131,7 +138,7 @@ func New(
 		"profile.html":       parsePageTemplate("profile.html"),
 		"sources_list.html":  parsePageTemplate("sources_list.html"),
 		"sources_new.html":   parsePageTemplate("sources_new.html"),
-		"source_detail.html": parsePageTemplate("source_detail.html"),
+		"source_detail.html": parsePageTemplate("source_detail.html", "webhook_stats.html"),
 		"source_edit.html":   parsePageTemplate("source_edit.html"),
 		"source_logs.html":   parsePageTemplate("source_logs.html"),
 		"target_edit.html":   parsePageTemplate("target_edit.html"),

internal/handlers/handlers_test.go

@@ -176,7 +176,7 @@ func TestHandleIndex_Authenticated(t *testing.T) {
 
 	assert.Equal(t, http.StatusSeeOther, w2.Code)
 	assert.Equal(
-		t, "/sources", w2.Header().Get("Location"),
+		t, "/hooks", w2.Header().Get("Location"),
 	)
 }
 

internal/handlers/index.go

@@ -5,13 +5,13 @@ import (
 )
 
 // HandleIndex returns a handler for the root path that redirects
-// based on authentication state: authenticated users go to /sources
+// based on authentication state: authenticated users go to /hooks
 // (the dashboard), unauthenticated users go to the login page.
 func (s *Handlers) HandleIndex() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		sess, err := s.session.Get(r)
 		if err == nil && s.session.IsAuthenticated(sess) {
-			http.Redirect(w, r, "/sources", http.StatusSeeOther)
+			http.Redirect(w, r, "/hooks", http.StatusSeeOther)
 
 			return
 		}

internal/handlers/logbound_test.go

@@ -4,7 +4,7 @@ package handlers_test
 // this package reach a value an UNAUTHENTICATED client picks outright
 // and of a length it picks outright:
 //
-//   - the unknown-entrypoint DEBUG line on /webhook/{uuid}, whose
+//   - the unknown-entrypoint DEBUG line on /h/{uuid}, whose
 //     path segment matched no stored entrypoint and so is bounded by
 //     nothing;
 //   - the failed-login DEBUG lines, whose username is a form field.
@@ -190,12 +190,12 @@ func assertNoClientText(t *testing.T, buf *bytes.Buffer) {
 // route pattern.
 func receiverRouter(h *handlers.Handlers) *chi.Mux {
 	router := chi.NewRouter()
-	router.Post("/webhook/{uuid}", h.HandleWebhook())
+	router.Post("/h/{uuid}", h.HandleWebhook())
 
 	return router
 }
 
-// postReceiver sends one POST at /webhook/<segment>.
+// postReceiver sends one POST at /h/<segment>.
 //
 // RawPath is cleared after parsing so chi routes on the decoded path
 // and the handler sees the raw bytes rather than their percent-escaped
@@ -210,7 +210,7 @@ func postReceiver(
 	req := httptest.NewRequestWithContext(
 		context.Background(),
 		http.MethodPost,
-		"/webhook/"+url.PathEscape(segment),
+		"/h/"+url.PathEscape(segment),
 		strings.NewReader(""),
 	)
 	req.URL.RawPath = ""
@@ -339,11 +339,9 @@ const storedUserPassword = "correct-horse-battery-staple"
 // storedFillBytes is the raw length of the client-chosen value in
 // those accounts' usernames. It is well past the 512-byte field
 // budget, so the line is still truncated, but short enough that the
-// session cookie a successful login writes stays inside
-// securecookie's 4 KB limit: the cookie is written BEFORE the
-// "user logged in" line, so an 8 KB username answers 500 and never
-// reaches it.
-const storedFillBytes = 1024
+// whole username, markers and fill name included, stays within
+// database.MaxUsernameBytes.
+const storedFillBytes = 960
 
 // storedFill builds a username fill of storedFillBytes raw bytes out
 // of repetitions of ch, with both markers at its far end.
@@ -509,7 +507,7 @@ func TestVerificationCapacity_LogLineDoesNotTrackPathSize(
 					http.StatusServiceUnavailable,
 					postLoginAtPath(
 						t, h,
-						"/source/"+url.PathEscape(
+						"/hook/"+url.PathEscape(
 							oversizedFill(fill),
 						)+"/login",
 					),

internal/handlers/profile_test.go

@@ -88,6 +88,8 @@ func TestHandleProfile_OwnProfile_OK(t *testing.T) {
 	h.HandleProfile().ServeHTTP(w, req)
 
 	assert.Equal(t, http.StatusOK, w.Code)
+	assert.Contains(t, w.Body.String(), "Account Information")
+	assert.NotContains(t, w.Body.String(), "Account Type")
 }
 
 func TestHandleProfile_OtherProfile_Forbidden(t *testing.T) {
@@ -158,7 +160,10 @@ func TestUserRoute_Unauthenticated_RedirectedByMiddleware(t *testing.T) {
 		"handler must not be reached for unauthenticated request",
 	)
 	assert.Equal(t, http.StatusSeeOther, w.Code)
-	assert.Equal(t, "/pages/login", w.Header().Get("Location"))
+	assert.Equal(
+		t, "/pages/login?next=%2Fuser%2Ftestuser",
+		w.Header().Get("Location"),
+	)
 }
 
 // passwordChangeRequest builds a POST request to the password-change

internal/handlers/recent_events.go

@@ -0,0 +1,293 @@
+package handlers
+
+import (
+	"net/http"
+	"slices"
+	"strconv"
+	"time"
+
+	"github.com/dustin/go-humanize"
+	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// recentEventColumns is the recent events list's projection. It
+// leaves out the body, for the reason maxRenderedBodyBytes gives,
+// and reads its size from body_bytes, recorded when the event was
+// stored.
+const recentEventColumns = "id, created_at, method, content_type, " +
+	"resubmitted_from_id, body_bytes"
+
+// recentAttemptColumns is the part of a recorded attempt the list
+// uses. The event log's deliveryResultColumns also reads response
+// bodies, which the list does not show.
+const recentAttemptColumns = "delivery_id, status_code, created_at"
+
+// RecentEventView is one row of the recent events list on a
+// webhook's page.
+type RecentEventView struct {
+	Method      string
+	ContentType string
+
+	// ResubmittedFromID names the event this one was copied from,
+	// empty for an event that arrived on the receiver.
+	ResubmittedFromID string
+
+	// Received is how long ago the event arrived, and ReceivedUTC
+	// the full timestamp the page shows on hover.
+	Received    string
+	ReceivedUTC string
+
+	// Size is the size of the stored body.
+	Size string
+
+	// ProcessingTime is how long the event's slowest delivery
+	// took; see processingTime.
+	ProcessingTime string
+
+	// Status is what the webhook's HTTP target answered, and
+	// StatusClass its colour; see targetStatus. Both are empty
+	// unless the webhook has exactly one HTTP target.
+	Status      string
+	StatusClass string
+}
+
+// recentEventRow is one row of recentEventColumns.
+type recentEventRow struct {
+	ID                string
+	CreatedAt         time.Time
+	Method            string
+	ContentType       string
+	ResubmittedFromID *string
+	BodyBytes         uint64
+}
+
+// recentAttemptRow is one row of recentAttemptColumns. CreatedAt is
+// when the attempt's result was recorded, which is when the attempt
+// finished.
+type recentAttemptRow struct {
+	DeliveryID string
+	StatusCode int
+	CreatedAt  time.Time
+}
+
+// singleHTTPTargetID returns the ID of the webhook's HTTP target
+// when it has exactly one, and "" when it has none or several.
+func singleHTTPTargetID(targets []database.Target) string {
+	id := ""
+	count := 0
+
+	for i := range targets {
+		if targets[i].Type == database.TargetTypeHTTP {
+			id = targets[i].ID
+			count++
+		}
+	}
+
+	if count != 1 {
+		return ""
+	}
+
+	return id
+}
+
+// loadRecentEvents loads the webhook's recentEventLimit newest
+// events for its page, newest first. statusTargetID is the
+// webhook's only HTTP target, or "" when the list shows no status.
+func loadRecentEvents(
+	webhookDB *gorm.DB, webhookID, statusTargetID string,
+) ([]RecentEventView, error) {
+	var rows []recentEventRow
+
+	err := webhookDB.Model(&database.Event{}).
+		Select(recentEventColumns).
+		Where("webhook_id = ?", webhookID).
+		Order("created_at DESC").
+		Limit(recentEventLimit).
+		Find(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+
+	eventIDs := make([]string, len(rows))
+	for i := range rows {
+		eventIDs[i] = rows[i].ID
+	}
+
+	// Oldest first, so an event's last delivery to a target is its
+	// newest: a replay adds a delivery rather than changing the
+	// earlier one.
+	var deliveries []database.Delivery
+
+	err = webhookDB.
+		Select("id, event_id, target_id, status, created_at").
+		Where("event_id IN ?", eventIDs).
+		Order("created_at ASC").
+		Find(&deliveries).Error
+	if err != nil {
+		return nil, err
+	}
+
+	byEvent := make(map[string][]database.Delivery, len(rows))
+	deliveryIDs := make([]string, len(deliveries))
+
+	for i := range deliveries {
+		eventID := deliveries[i].EventID
+		byEvent[eventID] = append(byEvent[eventID], deliveries[i])
+		deliveryIDs[i] = deliveries[i].ID
+	}
+
+	attempts, err := loadRecentAttempts(webhookDB, deliveryIDs)
+	if err != nil {
+		return nil, err
+	}
+
+	views := make([]RecentEventView, len(rows))
+	for i := range rows {
+		views[i] = rows[i].view(
+			byEvent[rows[i].ID], attempts, statusTargetID,
+		)
+	}
+
+	return views, nil
+}
+
+// loadRecentAttempts loads the recorded attempts of the listed
+// events' deliveries, keyed by delivery ID, each delivery's in
+// attempt order. The IDs go in chunks for the reason
+// deliveryIDChunkSize gives.
+func loadRecentAttempts(
+	webhookDB *gorm.DB, deliveryIDs []string,
+) (map[string][]recentAttemptRow, error) {
+	byDelivery := make(map[string][]recentAttemptRow)
+
+	for chunk := range slices.Chunk(deliveryIDs, deliveryIDChunkSize) {
+		var rows []recentAttemptRow
+
+		err := webhookDB.Model(&database.DeliveryResult{}).
+			Select(recentAttemptColumns).
+			Where("delivery_id IN ?", chunk).
+			Order("attempt_num ASC").
+			Find(&rows).Error
+		if err != nil {
+			return nil, err
+		}
+
+		for i := range rows {
+			id := rows[i].DeliveryID
+			byDelivery[id] = append(byDelivery[id], rows[i])
+		}
+	}
+
+	return byDelivery, nil
+}
+
+// view projects a loaded row for rendering. deliveries is the
+// event's deliveries, oldest first, and attempts their recorded
+// attempts keyed by delivery ID.
+func (r *recentEventRow) view(
+	deliveries []database.Delivery,
+	attempts map[string][]recentAttemptRow,
+	statusTargetID string,
+) RecentEventView {
+	v := RecentEventView{
+		Method:         r.Method,
+		ContentType:    r.ContentType,
+		Received:       humanize.Time(r.CreatedAt),
+		ReceivedUTC:    r.CreatedAt.UTC().Format(time.DateTime) + " UTC",
+		Size:           humanize.Bytes(r.BodyBytes),
+		ProcessingTime: processingTime(deliveries, attempts),
+	}
+
+	if r.ResubmittedFromID != nil {
+		v.ResubmittedFromID = *r.ResubmittedFromID
+	}
+
+	if statusTargetID != "" {
+		v.Status, v.StatusClass = targetStatus(
+			deliveries, attempts, statusTargetID,
+		)
+	}
+
+	return v
+}
+
+// processingTime is how long the event's slowest delivery took,
+// from being queued to its last recorded attempt, time spent
+// waiting between retries included. A delivery is queued when its
+// event is received, or when an operator replays it, so a replay
+// is timed from the replay rather than from the event's arrival.
+// It is "in progress" while any delivery is pending or retrying,
+// and empty for an event with no deliveries.
+func processingTime(
+	deliveries []database.Delivery,
+	attempts map[string][]recentAttemptRow,
+) string {
+	if len(deliveries) == 0 {
+		return ""
+	}
+
+	var slowest time.Duration
+
+	for i := range deliveries {
+		if !deliveries[i].Status.Terminal() {
+			return "in progress"
+		}
+
+		tries := attempts[deliveries[i].ID]
+		if len(tries) == 0 {
+			continue
+		}
+
+		last := tries[len(tries)-1].CreatedAt
+		slowest = max(slowest, last.Sub(deliveries[i].CreatedAt))
+	}
+
+	return slowest.Round(time.Millisecond).String()
+}
+
+// targetStatus is what the target answered for the event, and the
+// colour to show it in: the HTTP status code of the last attempt of
+// the event's newest delivery to the target. Without a code it is
+// "no response" when that attempt failed before a response
+// arrived, the delivery's status ("pending") before any attempt,
+// and "not sent" when the event has no delivery to the target.
+func targetStatus(
+	deliveries []database.Delivery,
+	attempts map[string][]recentAttemptRow,
+	targetID string,
+) (string, string) {
+	newest := -1
+
+	for i := range deliveries {
+		if deliveries[i].TargetID == targetID {
+			newest = i
+		}
+	}
+
+	if newest < 0 {
+		return "not sent", "text-gray-400"
+	}
+
+	tries := attempts[deliveries[newest].ID]
+	if len(tries) == 0 {
+		return string(deliveries[newest].Status), "text-gray-400"
+	}
+
+	code := tries[len(tries)-1].StatusCode
+
+	switch {
+	case code == 0:
+		return "no response", "text-red-600"
+	case code >= http.StatusInternalServerError:
+		return strconv.Itoa(code), "text-red-600"
+	case code >= http.StatusBadRequest:
+		return strconv.Itoa(code), "text-yellow-600"
+	case code >= http.StatusMultipleChoices:
+		return strconv.Itoa(code), "text-gray-500"
+	case code >= http.StatusOK:
+		return strconv.Itoa(code), "text-green-600"
+	default:
+		return strconv.Itoa(code), "text-gray-500"
+	}
+}

internal/handlers/recent_events_test.go

@@ -0,0 +1,362 @@
+package handlers_test
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/go-chi/chi"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/handlers"
+	"sneak.berlin/go/webhooker/internal/session"
+)
+
+// statusTitle marks the status column's cell in a recent events
+// row; it is absent from the page when the column is not shown.
+const statusTitle = `title="HTTP status from the HTTP target"`
+
+// recentEventsFixture is one started app and a webhook whose
+// recent events list a test fills.
+type recentEventsFixture struct {
+	h         *handlers.Handlers
+	sess      *session.Session
+	db        *database.Database
+	webhook   *database.Webhook
+	webhookDB *gorm.DB
+}
+
+func newRecentEventsFixture(t *testing.T) *recentEventsFixture {
+	t.Helper()
+
+	f := &recentEventsFixture{}
+
+	var dbMgr *database.WebhookDBManager
+
+	app := newTestApp(t, &f.h, &f.sess, &f.db, &dbMgr)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	f.webhook = seedWebhook(t, f.db)
+
+	webhookDB, err := dbMgr.GetDB(f.webhook.ID)
+	require.NoError(t, err)
+
+	f.webhookDB = webhookDB
+
+	return f
+}
+
+func (f *recentEventsFixture) render(t *testing.T) string {
+	t.Helper()
+
+	return renderSourceDetailPage(t, f.h, f.sess, f.webhook.ID)
+}
+
+// event records an event received at receivedAt, with its body's
+// size as the receiver records it.
+func (f *recentEventsFixture) event(
+	t *testing.T, contentType, body string, receivedAt time.Time,
+) *database.Event {
+	t.Helper()
+
+	event := &database.Event{
+		WebhookID:   f.webhook.ID,
+		Method:      http.MethodPost,
+		Body:        body,
+		BodyBytes:   int64(len(body)),
+		ContentType: contentType,
+	}
+	event.CreatedAt = receivedAt
+
+	require.NoError(t, f.webhookDB.Omit(
+		clause.Associations,
+	).Create(event).Error)
+
+	return event
+}
+
+// delivery records a delivery of the event to the target, queued
+// when the event was received.
+func (f *recentEventsFixture) delivery(
+	t *testing.T,
+	event *database.Event,
+	targetID string,
+	status database.DeliveryStatus,
+) *database.Delivery {
+	t.Helper()
+
+	return f.deliveryQueuedAt(
+		t, event, targetID, status, event.CreatedAt,
+	)
+}
+
+// deliveryQueuedAt records a delivery of the event to the target,
+// queued at queuedAt, as a replay is.
+func (f *recentEventsFixture) deliveryQueuedAt(
+	t *testing.T,
+	event *database.Event,
+	targetID string,
+	status database.DeliveryStatus,
+	queuedAt time.Time,
+) *database.Delivery {
+	t.Helper()
+
+	dlv := &database.Delivery{
+		EventID:  event.ID,
+		TargetID: targetID,
+		Status:   status,
+	}
+	dlv.CreatedAt = queuedAt
+
+	require.NoError(t, f.webhookDB.Omit(
+		clause.Associations,
+	).Create(dlv).Error)
+
+	return dlv
+}
+
+// attempt records one attempt of the delivery that finished took
+// after the delivery was queued, with HTTP status code (0 for no
+// response).
+func (f *recentEventsFixture) attempt(
+	t *testing.T, dlv *database.Delivery, code int, took time.Duration,
+) {
+	t.Helper()
+
+	result := &database.DeliveryResult{
+		DeliveryID: dlv.ID,
+		AttemptNum: 1,
+		StatusCode: code,
+	}
+	result.CreatedAt = dlv.CreatedAt.Add(took)
+
+	require.NoError(t, f.webhookDB.Omit(
+		clause.Associations,
+	).Create(result).Error)
+}
+
+// statusCell is the status column's cell as the page renders it.
+func statusCell(class, text string) string {
+	return `<span class="font-medium ` + class + `" ` + statusTitle +
+		`>` + text + `</span>`
+}
+
+// TestHandleSourceDetail_ShowsFiftyNewestEvents proves the list is
+// headed "50 Most Recent Events" and holds the 50 newest events,
+// newest first, and not one more.
+func TestHandleSourceDetail_ShowsFiftyNewestEvents(t *testing.T) {
+	t.Parallel()
+
+	f := newRecentEventsFixture(t)
+	base := time.Now().Add(-time.Hour)
+
+	for i := range 51 {
+		f.event(
+			t, fmt.Sprintf("application/x-recent-%02d", i), "{}",
+			base.Add(time.Duration(i)*time.Second),
+		)
+	}
+
+	body := f.render(t)
+
+	assert.Contains(t, body, ">50 Most Recent Events</h2>")
+	assert.Equal(t, 50, strings.Count(body, `title="Body size"`))
+	assert.NotContains(t, body, "application/x-recent-00")
+	assert.Contains(t, body, "application/x-recent-01")
+	assert.Less(
+		t,
+		strings.Index(body, "application/x-recent-50"),
+		strings.Index(body, "application/x-recent-49"),
+	)
+}
+
+// TestHandleSourceDetail_RecentEventColumns proves a row shows its
+// time relative with the UTC timestamp on hover, its body size,
+// and its processing time once every delivery has finished.
+func TestHandleSourceDetail_RecentEventColumns(t *testing.T) {
+	t.Parallel()
+
+	f := newRecentEventsFixture(t)
+	logTarget := seedTarget(t, f.db, f.webhook.ID, database.TargetTypeLog)
+
+	receivedAt := time.Now().Add(-210 * time.Second).
+		UTC().Truncate(time.Second)
+
+	done := f.event(
+		t, contentTypeJSON, strings.Repeat("x", 2048), receivedAt,
+	)
+	f.attempt(
+		t,
+		f.delivery(t, done, logTarget.ID, database.DeliveryStatusDelivered),
+		0, 1500*time.Millisecond,
+	)
+
+	waiting := f.event(t, "text/plain", "{}", receivedAt)
+	f.delivery(t, waiting, logTarget.ID, database.DeliveryStatusPending)
+
+	body := f.render(t)
+
+	assert.Contains(
+		t, body,
+		`<span title="`+receivedAt.Format(time.DateTime)+
+			` UTC">3 minutes ago</span>`,
+	)
+	assert.Contains(t, body, `<span title="Body size">2.0 kB</span>`)
+	assert.Contains(t, body, ">1.5s</span>")
+	assert.Contains(t, body, ">in progress</span>")
+}
+
+// TestHandleSourceDetail_StatusWithSingleHTTPTarget proves that a
+// webhook with exactly one HTTP target shows, colour-coded, what
+// that target answered for each event. The log target beside it
+// does not count against "exactly one".
+func TestHandleSourceDetail_StatusWithSingleHTTPTarget(t *testing.T) {
+	t.Parallel()
+
+	f := newRecentEventsFixture(t)
+	target := seedTarget(t, f.db, f.webhook.ID, database.TargetTypeHTTP)
+	seedTarget(t, f.db, f.webhook.ID, database.TargetTypeLog)
+
+	now := time.Now()
+
+	for _, code := range []int{204, 302, 404, 503, 0} {
+		dlv := f.delivery(
+			t, f.event(t, contentTypeJSON, "{}", now), target.ID,
+			database.DeliveryStatusDelivered,
+		)
+		f.attempt(t, dlv, code, time.Second)
+	}
+
+	f.delivery(
+		t, f.event(t, contentTypeJSON, "{}", now), target.ID,
+		database.DeliveryStatusPending,
+	)
+	f.event(t, contentTypeJSON, "{}", now)
+
+	// A replay is a newer delivery, and its answer is the one shown.
+	replayed := f.event(t, contentTypeJSON, "{}", now)
+	f.attempt(t, f.delivery(
+		t, replayed, target.ID, database.DeliveryStatusFailed,
+	), 502, time.Second)
+	f.attempt(t, f.deliveryQueuedAt(
+		t, replayed, target.ID, database.DeliveryStatusDelivered,
+		now.Add(time.Minute),
+	), 200, time.Second)
+
+	body := f.render(t)
+
+	assert.Contains(t, body, statusCell("text-green-600", "204"))
+	assert.Contains(t, body, statusCell("text-gray-500", "302"))
+	assert.Contains(t, body, statusCell("text-yellow-600", "404"))
+	assert.Contains(t, body, statusCell("text-red-600", "503"))
+	assert.Contains(t, body, statusCell("text-red-600", "no response"))
+	assert.Contains(t, body, statusCell("text-gray-400", "pending"))
+	assert.Contains(t, body, statusCell("text-gray-400", "not sent"))
+	assert.Contains(t, body, statusCell("text-green-600", "200"))
+	assert.NotContains(t, body, ">502<")
+}
+
+// TestHandleSourceDetail_NoStatusWithoutSingleHTTPTarget proves the
+// status column is absent when the webhook has no HTTP target or
+// more than one.
+func TestHandleSourceDetail_NoStatusWithoutSingleHTTPTarget(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	cases := map[string][]database.TargetType{
+		"none":    {database.TargetTypeLog},
+		"several": {database.TargetTypeHTTP, database.TargetTypeHTTP},
+	}
+
+	for name, types := range cases {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			f := newRecentEventsFixture(t)
+			event := f.event(t, contentTypeJSON, "{}", time.Now())
+
+			for _, tt := range types {
+				target := seedTarget(t, f.db, f.webhook.ID, tt)
+				f.attempt(t, f.delivery(
+					t, event, target.ID,
+					database.DeliveryStatusDelivered,
+				), 200, time.Second)
+			}
+
+			body := f.render(t)
+
+			assert.Contains(t, body, `title="Body size"`)
+			assert.NotContains(t, body, statusTitle)
+		})
+	}
+}
+
+// TestHandleWebhook_RecordsBodySize proves the receiver records the
+// body's size in bytes, not characters, with the event it stores.
+func TestHandleWebhook_RecordsBodySize(t *testing.T) {
+	t.Parallel()
+
+	f := newRecentEventsFixture(t)
+	seedEntrypoint(t, f.db, f.webhook.ID)
+
+	// Two bytes per character.
+	body := strings.Repeat("é", 1024)
+
+	req := httptest.NewRequestWithContext(
+		context.Background(), http.MethodPost, "/h/x",
+		strings.NewReader(body),
+	)
+
+	rctx := chi.NewRouteContext()
+	rctx.URLParams.Add("uuid", "ep-"+f.webhook.ID)
+
+	req = req.WithContext(context.WithValue(
+		req.Context(), chi.RouteCtxKey, rctx,
+	))
+
+	w := httptest.NewRecorder()
+	f.h.HandleWebhook().ServeHTTP(w, req)
+
+	require.Equal(t, http.StatusOK, w.Code)
+
+	var stored database.Event
+
+	require.NoError(t, f.webhookDB.First(&stored).Error)
+	assert.Equal(t, int64(2048), stored.BodyBytes)
+}
+
+// TestHandleSourceDetail_FailedLoadIsAnError proves that when the
+// list cannot be loaded the page answers with an error, rather than
+// an empty list claiming the webhook has no events.
+func TestHandleSourceDetail_FailedLoadIsAnError(t *testing.T) {
+	t.Parallel()
+
+	f := newRecentEventsFixture(t)
+	target := seedTarget(t, f.db, f.webhook.ID, database.TargetTypeHTTP)
+
+	f.attempt(t, f.delivery(
+		t, f.event(t, contentTypeJSON, "{}", time.Now()), target.ID,
+		database.DeliveryStatusDelivered,
+	), 200, time.Second)
+
+	// The attempts are the list's last query, so its events and
+	// deliveries have already loaded when it fails.
+	require.NoError(t, f.webhookDB.Exec(
+		"DROP TABLE delivery_results",
+	).Error)
+
+	w := serveSourceDetailPage(t, f.h, f.sess, f.webhook.ID)
+
+	assert.Equal(t, http.StatusInternalServerError, w.Code)
+	assert.NotContains(t, w.Body.String(), "No events received yet.")
+}

internal/handlers/source_delete_test.go

@@ -220,7 +220,7 @@ func TestHandleSourceDelete_EvictsArchiveWriter(t *testing.T) {
 	)
 
 	req := postRequest(
-		"/source/"+wh.ID+"/delete",
+		"/hook/"+wh.ID+"/delete",
 		cookies,
 		map[string]string{paramSourceID: wh.ID},
 	)
@@ -267,7 +267,7 @@ func TestHandleSourceDelete_KeepsArchiveFile(t *testing.T) {
 	)
 
 	req := postRequest(
-		"/source/"+wh.ID+"/delete",
+		"/hook/"+wh.ID+"/delete",
 		cookies,
 		map[string]string{paramSourceID: wh.ID},
 	)
@@ -323,7 +323,7 @@ func TestHandleSourceDelete_FailedDeleteKeepsEverything(
 	)
 
 	req := postRequest(
-		"/source/"+wh.ID+"/delete",
+		"/hook/"+wh.ID+"/delete",
 		cookies,
 		map[string]string{paramSourceID: wh.ID},
 	)
@@ -337,7 +337,7 @@ func TestHandleSourceDelete_FailedDeleteKeepsEverything(
 	)
 	assert.Empty(
 		t, w.Header().Get("Location"),
-		"a failed deletion must not redirect to /sources",
+		"a failed deletion must not redirect to /hooks",
 	)
 
 	assert.Equal(
@@ -402,7 +402,7 @@ func TestHandleSourceDelete_RemovesConfigAndEventDatabase(
 	)
 
 	req := postRequest(
-		"/source/"+wh.ID+"/delete",
+		"/hook/"+wh.ID+"/delete",
 		cookies,
 		map[string]string{paramSourceID: wh.ID},
 	)
@@ -411,7 +411,7 @@ func TestHandleSourceDelete_RemovesConfigAndEventDatabase(
 	h.HandleSourceDelete().ServeHTTP(w, req)
 
 	require.Equal(t, http.StatusSeeOther, w.Code)
-	assert.Equal(t, "/sources", w.Header().Get("Location"))
+	assert.Equal(t, "/hooks", w.Header().Get("Location"))
 
 	assert.Equal(
 		t, int64(0),
@@ -465,7 +465,7 @@ func TestHandleTargetDelete_EvictsWhenLastDatabaseTargetGone(
 	)
 
 	req := postRequest(
-		"/source/"+wh.ID+"/targets/"+tgt.ID+"/delete",
+		"/hook/"+wh.ID+"/targets/"+tgt.ID+"/delete",
 		cookies,
 		map[string]string{
 			paramSourceID: wh.ID,
@@ -515,7 +515,7 @@ func TestHandleTargetDelete_KeepsWriterWhenDatabaseTargetRemains(
 	)
 
 	req := postRequest(
-		"/source/"+wh.ID+"/targets/"+doomed.ID+"/delete",
+		"/hook/"+wh.ID+"/targets/"+doomed.ID+"/delete",
 		cookies,
 		map[string]string{
 			paramSourceID: wh.ID,
@@ -563,7 +563,7 @@ func TestHandleTargetDelete_KeepsWriterWhenOtherTypeDeleted(
 	)
 
 	req := postRequest(
-		"/source/"+wh.ID+"/targets/"+other.ID+"/delete",
+		"/hook/"+wh.ID+"/targets/"+other.ID+"/delete",
 		cookies,
 		map[string]string{
 			paramSourceID: wh.ID,

internal/handlers/source_detail_baseurl_test.go

@@ -81,7 +81,7 @@ func (f *baseURLFixture) entrypointURL(
 	req := httptest.NewRequestWithContext(
 		context.Background(),
 		http.MethodGet,
-		"/source/"+f.webhook,
+		"/hook/"+f.webhook,
 		nil,
 	)
 	req.Host = host
@@ -213,7 +213,7 @@ func TestSourceDetailBaseURL_ForwardedProtoSpellings(t *testing.T) {
 
 			assert.Equal(
 				t,
-				tc.scheme+"://"+host+"/webhook/"+fixture.path,
+				tc.scheme+"://"+host+"/h/"+fixture.path,
 				fixture.entrypointURL(
 					t, host, forwardedProto(tc.header),
 				),
@@ -244,7 +244,7 @@ func TestSourceDetailBaseURL_DirectTLSBeatsPlaintextHeader(
 
 	assert.Equal(
 		t,
-		"https://"+host+"/webhook/"+fixture.path,
+		"https://"+host+"/h/"+fixture.path,
 		got,
 		"a connection this process terminated with TLS "+
 			"outranks a header claiming plaintext",
@@ -272,7 +272,7 @@ func TestSourceDetailBaseURL_KeepsHostAuthority(t *testing.T) {
 
 			assert.Equal(
 				t,
-				"https://"+host+"/webhook/"+fixture.path,
+				"https://"+host+"/h/"+fixture.path,
 				fixture.entrypointURL(
 					t, host, forwardedProto("HTTPS"),
 				),

internal/handlers/source_detail_test.go

@@ -62,10 +62,27 @@ func renderSourceDetailPage(
 ) string {
 	t.Helper()
 
+	w := serveSourceDetailPage(t, h, sess, webhookID)
+
+	require.Equal(t, http.StatusOK, w.Code)
+
+	return w.Body.String()
+}
+
+// serveSourceDetailPage runs the real source detail handler for a
+// webhook and returns its response, whatever its status.
+func serveSourceDetailPage(
+	t *testing.T,
+	h *handlers.Handlers,
+	sess *session.Session,
+	webhookID string,
+) *httptest.ResponseRecorder {
+	t.Helper()
+
 	req := httptest.NewRequestWithContext(
 		context.Background(),
 		http.MethodGet,
-		"/source/"+webhookID,
+		"/hook/"+webhookID,
 		nil,
 	)
 
@@ -87,9 +104,7 @@ func renderSourceDetailPage(
 	w := httptest.NewRecorder()
 	h.HandleSourceDetail().ServeHTTP(w, req)
 
-	require.Equal(t, http.StatusOK, w.Code)
-
-	return w.Body.String()
+	return w
 }
 
 // TestHandleSourceDetail_MasksSlackWebhookURL is the

internal/handlers/source_logs_deleted_target_test.go

@@ -28,7 +28,7 @@ func deleteTargetThroughHandler(
 	t.Helper()
 
 	req := postRequest(
-		"/source/"+webhookID+"/targets/"+targetID+"/delete",
+		"/hook/"+webhookID+"/targets/"+targetID+"/delete",
 		authenticatedCookies(
 			t, sess, deleteTestUserID, deleteTestUsername,
 		),

internal/handlers/source_logs_test.go

@@ -84,7 +84,7 @@ func renderSourceLogsPageWithQuery(
 	req := httptest.NewRequestWithContext(
 		context.Background(),
 		http.MethodGet,
-		"/source/"+webhookID+"/logs"+query,
+		"/hook/"+webhookID+"/events"+query,
 		nil,
 	)
 

internal/handlers/source_management.go

@@ -330,7 +330,7 @@ func (h *Handlers) createWebhookWithEntrypoint(
 	)
 
 	http.Redirect(
-		w, r, "/source/"+webhook.ID, http.StatusSeeOther,
+		w, r, "/hook/"+webhook.ID, http.StatusSeeOther,
 	)
 }
 
@@ -415,16 +415,23 @@ func (h *Handlers) renderSourceDetail(
 		"webhook_id = ?", webhook.ID,
 	).Find(&targets)
 
-	var events []database.Event
+	var events []RecentEventView
 
 	if h.dbMgr.DBExists(webhook.ID) {
-		webhookDB, dbErr := h.dbMgr.GetDB(webhook.ID)
-		if dbErr == nil {
-			webhookDB.Where(
-				"webhook_id = ?", webhook.ID,
-			).Order("created_at DESC").Limit(
-				recentEventLimit,
-			).Find(&events)
+		webhookDB, err := h.dbMgr.GetDB(webhook.ID)
+		if err != nil {
+			h.serverError(w, "failed to get webhook database", err)
+
+			return
+		}
+
+		events, err = loadRecentEvents(
+			webhookDB, webhook.ID, singleHTTPTargetID(targets),
+		)
+		if err != nil {
+			h.serverError(w, "failed to load recent events", err)
+
+			return
 		}
 	}
 
@@ -450,6 +457,7 @@ func (h *Handlers) renderSourceDetail(
 		"Targets":     delivery.NewTargetViews(targets),
 		"Events":      events,
 		"BaseURL":     baseURL,
+		"Stats":       h.loadWebhookStats(webhook.ID, entrypoints, targets),
 	}
 
 	h.renderTemplate(w, r, "source_detail.html", data)
@@ -581,7 +589,7 @@ func (h *Handlers) applyWebhookEdit(
 	}
 
 	http.Redirect(
-		w, r, "/source/"+webhook.ID, http.StatusSeeOther,
+		w, r, "/hook/"+webhook.ID, http.StatusSeeOther,
 	)
 }
 
@@ -664,7 +672,7 @@ func (h *Handlers) deleteWebhookResources(
 		return
 	}
 
-	http.Redirect(w, r, "/sources", http.StatusSeeOther)
+	http.Redirect(w, r, "/hooks", http.StatusSeeOther)
 }
 
 // commitWebhookDeletion soft-deletes a webhook's entrypoints,
@@ -1257,7 +1265,7 @@ func (h *Handlers) HandleEntrypointCreate() http.HandlerFunc {
 		}
 
 		http.Redirect(
-			w, r, "/source/"+webhook.ID, http.StatusSeeOther,
+			w, r, "/hook/"+webhook.ID, http.StatusSeeOther,
 		)
 	}
 }
@@ -1313,7 +1321,7 @@ func (h *Handlers) processTargetCreate(
 	//
 	// Every field here is read with PostFormValue, not FormValue.
 	// FormValue falls back to the query string, which would let
-	// `POST /source/{id}/targets?url=https://hooks.slack.com/...`
+	// `POST /hook/{id}/targets?url=https://hooks.slack.com/...`
 	// configure a target from a value the request line carries — and
 	// the request line, unlike the body, is what logs, proxies,
 	// Referer headers and error trackers record.
@@ -1370,7 +1378,7 @@ func (h *Handlers) processTargetCreate(
 	}
 
 	http.Redirect(
-		w, r, "/source/"+webhook.ID, http.StatusSeeOther,
+		w, r, "/hook/"+webhook.ID, http.StatusSeeOther,
 	)
 }
 
@@ -1428,7 +1436,7 @@ type targetFormInput struct {
 //
 // Every field is read with PostFormValue, not FormValue. FormValue
 // falls back to the query string, which would let
-// `POST /source/{id}/targets?url=https://hooks.slack.com/...`
+// `POST /hook/{id}/targets?url=https://hooks.slack.com/...`
 // configure a target from a value the request line carries — and the
 // request line, unlike the body, is what logs, proxies, Referer
 // headers and error trackers record. The headers field is under the
@@ -1570,11 +1578,22 @@ func (h *Handlers) validateTargetURL(
 			"url", delivery.MaskURL(targetURL),
 			"error", err,
 		)
-		http.Error(
-			w,
-			"Invalid target URL: "+err.Error(),
-			http.StatusBadRequest,
-		)
+
+		msg := "Invalid target URL: " + err.Error()
+
+		// Only a private or reserved address's refusal says how
+		// to allow it. Metadata refusals never do: link-local and
+		// the other unconditional metadata addresses cannot be
+		// opened, and the default blocklist's public addresses,
+		// which listing does open, hand out credentials.
+		if errors.Is(err, delivery.ErrBlockedPrivateOrReservedIP) {
+			msg += ". Private and reserved addresses are refused " +
+				"by default; the server's ALLOWED_EGRESS_CIDRS " +
+				"setting allows named networks (see \"Allowing " +
+				"egress to your own network\" in the README)."
+		}
+
+		http.Error(w, msg, http.StatusBadRequest)
 
 		return err
 	}
@@ -1707,7 +1726,7 @@ func (h *Handlers) deleteChildResource(
 
 		http.Redirect(
 			w, r,
-			"/source/"+webhook.ID,
+			"/hook/"+webhook.ID,
 			http.StatusSeeOther,
 		)
 	}
@@ -1804,7 +1823,7 @@ func (h *Handlers) toggleChildResource(
 
 		http.Redirect(
 			w, r,
-			"/source/"+webhook.ID,
+			"/hook/"+webhook.ID,
 			http.StatusSeeOther,
 		)
 	}

internal/handlers/source_management_test.go

@@ -105,7 +105,7 @@ func submitCreate(
 		form.Set("retention_days", *retention)
 	}
 
-	req := formRequest("/sources/new", cookies, form, nil)
+	req := formRequest("/hooks/new", cookies, form, nil)
 	w := httptest.NewRecorder()
 
 	h.HandleSourceCreateSubmit().ServeHTTP(w, req)
@@ -265,7 +265,7 @@ func TestHandleSourceCreate_PrefillsDefaultFromConstant(t *testing.T) {
 
 	w := httptest.NewRecorder()
 	env.handlers.HandleSourceCreate().ServeHTTP(
-		w, getRequest(t, "/sources/new", env.cookies, nil),
+		w, getRequest(t, "/hooks/new", env.cookies, nil),
 	)
 
 	require.Equal(t, http.StatusOK, w.Code)
@@ -402,7 +402,7 @@ func TestHandleSourceCreateSubmit_RejectedFormKeepsUserInput(
 	form.Set("description", description)
 	form.Set("retention_days", "nonsense")
 
-	req := formRequest("/sources/new", env.cookies, form, nil)
+	req := formRequest("/hooks/new", env.cookies, form, nil)
 	w := httptest.NewRecorder()
 
 	env.handlers.HandleSourceCreateSubmit().ServeHTTP(w, req)
@@ -430,7 +430,7 @@ func submitEdit(
 	form.Set("retention_days", retention)
 
 	req := formRequest(
-		"/source/"+wh.ID+"/edit",
+		"/hook/"+wh.ID+"/edit",
 		env.cookies,
 		form,
 		map[string]string{sourceIDParam: wh.ID},
@@ -512,7 +512,7 @@ func TestSourceEditForm_ForeverWebhookRoundTrips(t *testing.T) {
 	)
 
 	req := getRequest(
-		t, "/source/"+wh.ID+"/edit", env.cookies,
+		t, "/hook/"+wh.ID+"/edit", env.cookies,
 		map[string]string{sourceIDParam: wh.ID},
 	)
 	w := httptest.NewRecorder()
@@ -567,7 +567,7 @@ func TestSourceListAndDetail_ShowForeverNotTheSentinelNumber(
 
 	listW := httptest.NewRecorder()
 	env.handlers.HandleSourceList().ServeHTTP(
-		listW, getRequest(t, "/sources", env.cookies, nil),
+		listW, getRequest(t, "/hooks", env.cookies, nil),
 	)
 
 	require.Equal(t, http.StatusOK, listW.Code)
@@ -578,7 +578,7 @@ func TestSourceListAndDetail_ShowForeverNotTheSentinelNumber(
 	env.handlers.HandleSourceDetail().ServeHTTP(
 		detailW,
 		getRequest(
-			t, "/source/"+wh.ID, env.cookies,
+			t, "/hook/"+wh.ID, env.cookies,
 			map[string]string{sourceIDParam: wh.ID},
 		),
 	)

internal/handlers/target_create_query_test.go

@@ -76,11 +76,11 @@ func postTargetCreate(
 	router := chi.NewRouter()
 	router.Use(mw.Logging())
 	router.Post(
-		"/source/{sourceID}/targets",
+		"/hook/{sourceID}/targets",
 		env.handlers.HandleTargetCreate(),
 	)
 
-	target := "/source/" + webhookID + "/targets"
+	target := "/hook/" + webhookID + "/targets"
 	if query != "" {
 		target += "?" + query
 	}
@@ -114,7 +114,7 @@ func postTargetCreate(
 // regression test for the ingress leak. r.FormValue falls back to the
 // query string when a field is absent from the POST body, so
 //
-//	POST /source/{id}/targets?url=https://hooks.slack.com/services/...
+//	POST /hook/{id}/targets?url=https://hooks.slack.com/services/...
 //
 // with an empty url field used to create a working target from a value
 // carried on the request line — where logs, proxies, Referer headers

internal/handlers/target_edit.go

@@ -47,7 +47,7 @@ type targetEditView struct {
 //
 // This page is the one place the full destination URL and header
 // values are shown. It is reachable only through the
-// /source/{sourceID} route group, which supplies RequireAuth and
+// /hook/{sourceID} route group, which supplies RequireAuth and
 // NoCache, and only for a target of a webhook the session's user
 // owns; masking (delivery.TargetView) is unchanged everywhere else.
 func (h *Handlers) HandleTargetEdit() http.HandlerFunc {
@@ -163,7 +163,7 @@ func (h *Handlers) applyTargetEdit(
 	}
 
 	http.Redirect(
-		w, r, "/source/"+webhook.ID, http.StatusSeeOther,
+		w, r, "/hook/"+webhook.ID, http.StatusSeeOther,
 	)
 }
 

internal/handlers/target_edit_test.go

@@ -42,15 +42,15 @@ const (
 func targetRouter(env *sourceTestEnv) *chi.Mux {
 	router := chi.NewRouter()
 	router.Post(
-		"/source/{sourceID}/targets",
+		"/hook/{sourceID}/targets",
 		env.handlers.HandleTargetCreate(),
 	)
 	router.Get(
-		"/source/{sourceID}/targets/{targetID}/edit",
+		"/hook/{sourceID}/targets/{targetID}/edit",
 		env.handlers.HandleTargetEdit(),
 	)
 	router.Post(
-		"/source/{sourceID}/targets/{targetID}/edit",
+		"/hook/{sourceID}/targets/{targetID}/edit",
 		env.handlers.HandleTargetEditSubmit(),
 	)
 
@@ -117,7 +117,7 @@ func seedHTTPTarget(
 
 	w := serveTarget(
 		env, http.MethodPost,
-		"/source/"+webhook.ID+"/targets", form,
+		"/hook/"+webhook.ID+"/targets", form,
 	)
 	require.Equal(t, http.StatusSeeOther, w.Code, w.Body.String())
 
@@ -188,7 +188,7 @@ func submitTargetEdit(
 ) *httptest.ResponseRecorder {
 	return serveTarget(
 		env, http.MethodPost,
-		"/source/"+webhookID+"/targets/"+targetID+"/edit",
+		"/hook/"+webhookID+"/targets/"+targetID+"/edit",
 		form,
 	)
 }
@@ -401,7 +401,7 @@ func TestHandleTargetEdit_PrefillsTheStoredValuesUnmasked(
 
 	w := serveTarget(
 		env, http.MethodGet,
-		"/source/"+webhook.ID+"/targets/"+target.ID+"/edit",
+		"/hook/"+webhook.ID+"/targets/"+target.ID+"/edit",
 		nil,
 	)
 	require.Equal(t, http.StatusOK, w.Code)
@@ -508,7 +508,7 @@ func assertEditIgnoresQueryString(
 
 	w := serveTarget(
 		env, http.MethodPost,
-		"/source/"+webhook.ID+"/targets/"+target.ID+
+		"/hook/"+webhook.ID+"/targets/"+target.ID+
 			"/edit?url="+url.QueryEscape(editReplacedURL)+
 			"&headers="+url.QueryEscape(editAuthHeader),
 		form,
@@ -592,7 +592,7 @@ func assertTargetOfAnotherWebhook404s(
 
 	get := serveTarget(
 		env, http.MethodGet,
-		"/source/"+mine.ID+"/targets/"+target.ID+"/edit", nil,
+		"/hook/"+mine.ID+"/targets/"+target.ID+"/edit", nil,
 	)
 	assert.Equal(t, http.StatusNotFound, get.Code)
 
@@ -630,7 +630,7 @@ func assertWebhookOfAnotherUser404s(
 
 	w := serveTarget(
 		env, http.MethodGet,
-		"/source/"+other.ID+"/targets/"+target.ID+"/edit", nil,
+		"/hook/"+other.ID+"/targets/"+target.ID+"/edit", nil,
 	)
 
 	assert.Equal(t, http.StatusNotFound, w.Code)

internal/handlers/target_private_refusal_test.go

@@ -0,0 +1,116 @@
+package handlers_test
+
+import (
+	"net/http"
+	"net/url"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// privateRefusalHint is the sentence that tells an operator a private
+// destination is refused on purpose, and how to allow one.
+const privateRefusalHint = "Private and reserved addresses are " +
+	"refused by default; the server's ALLOWED_EGRESS_CIDRS setting " +
+	"allows named networks (see \"Allowing egress to your own " +
+	"network\" in the README)."
+
+// TestTargetRefusal_PrivateDestinationSaysHowToAllowIt covers both
+// target types that take a URL, on add and on edit.
+func TestTargetRefusal_PrivateDestinationSaysHowToAllowIt(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+
+	targetTypes := []database.TargetType{
+		database.TargetTypeHTTP,
+		database.TargetTypeSlack,
+	}
+
+	for _, targetType := range targetTypes {
+		t.Run(string(targetType), func(t *testing.T) {
+			t.Parallel()
+
+			webhook := seedWebhookWithRetention(t, env.db, 30)
+			targetsPath := "/hook/" + webhook.ID + "/targets"
+
+			form := url.Values{}
+			form.Set("name", "private")
+			form.Set("type", string(targetType))
+			form.Set("url", editBlockedURL)
+
+			added := serveTarget(
+				env, http.MethodPost, targetsPath, form,
+			)
+			assert.Equal(t, http.StatusBadRequest, added.Code)
+			assert.Contains(
+				t, added.Body.String(), privateRefusalHint,
+			)
+
+			form.Set("url", editOriginalURL)
+
+			created := serveTarget(
+				env, http.MethodPost, targetsPath, form,
+			)
+			require.Equal(
+				t, http.StatusSeeOther, created.Code,
+				created.Body.String(),
+			)
+
+			targets := targetsForWebhook(t, env.db, webhook.ID)
+			require.Len(t, targets, 1)
+
+			form.Set("url", editBlockedURL)
+
+			edited := submitTargetEdit(
+				env, webhook.ID, targets[0].ID, form,
+			)
+			assert.Equal(t, http.StatusBadRequest, edited.Code)
+			assert.Contains(
+				t, edited.Body.String(), privateRefusalHint,
+			)
+		})
+	}
+}
+
+// TestTargetRefusal_MetadataDestinationDoesNotSayHowToAllowIt: no
+// setting opens a link-local address, and Azure's WireServer hands out
+// VM credentials, so neither refusal points at the setting.
+func TestTargetRefusal_MetadataDestinationDoesNotSayHowToAllowIt(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	env := setupSourceTest(t)
+
+	metadataURLs := map[string]string{
+		"link-local": "http://169.254.169.254/latest/meta-data/",
+		"wireserver": "http://168.63.129.16/?comp=versions",
+	}
+
+	for name, metadataURL := range metadataURLs {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			webhook := seedWebhookWithRetention(t, env.db, 30)
+
+			form := url.Values{}
+			form.Set("name", "metadata")
+			form.Set("type", string(database.TargetTypeHTTP))
+			form.Set("url", metadataURL)
+
+			w := serveTarget(
+				env, http.MethodPost,
+				"/hook/"+webhook.ID+"/targets", form,
+			)
+			assert.Equal(t, http.StatusBadRequest, w.Code)
+			assert.NotContains(
+				t, w.Body.String(), privateRefusalHint,
+			)
+		})
+	}
+}

internal/handlers/target_retries_test.go

@@ -102,7 +102,7 @@ func createWithRetries(
 
 	w := serveTarget(
 		env, http.MethodPost,
-		"/source/"+webhook.ID+"/targets",
+		"/hook/"+webhook.ID+"/targets",
 		createRetriesForm(retries),
 	)
 

internal/handlers/ui_copy_test.go

@@ -54,8 +54,7 @@ func renderPage(
 }
 
 // TestNavbarUsesWebhookTerminology pins the user-visible navigation
-// label to "Webhooks". The /sources route is deliberately unchanged, so
-// the assertion targets the link text rather than the href.
+// label to "Webhooks" and its link to the webhook list at /hooks.
 func TestNavbarUsesWebhookTerminology(t *testing.T) {
 	t.Parallel()
 
@@ -95,15 +94,11 @@ func TestNavbarUsesWebhookTerminology(t *testing.T) {
 		t, body, ">Sources<",
 		"no user-visible element may still be labelled Sources",
 	)
-	assert.Contains(
-		t, body, `href="/sources"`,
-		"the /sources route itself must not change",
-	)
+	assert.Contains(t, body, `href="/hooks"`)
 }
 
 // TestEditPageUsesWebhookTerminology pins the edit page's heading and
-// its back link. The link's href still points at /source/{id}, which is
-// intentional: only user-visible copy changes.
+// its back link to the webhook page at /hook/{id}.
 func TestEditPageUsesWebhookTerminology(t *testing.T) {
 	t.Parallel()
 
@@ -130,7 +125,57 @@ func TestEditPageUsesWebhookTerminology(t *testing.T) {
 
 	assert.Contains(t, body, "Edit Webhook")
 	assert.NotContains(t, body, ">Sources<")
-	assert.Contains(t, body, `href="/source/wh-1"`)
+	assert.Contains(t, body, `href="/hook/wh-1"`)
+}
+
+// TestEventLogPageIsCalledFullEventLog pins the one name the event log
+// page at /hook/{id}/events goes by: both links to it on the webhook
+// page, and its own heading, read "Full Event Log".
+func TestEventLogPageIsCalledFullEventLog(t *testing.T) {
+	t.Parallel()
+
+	var h *handlers.Handlers
+
+	var sess *session.Session
+
+	app := newTestApp(t, &h, &sess)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	// A pointer, as in the handlers: source_detail.html calls
+	// Webhook.RetentionLabel, a pointer method. Both pages only range
+	// over their lists, and a list left out renders as empty, so the
+	// lists are left out.
+	webhook := &database.Webhook{Name: "wh", RetentionDays: 14}
+	webhook.ID = testWebhookID
+
+	detailBody := renderPage(
+		t, h, sess, "source_detail.html", map[string]any{
+			dataKeyWebhook: webhook,
+		},
+	)
+
+	assert.Contains(
+		t, detailBody,
+		`<a href="/hook/wh-1/events" class="btn-secondary">Full Event Log</a>`,
+		"the button at the top of the webhook page",
+	)
+	assert.Contains(
+		t, detailBody,
+		`<a href="/hook/wh-1/events" class="btn-text text-sm">Full Event Log</a>`,
+		"the link under recent events",
+	)
+
+	logBody := renderPage(t, h, sess, "source_logs.html", map[string]any{
+		dataKeyWebhook: webhook,
+		"TotalEvents":  int64(0),
+	})
+
+	assert.Contains(
+		t, logBody,
+		`<h1 class="text-2xl font-medium text-gray-900">Full Event Log</h1>`,
+	)
 }
 
 // TestCreateFormRetentionCopyMatchesBehaviour pins the create form's
@@ -283,7 +328,7 @@ func TestEntrypointCopyButtonIsProgressiveEnhancement(t *testing.T) {
 		t, body,
 		`<code id="entrypoint-url-ep-1"`,
 	)
-	assert.Contains(t, body, "https://hooks.example.com/webhook/abc123")
+	assert.Contains(t, body, "https://hooks.example.com/h/abc123")
 	assert.Contains(
 		t, body,
 		`hidden data-copy-target="entrypoint-url-ep-1"`,

internal/handlers/webhook.go

@@ -131,7 +131,7 @@ func (h *Handlers) lookupEntrypoint(
 		"path = ?", entrypointUUID,
 	).First(&entrypoint)
 	if result.Error != nil {
-		// The receiver is unauthenticated and /webhook/{uuid}
+		// The receiver is unauthenticated and /h/{uuid}
 		// matches any single segment, so this value is entirely
 		// client-chosen on exactly the branch where the lookup
 		// failed. DEBUG is off by default; the cap is what keeps
@@ -230,6 +230,7 @@ func (s eventSource) event() *database.Event {
 		Method:            s.Method,
 		Headers:           s.HeadersJSON,
 		Body:              string(s.Body),
+		BodyBytes:         int64(len(s.Body)),
 		ContentType:       s.ContentType,
 		ResubmittedFromID: s.ResubmittedFromID,
 	}
@@ -252,11 +253,12 @@ func requestEventSource(
 	}
 }
 
-// createAndFanOut writes the event and one pending delivery per target
-// in a single transaction, then hands the tasks to the delivery
-// engine. It is the only path by which an event and its deliveries are
-// created, so a resubmitted event is retried, SSRF-guarded and
-// circuit-broken exactly as a received one is.
+// createAndFanOut writes the event and one pending delivery per target,
+// and adds them to the webhook's running totals, in a single
+// transaction, then hands the tasks to the delivery engine. It is the
+// only path by which an event and its deliveries are created, so a
+// resubmitted event is retried, SSRF-guarded and circuit-broken
+// exactly as a received one is.
 //
 // The tasks are returned as well as queued, so a caller can report how
 // many targets the event went to.
@@ -296,6 +298,15 @@ func (h *Handlers) createAndFanOut(
 		return nil, nil, err
 	}
 
+	err = database.AddEventTotals(tx, database.EventTotals{
+		Events: 1, LastEventAt: &event.CreatedAt,
+	})
+	if err != nil {
+		tx.Rollback()
+
+		return nil, nil, err
+	}
+
 	err = tx.Commit().Error
 	if err != nil {
 		return nil, nil, fmt.Errorf(
@@ -354,8 +365,9 @@ func (h *Handlers) finishWebhookResponse(
 }
 
 // buildDeliveryTasks creates one pending delivery per target in the
-// transaction and returns the tasks for the delivery engine. The
-// caller owns the transaction and rolls it back on error.
+// transaction, adds each to its target's totals, and returns the tasks
+// for the delivery engine. The caller owns the transaction and rolls
+// it back on error.
 func buildDeliveryTasks(
 	tx *gorm.DB,
 	event *database.Event,
@@ -379,6 +391,13 @@ func buildDeliveryTasks(
 			)
 		}
 
+		err = database.AddTargetTotals(tx, database.TargetTotals{
+			TargetID: targets[i].ID, Deliveries: 1,
+		})
+		if err != nil {
+			return nil, err
+		}
+
 		tasks = append(tasks, delivery.Task{
 			DeliveryID:   dlv.ID,
 			EventID:      event.ID,

internal/handlers/webhook_stats.go

@@ -0,0 +1,259 @@
+package handlers
+
+import (
+	"fmt"
+	"time"
+
+	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// The spans of the two recent windows the statistics pane reports on:
+// the last 10 minutes and the last 24 hours.
+const (
+	shortWindow = 10 * time.Minute
+	longWindow  = 24 * time.Hour
+)
+
+// percent turns a fraction into a percentage.
+const percent = 100
+
+// WebhookStats holds the figures in the statistics pane at the top of
+// the webhook page.
+type WebhookStats struct {
+	Entrypoints       int
+	ActiveEntrypoints int
+	Targets           int
+	ActiveTargets     int
+
+	// Lifetime counts every event, delivery and failure the webhook
+	// has had, and WithinRetention those still stored.
+	Lifetime        Counts
+	WithinRetention Counts
+
+	// InProgress counts the deliveries still pending or retrying.
+	InProgress int64
+
+	// LastEventAt is when the newest event arrived, or nil when none
+	// has. Retention does not change it.
+	LastEventAt *time.Time
+
+	Last10Minutes RecentWindow
+	Last24Hours   RecentWindow
+}
+
+// Counts holds a number of events, of deliveries and of failed
+// deliveries.
+type Counts struct {
+	Events     int64
+	Deliveries int64
+	Failures   int64
+}
+
+// RecentWindow holds what happened in one recent window: the events
+// received in it, and the deliveries that became delivered or failed in
+// it.
+type RecentWindow struct {
+	Events    int64
+	Delivered int64
+	Failed    int64
+}
+
+// TargetFinished is how many of one target's deliveries became
+// delivered, and how many failed, in a recent window.
+type TargetFinished struct {
+	TargetID  string
+	Delivered int64
+	Failed    int64
+}
+
+// FailurePercent is the share of the deliveries finished in the window
+// that failed, or a dash when none finished. Deliveries still pending
+// or retrying are not counted either way.
+func (w RecentWindow) FailurePercent() string {
+	finished := w.Delivered + w.Failed
+	if finished == 0 {
+		return "—"
+	}
+
+	return fmt.Sprintf(
+		"%.1f%%", percent*float64(w.Failed)/float64(finished),
+	)
+}
+
+// loadWebhookStats gathers the figures for the statistics pane from the
+// webhook's entrypoints and targets, as the page has already loaded
+// them, and from its event database. It returns nil, and logs why, when
+// the event database cannot be read.
+func (h *Handlers) loadWebhookStats(
+	webhookID string,
+	entrypoints []database.Entrypoint,
+	targets []database.Target,
+) *WebhookStats {
+	stats := &WebhookStats{
+		Entrypoints: len(entrypoints),
+		Targets:     len(targets),
+	}
+
+	for i := range entrypoints {
+		if entrypoints[i].Active {
+			stats.ActiveEntrypoints++
+		}
+	}
+
+	for i := range targets {
+		if targets[i].Active {
+			stats.ActiveTargets++
+		}
+	}
+
+	// Opening an event database that does not exist would create it,
+	// and it would hold nothing to count.
+	if !h.dbMgr.DBExists(webhookID) {
+		return stats
+	}
+
+	webhookDB, err := h.dbMgr.GetDB(webhookID)
+	if err == nil {
+		err = readEventStats(webhookDB, time.Now(), stats)
+	}
+
+	if err != nil {
+		h.log.Error(
+			"failed to read webhook statistics",
+			"webhook_id", webhookID,
+			"error", err,
+		)
+
+		return nil
+	}
+
+	return stats
+}
+
+// readEventStats fills in the figures that come from the webhook's
+// event database. None of them reads every stored row: the totals are
+// one row for the events and one per target for the deliveries, and
+// every other figure is read from an index, over only the rows it
+// counts.
+func readEventStats(
+	db *gorm.DB, now time.Time, stats *WebhookStats,
+) error {
+	err := readTotals(db, stats)
+	if err != nil {
+		return err
+	}
+
+	err = db.Model(&database.Delivery{}).
+		Where("status IN ?", []database.DeliveryStatus{
+			database.DeliveryStatusPending,
+			database.DeliveryStatusRetrying,
+		}).
+		Count(&stats.InProgress).Error
+	if err != nil {
+		return fmt.Errorf("counting deliveries in progress: %w", err)
+	}
+
+	stats.Last10Minutes, err = readRecentWindow(
+		db, now.Add(-shortWindow),
+	)
+	if err != nil {
+		return err
+	}
+
+	stats.Last24Hours, err = readRecentWindow(
+		db, now.Add(-longWindow),
+	)
+
+	return err
+}
+
+// readTotals fills in the lifetime and within-retention figures, and
+// when the last event arrived, from the running totals: the events'
+// row, and the targets' rows summed.
+func readTotals(db *gorm.DB, stats *WebhookStats) error {
+	var events database.EventTotals
+
+	err := db.Take(&events).Error
+	if err != nil {
+		return fmt.Errorf("reading event totals: %w", err)
+	}
+
+	var targets []database.TargetTotals
+
+	err = db.Find(&targets).Error
+	if err != nil {
+		return fmt.Errorf("reading target totals: %w", err)
+	}
+
+	stats.Lifetime.Events = events.Events
+	stats.WithinRetention.Events = events.Events - events.EventsRemoved
+	stats.LastEventAt = events.LastEventAt
+
+	for _, t := range targets {
+		stats.Lifetime.Deliveries += t.Deliveries
+		stats.Lifetime.Failures += t.Failed
+		stats.WithinRetention.Deliveries += t.Deliveries - t.DeliveriesRemoved
+		stats.WithinRetention.Failures += t.Failed - t.FailedRemoved
+	}
+
+	return nil
+}
+
+// readRecentWindow counts the events received, and the deliveries that
+// became delivered or failed, since the given time.
+func readRecentWindow(
+	db *gorm.DB, since time.Time,
+) (RecentWindow, error) {
+	var w RecentWindow
+
+	err := db.Model(&database.Event{}).
+		Where("created_at >= ?", since).
+		Count(&w.Events).Error
+	if err != nil {
+		return w, fmt.Errorf("counting recent events: %w", err)
+	}
+
+	byTarget, err := finishedByTarget(db, since)
+	if err != nil {
+		return w, err
+	}
+
+	for _, f := range byTarget {
+		w.Delivered += f.Delivered
+		w.Failed += f.Failed
+	}
+
+	return w, nil
+}
+
+// finishedByTarget counts, for each target, the deliveries that became
+// delivered and those that failed since the given time, in one query
+// over just that window of the deliveries' status index. A target with
+// neither is left out.
+func finishedByTarget(
+	db *gorm.DB, since time.Time,
+) ([]TargetFinished, error) {
+	var byTarget []TargetFinished
+
+	err := db.Model(&database.Delivery{}).
+		Select("target_id, "+
+			"count(CASE WHEN status = ? THEN 1 END) AS delivered, "+
+			"count(CASE WHEN status = ? THEN 1 END) AS failed",
+			database.DeliveryStatusDelivered,
+			database.DeliveryStatusFailed).
+		Where("status IN ? AND finished_at >= ?",
+			[]database.DeliveryStatus{
+				database.DeliveryStatusDelivered,
+				database.DeliveryStatusFailed,
+			}, since).
+		Group("target_id").
+		Find(&byTarget).Error
+	if err != nil {
+		return nil, fmt.Errorf(
+			"counting deliveries finished by target: %w", err,
+		)
+	}
+
+	return byTarget, nil
+}

internal/handlers/webhook_stats_test.go

@@ -0,0 +1,569 @@
+package handlers_test
+
+import (
+	"net/http"
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/fx/fxtest"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"sneak.berlin/go/webhooker/internal/config"
+	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/handlers"
+	"sneak.berlin/go/webhooker/internal/logger"
+	"sneak.berlin/go/webhooker/internal/session"
+)
+
+// statsEntrypoint adds an entrypoint to a webhook and returns its path.
+func statsEntrypoint(
+	t *testing.T, db *database.Database, webhookID string, active bool,
+) string {
+	t.Helper()
+
+	ep := &database.Entrypoint{
+		WebhookID: webhookID,
+		Path:      uuid.New().String(),
+	}
+
+	require.NoError(t, db.DB().Omit(clause.Associations).Create(ep).Error)
+	require.NoError(t, db.DB().Model(ep).Update("active", active).Error)
+
+	return ep.Path
+}
+
+// statsDelivery returns an event's delivery to a target.
+func statsDelivery(
+	t *testing.T, webhookDB *gorm.DB, eventID, targetID string,
+) database.Delivery {
+	t.Helper()
+
+	var d database.Delivery
+
+	require.NoError(t, webhookDB.Where(
+		"event_id = ? AND target_id = ?", eventID, targetID,
+	).First(&d).Error)
+
+	return d
+}
+
+// statsFinish settles a delivery as the delivery engine does: its
+// final status and the time it finished, and one more on its target's
+// delivered or failed total, in one transaction.
+func statsFinish(
+	t *testing.T,
+	webhookDB *gorm.DB,
+	d database.Delivery,
+	status database.DeliveryStatus,
+	at time.Time,
+) {
+	t.Helper()
+
+	add := database.TargetTotals{TargetID: d.TargetID, Delivered: 1}
+	if status == database.DeliveryStatusFailed {
+		add = database.TargetTotals{TargetID: d.TargetID, Failed: 1}
+	}
+
+	require.NoError(t, webhookDB.Transaction(func(tx *gorm.DB) error {
+		err := tx.Model(&database.Delivery{}).
+			Where("id = ?", d.ID).
+			Updates(map[string]any{"status": status, "finished_at": at}).
+			Error
+		if err != nil {
+			return err
+		}
+
+		return database.AddTargetTotals(tx, add)
+	}))
+}
+
+// statsAge moves an event's arrival back to the given time.
+func statsAge(
+	t *testing.T, webhookDB *gorm.DB, eventID string, at time.Time,
+) {
+	t.Helper()
+
+	require.NoError(t, webhookDB.Model(&database.Event{}).
+		Where("id = ?", eventID).
+		Update("created_at", at).Error)
+}
+
+// statsTargetTotals reads a webhook database's target totals, keyed by
+// target.
+func statsTargetTotals(
+	t *testing.T, webhookDB *gorm.DB,
+) map[string]database.TargetTotals {
+	t.Helper()
+
+	var rows []database.TargetTotals
+
+	require.NoError(t, webhookDB.Find(&rows).Error)
+
+	byTarget := make(map[string]database.TargetTotals, len(rows))
+	for _, row := range rows {
+		byTarget[row.TargetID] = row
+	}
+
+	return byTarget
+}
+
+// statsHistory is the webhook seedStatsHistory builds: its event
+// database, its newest event, and its two active targets.
+type statsHistory struct {
+	webhook       *database.Webhook
+	webhookDB     *gorm.DB
+	newest        database.Event
+	first, second string
+}
+
+// seedStatsHistory builds the webhook the statistics test checks: 14
+// days of retention, twelve entrypoints (one inactive) and six targets
+// (four inactive). Ten events arrive through the receiver, and so each
+// has a delivery to the two active targets. The oldest event is past
+// retention, the next 30 hours old, the next six hours old, the other
+// seven just in. Six deliveries are settled as the delivery engine
+// would, two of them inside a recent window though their event arrived
+// before it. The newest event's delivery to the second target is
+// retrying, the rest are left pending, and a replay adds a pending
+// delivery to the oldest event. Once retention has removed the oldest
+// event, every figure in the pane differs from every other.
+func seedStatsHistory(
+	t *testing.T,
+	h *handlers.Handlers,
+	sess *session.Session,
+	db *database.Database,
+	dbMgr *database.WebhookDBManager,
+) statsHistory {
+	t.Helper()
+
+	wh := &database.Webhook{UserID: deleteTestUserID, Name: "stats", RetentionDays: 14}
+	require.NoError(t, db.DB().Omit(clause.Associations).Create(wh).Error)
+
+	path := statsEntrypoint(t, db, wh.ID, true)
+	for range 10 {
+		statsEntrypoint(t, db, wh.ID, true)
+	}
+
+	statsEntrypoint(t, db, wh.ID, false)
+
+	first := seedConfiguredTarget(
+		t, db, wh.ID, database.TargetTypeHTTP,
+		`{"url":"`+replayTargetURL+`"}`,
+	)
+	second := seedTarget(t, db, wh.ID, database.TargetTypeLog)
+
+	for range 4 {
+		inactive := seedTarget(t, db, wh.ID, database.TargetTypeLog)
+		require.NoError(t, db.DB().Model(inactive).
+			Update("active", false).Error)
+	}
+
+	router := receiverRouter(h)
+
+	for range 10 {
+		require.Equal(t, http.StatusOK, postReceiver(t, router, path))
+	}
+
+	webhookDB, err := dbMgr.GetDB(wh.ID)
+	require.NoError(t, err)
+
+	events := listEvents(t, webhookDB)
+	require.Len(t, events, 10)
+
+	oldest, yesterday, middle, newest := events[0], events[1], events[2], events[9]
+	now := time.Now()
+
+	statsAge(t, webhookDB, oldest.ID, now.Add(-15*24*time.Hour))
+	statsAge(t, webhookDB, yesterday.ID, now.Add(-30*time.Hour))
+	statsAge(t, webhookDB, middle.ID, now.Add(-6*time.Hour))
+
+	oldestFailure := statsDelivery(t, webhookDB, oldest.ID, first.ID)
+	statsFinish(t, webhookDB, oldestFailure,
+		database.DeliveryStatusFailed, now.Add(-14*24*time.Hour))
+	statsFinish(t, webhookDB,
+		statsDelivery(t, webhookDB, yesterday.ID, first.ID),
+		database.DeliveryStatusFailed, now.Add(-29*time.Hour))
+	statsFinish(t, webhookDB,
+		statsDelivery(t, webhookDB, yesterday.ID, second.ID),
+		database.DeliveryStatusFailed, now.Add(-23*time.Hour))
+	statsFinish(t, webhookDB,
+		statsDelivery(t, webhookDB, middle.ID, second.ID),
+		database.DeliveryStatusFailed, now.Add(-5*time.Hour))
+	statsFinish(t, webhookDB,
+		statsDelivery(t, webhookDB, middle.ID, first.ID),
+		database.DeliveryStatusFailed, now.Add(-time.Minute))
+	statsFinish(t, webhookDB,
+		statsDelivery(t, webhookDB, newest.ID, first.ID),
+		database.DeliveryStatusDelivered, now.Add(-2*time.Minute))
+
+	retrying := statsDelivery(t, webhookDB, newest.ID, second.ID)
+	require.NoError(t, webhookDB.Model(&retrying).
+		Update("status", database.DeliveryStatusRetrying).Error)
+
+	require.Equal(t, http.StatusSeeOther,
+		postReplay(t, h, sess, wh.ID, oldestFailure.ID).Code)
+
+	return statsHistory{
+		webhook: wh, webhookDB: webhookDB, newest: newest,
+		first: first.ID, second: second.ID,
+	}
+}
+
+// statsPrune runs the real retention reaper until it has removed one
+// event from the webhook's database, then stops it.
+func statsPrune(
+	t *testing.T,
+	db *database.Database,
+	dbMgr *database.WebhookDBManager,
+	log *logger.Logger,
+	webhookDB *gorm.DB,
+) {
+	t.Helper()
+
+	lc := fxtest.NewLifecycle(t)
+	database.NewRetentionReaper(lc, database.RetentionReaperParams{
+		Config: &config.Config{
+			RetentionSweepInterval: 10 * time.Millisecond,
+		},
+		Database:  db,
+		DBManager: dbMgr,
+		Logger:    log,
+	})
+
+	lc.RequireStart()
+
+	require.Eventually(t, func() bool {
+		var totals database.EventTotals
+
+		err := webhookDB.Take(&totals).Error
+
+		return err == nil && totals.EventsRemoved == 1
+	}, 10*time.Second, 10*time.Millisecond)
+
+	lc.RequireStop()
+}
+
+// statsPane returns the text of the statistics pane in a rendered
+// webhook page, everything from its heading to the next heading on the
+// page, with the markup taken out and each run of space made one
+// space. A table then reads header by header and row by row, each
+// row's label followed by its figures in column order.
+func statsPane(t *testing.T, page string) string {
+	t.Helper()
+
+	_, pane, found := strings.Cut(page, ">Statistics</h2>")
+	require.True(t, found, "the page has no statistics pane")
+
+	pane, _, _ = strings.Cut(pane, "<h2")
+	pane = regexp.MustCompile(`<[^>]*>`).ReplaceAllString(pane, " ")
+
+	return strings.Join(strings.Fields(pane), " ")
+}
+
+// assertStatsTargets checks, for the history seedStatsHistory builds,
+// each target's totals and its deliveries finished in the last 24
+// hours. The first target has ten deliveries and the replay, the
+// second ten; the inactive targets have none and so no row.
+func assertStatsTargets(t *testing.T, hist statsHistory) {
+	t.Helper()
+
+	first, second := hist.first, hist.second
+
+	assert.Equal(t, map[string]database.TargetTotals{
+		first:  {TargetID: first, Deliveries: 11, Delivered: 1, Failed: 3},
+		second: {TargetID: second, Deliveries: 10, Failed: 2},
+	}, statsTargetTotals(t, hist.webhookDB))
+
+	lastDay, err := handlers.FinishedByTargetForTest(
+		hist.webhookDB, time.Now().Add(-24*time.Hour),
+	)
+	require.NoError(t, err)
+	assert.ElementsMatch(t, []handlers.TargetFinished{
+		{TargetID: first, Delivered: 1, Failed: 1},
+		{TargetID: second, Failed: 2},
+	}, lastDay)
+}
+
+// assertStatsPaneAfterPrune checks the rendered statistics pane for the
+// history seedStatsHistory builds, once retention has removed the
+// oldest event: each figure after its label, in its column.
+func assertStatsPaneAfterPrune(
+	t *testing.T,
+	h *handlers.Handlers,
+	sess *session.Session,
+	hist statsHistory,
+) {
+	t.Helper()
+
+	pane := statsPane(t, renderSourceDetailPage(t, h, sess, hist.webhook.ID))
+	lastEvent := hist.newest.CreatedAt.UTC().Format("2006-01-02 15:04:05 UTC")
+
+	assert.Contains(t, pane, "Entrypoints 12 (11 active) "+
+		"Targets 6 (2 active) "+
+		"Deliveries in progress 13 "+
+		"Last event "+lastEvent+" "+
+		"Retention 14 days")
+	assert.Contains(t, pane, "Lifetime Within retention "+
+		"Events 10 9 "+
+		"Deliveries 21 18 "+
+		"Failures 5 4")
+	assert.Contains(t, pane, "Last 10 minutes Last 24 hours "+
+		"Events 7 8 "+
+		"Failures 1 3 "+
+		"Failure percentage 50.0% 75.0%")
+}
+
+// TestWebhookStats_EveryFigureAcrossRetentionPrune checks every figure
+// the statistics pane shows for the history seedStatsHistory builds,
+// and each target's totals and recent figures, before and after the
+// real retention reaper removes the oldest event.
+func TestWebhookStats_EveryFigureAcrossRetentionPrune(t *testing.T) {
+	t.Parallel()
+
+	var (
+		h     *handlers.Handlers
+		sess  *session.Session
+		db    *database.Database
+		dbMgr *database.WebhookDBManager
+		log   *logger.Logger
+	)
+
+	app := newTestApp(t, &h, &sess, &db, &dbMgr, &log)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	hist := seedStatsHistory(t, h, sess, db, dbMgr)
+	first, second := hist.first, hist.second
+
+	stats := h.WebhookStatsForTest(hist.webhook.ID)
+	require.NotNil(t, stats)
+
+	assert.Equal(t, 12, stats.Entrypoints)
+	assert.Equal(t, 11, stats.ActiveEntrypoints)
+	assert.Equal(t, 6, stats.Targets)
+	assert.Equal(t, 2, stats.ActiveTargets)
+	assert.Equal(t, handlers.Counts{Events: 10, Deliveries: 21, Failures: 5},
+		stats.Lifetime)
+	assert.Equal(t, stats.Lifetime, stats.WithinRetention)
+	assert.Equal(t, int64(15), stats.InProgress)
+	require.NotNil(t, stats.LastEventAt)
+	assert.True(t, hist.newest.CreatedAt.Equal(*stats.LastEventAt))
+	assert.Equal(t, handlers.RecentWindow{
+		Events: 7, Delivered: 1, Failed: 1,
+	}, stats.Last10Minutes)
+	assert.Equal(t, handlers.RecentWindow{
+		Events: 8, Delivered: 1, Failed: 3,
+	}, stats.Last24Hours)
+	assert.Equal(t, "50.0%", stats.Last10Minutes.FailurePercent())
+	assert.Equal(t, "75.0%", stats.Last24Hours.FailurePercent())
+
+	assertStatsTargets(t, hist)
+
+	// Retention removes the oldest event with its three deliveries:
+	// the first target's failed one and the pending replay, and the
+	// second target's pending one.
+	statsPrune(t, db, dbMgr, log, hist.webhookDB)
+
+	after := h.WebhookStatsForTest(hist.webhook.ID)
+	require.NotNil(t, after)
+
+	assert.Equal(t, stats.Lifetime, after.Lifetime)
+	assert.Equal(t, handlers.Counts{Events: 9, Deliveries: 18, Failures: 4},
+		after.WithinRetention)
+	assert.Equal(t, int64(13), after.InProgress)
+	assert.Equal(t, stats.LastEventAt, after.LastEventAt)
+	assert.Equal(t, stats.Last10Minutes, after.Last10Minutes)
+	assert.Equal(t, stats.Last24Hours, after.Last24Hours)
+
+	assert.Equal(t, map[string]database.TargetTotals{
+		first: {
+			TargetID: first, Deliveries: 11, Delivered: 1, Failed: 3,
+			DeliveriesRemoved: 2, FailedRemoved: 1,
+		},
+		second: {
+			TargetID: second, Deliveries: 10, Failed: 2,
+			DeliveriesRemoved: 1,
+		},
+	}, statsTargetTotals(t, hist.webhookDB))
+
+	assertStatsPaneAfterPrune(t, h, sess, hist)
+}
+
+// TestWebhookStats_LastEventSurvivesPruningEveryEvent checks that once
+// retention has removed every event, the pane still shows when the last
+// one arrived rather than "none".
+func TestWebhookStats_LastEventSurvivesPruningEveryEvent(t *testing.T) {
+	t.Parallel()
+
+	var (
+		h     *handlers.Handlers
+		sess  *session.Session
+		db    *database.Database
+		dbMgr *database.WebhookDBManager
+		log   *logger.Logger
+	)
+
+	app := newTestApp(t, &h, &sess, &db, &dbMgr, &log)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	wh := &database.Webhook{
+		UserID: deleteTestUserID, Name: "pruned", RetentionDays: 1,
+	}
+	require.NoError(t, db.DB().Omit(clause.Associations).Create(wh).Error)
+
+	path := statsEntrypoint(t, db, wh.ID, true)
+	require.Equal(t, http.StatusOK,
+		postReceiver(t, receiverRouter(h), path))
+
+	webhookDB, err := dbMgr.GetDB(wh.ID)
+	require.NoError(t, err)
+
+	events := listEvents(t, webhookDB)
+	require.Len(t, events, 1)
+
+	arrived := events[0].CreatedAt
+
+	statsAge(t, webhookDB, events[0].ID, time.Now().Add(-50*time.Hour))
+	statsPrune(t, db, dbMgr, log, webhookDB)
+	require.Empty(t, listEvents(t, webhookDB))
+
+	stats := h.WebhookStatsForTest(wh.ID)
+	require.NotNil(t, stats)
+	require.NotNil(t, stats.LastEventAt)
+	assert.True(t, arrived.Equal(*stats.LastEventAt))
+
+	pane := statsPane(t, renderSourceDetailPage(t, h, sess, wh.ID))
+	assert.Contains(t, pane,
+		"Last event "+arrived.UTC().Format("2006-01-02 15:04:05 UTC"))
+}
+
+// TestWebhookStats_LastEventInUTC checks that the pane shows when the
+// last event arrived in UTC, as the event list does, when the time was
+// stored in another zone, as it is on a host whose local time is not
+// UTC.
+func TestWebhookStats_LastEventInUTC(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)
+
+	webhookDB, err := dbMgr.GetDB(wh.ID)
+	require.NoError(t, err)
+
+	arrived := time.Date(2026, time.March, 4, 22, 30, 0, 0,
+		time.FixedZone("EST", -5*60*60))
+	require.NoError(t, database.AddEventTotals(webhookDB,
+		database.EventTotals{Events: 1, LastEventAt: &arrived}))
+
+	pane := statsPane(t, renderSourceDetailPage(t, h, sess, wh.ID))
+	assert.Contains(t, pane, "Last event 2026-03-05 03:30:00 UTC")
+}
+
+// TestWebhookStats_PaneShowsRetentionPeriod checks that the statistics
+// pane itself, not only the line at the foot of the page, shows the
+// webhook's retention period, for a finite one and for forever.
+func TestWebhookStats_PaneShowsRetentionPeriod(t *testing.T) {
+	t.Parallel()
+
+	var (
+		h    *handlers.Handlers
+		sess *session.Session
+		db   *database.Database
+	)
+
+	app := newTestApp(t, &h, &sess, &db)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	tests := []struct {
+		retentionDays int
+		want          string
+	}{
+		{30, "30 days"},
+		{database.RetentionForeverDays, "forever"},
+	}
+
+	for _, tt := range tests {
+		wh := &database.Webhook{
+			UserID:        deleteTestUserID,
+			Name:          "retention",
+			RetentionDays: tt.retentionDays,
+		}
+		require.NoError(t,
+			db.DB().Omit(clause.Associations).Create(wh).Error)
+
+		pane := statsPane(t, renderSourceDetailPage(t, h, sess, wh.ID))
+		assert.Contains(t, pane, "Retention "+tt.want)
+	}
+}
+
+// TestWebhookStats_WebhookWithNoEvents covers a webhook whose event
+// database has never been opened: every count is zero, the
+// percentages are a dash, and showing the page does not create the
+// database.
+func TestWebhookStats_WebhookWithNoEvents(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)
+
+	assert.Equal(t, &handlers.WebhookStats{}, h.WebhookStatsForTest(wh.ID))
+	assert.Equal(t, "—", handlers.RecentWindow{}.FailurePercent())
+
+	pane := statsPane(t, renderSourceDetailPage(t, h, sess, wh.ID))
+	assert.Contains(t, pane, "Last event none")
+	assert.Contains(t, pane, "Failure percentage — —")
+	assert.False(t, dbMgr.DBExists(wh.ID))
+}
+
+// TestRecentWindow_FailurePercent pins the percentage: failed
+// deliveries out of all that finished in the window.
+func TestRecentWindow_FailurePercent(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		window handlers.RecentWindow
+		want   string
+	}{
+		{handlers.RecentWindow{}, "—"},
+		{handlers.RecentWindow{Events: 4}, "—"},
+		{handlers.RecentWindow{Delivered: 3, Failed: 1}, "25.0%"},
+		{handlers.RecentWindow{Failed: 2}, "100.0%"},
+		{handlers.RecentWindow{Delivered: 2}, "0.0%"},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(t, tt.want, tt.window.FailurePercent(), tt.window)
+	}
+}

internal/logfield/logfield_test.go

@@ -201,7 +201,7 @@ func TestTruncate_LeavesShortValuesAlone(t *testing.T) {
 	t.Parallel()
 
 	for _, s := range []string{
-		"", "GET", "/source/abc/edit", "Mozilla/5.0 (X11)",
+		"", "GET", "/hook/abc/edit", "Mozilla/5.0 (X11)",
 	} {
 		assert.Equal(t, s, logfield.Truncate(s, budget))
 	}

internal/middleware/accesslog_test.go

@@ -119,7 +119,7 @@ func accessLogRouter(m *middleware.Middleware) *chi.Mux {
 	)
 
 	router.HandleFunc(
-		"/webhook/{uuid}",
+		"/h/{uuid}",
 		func(w http.ResponseWriter, r *http.Request) {
 			// Stands in for the real handler: an unknown entrypoint
 			// UUID 404s, a known one succeeds.
@@ -271,11 +271,11 @@ func TestAccessLog_InventedReceiverPathsLogRoutePattern(t *testing.T) {
 	assertFloodIsBounded(
 		t,
 		func(i int) string {
-			return "/webhook/" + attackerMarker +
+			return "/h/" + attackerMarker +
 				strings.Repeat("x", i) + "?q=" + attackerMarker
 		},
 		http.StatusNotFound,
-		"/webhook/{uuid}",
+		"/h/{uuid}",
 	)
 }
 
@@ -346,10 +346,10 @@ type sizeCase struct {
 func lineSizeCases() map[string]sizeCase {
 	cases := map[string]sizeCase{
 		"oversized path segment": {
-			target: "/webhook/" + attackerMarker +
+			target: "/h/" + attackerMarker +
 				strings.Repeat("x", oversizedSegmentBytes),
 			wantStatus: http.StatusNotFound,
-			wantURL:    "/webhook/{uuid}",
+			wantURL:    "/h/{uuid}",
 			bound:      maxLineBytes,
 		},
 		// /.well-known/healthcheck answers 200 to anyone and has no
@@ -605,14 +605,14 @@ func TestAccessLog_SuccessKeepsConcretePathAndRedactsQuery(
 	router := accessLogRouter(m)
 
 	assert.Equal(
-		t, http.StatusOK, get(t, router, "/webhook/known?src=ci"),
+		t, http.StatusOK, get(t, router, "/h/known?src=ci"),
 	)
 
 	// The path resolved against a stored entrypoint, so it stays. The
 	// query never does: see TestAccessLog_UnauthenticatedSuccess...
 	entries := accessLogEntries(t, buf)
 	require.Len(t, entries, 1)
-	assert.Equal(t, "/webhook/known?(redacted)", entries[0]["url"])
+	assert.Equal(t, "/h/known?(redacted)", entries[0]["url"])
 	assert.NotContains(t, buf.String(), "src=ci")
 }
 
@@ -640,7 +640,7 @@ func TestAccessLog_RetainsEveryOtherField(t *testing.T) {
 	assert.Equal(
 		t,
 		http.StatusNotFound,
-		get(t, router, "/webhook/"+attackerMarker),
+		get(t, router, "/h/"+attackerMarker),
 	)
 
 	entries := accessLogEntries(t, buf)

internal/middleware/csrf.go

@@ -41,7 +41,7 @@ func (m *Middleware) CSRF() func(http.Handler) http.Handler {
 		// CSRF is registered ahead of RequireAuth on every route
 		// group that uses it, so this WARN is reachable by an
 		// unauthenticated client: a POST with no token to
-		// /source/<any length of any text>/edit lands here. The
+		// /hook/<any length of any text>/edit lands here. The
 		// method and path are capped against the same budgets as
 		// the access log. remote_addr is set by net/http from the
 		// accepted connection rather than by the client, and

internal/middleware/logbound_test.go

@@ -383,7 +383,7 @@ func TestLogLines_ClientChosenPathDoesNotSizeTheLine(t *testing.T) {
 						t, newHandler,
 					)
 
-					path := "/source/" +
+					path := "/hook/" +
 						oversizedPathSegment(fill) + "/edit"
 
 					assert.Equal(
@@ -434,7 +434,7 @@ func TestLoginThrottle_LogLineDoesNotTrackPathSize(t *testing.T) {
 				req := httptest.NewRequestWithContext(
 					context.Background(),
 					http.MethodPost,
-					"/source/"+
+					"/hook/"+
 						oversizedPathSegment(fill)+"/login",
 					nil,
 				)
@@ -499,7 +499,7 @@ func TestMaxBodySize_FloodOfOversizePathsDoesNotGrowTheLog(
 							http.StatusRequestEntityTooLarge,
 							postOversize(
 								h,
-								"/source/"+segment(i)+"/edit",
+								"/hook/"+segment(i)+"/edit",
 							),
 						)
 					}

internal/middleware/loginguard.go

@@ -108,10 +108,10 @@ type failureWindow struct {
 //
 // A limiter that spends budget on arrival cannot protect a
 // single-admin product: behind the reverse proxy the deployment
-// requires, with TRUSTED_PROXIES unset, every client keys on the
-// proxy, so a stranger trickling five POSTs a minute keeps the one
-// bucket full and the operator's own correct password is answered 429
-// forever. There is no second administrative path.
+// requires, when TRUSTED_PROXIES does not cover it, every client
+// keys on the proxy, so a stranger trickling five POSTs a minute
+// keeps the one bucket full and the operator's own correct password
+// is answered 429 forever. There is no second administrative path.
 //
 // So budget is spent only by a FAILED verification. A correct
 // password is never throttled, whatever the counters say, which is

internal/middleware/metrics.go

@@ -40,7 +40,7 @@ const unmatchedMethod = unmatchedRoute
 //
 // The pattern is what bounds the label's domain to the routes the
 // service registers. The path does not bound it at all — every byte
-// after /webhook/ is client-chosen, so labelling by path lets any
+// after /h/ is client-chosen, so labelling by path lets any
 // unauthenticated client mint permanent series at will, and publishes
 // the entrypoint UUID (the receiver's only credential) in the scrape
 // while doing it.

internal/middleware/metrics_method_test.go

@@ -50,7 +50,7 @@ func realMethods() []string {
 // dimension varying, so any series growth a probe produces is the
 // method label's and nothing else's.
 func methodProbePath() string {
-	return "/webhook/" + uuid.NewString()
+	return "/h/" + uuid.NewString()
 }
 
 // inventedMethods returns n distinct RFC 9110 method tokens that no

internal/middleware/metrics_test.go

@@ -28,7 +28,7 @@ const (
 
 	// receiverRoutePattern is the one handler label every receiver
 	// request must produce, however the client varies the path.
-	receiverRoutePattern = "/webhook/{uuid}"
+	receiverRoutePattern = "/h/{uuid}"
 
 	// okRoute is a static route used to pin that the response-writer
 	// interceptor still reports status and size after the handler id
@@ -143,13 +143,13 @@ func drivePaths(
 	return drive(t, h, probes)
 }
 
-// receiverPaths returns n distinct /webhook/ paths, each naming a
+// receiverPaths returns n distinct /h/ paths, each naming a
 // fresh UUID exactly as an unauthenticated flood would.
 func receiverPaths(n int) []string {
 	paths := make([]string, 0, n)
 
 	for range n {
-		paths = append(paths, "/webhook/"+uuid.NewString())
+		paths = append(paths, "/h/"+uuid.NewString())
 	}
 
 	return paths
@@ -220,7 +220,7 @@ func keys(set map[string]struct{}) []string {
 
 // TestMetrics_DistinctReceiverPathsMintOneLabelSet is the direct
 // assertion the issue asks for: N requests to N distinct
-// /webhook/<uuid> paths must produce exactly ONE handler label, the
+// /h/<uuid> paths must produce exactly ONE handler label, the
 // route pattern. Before the fix this produced N of them.
 func TestMetrics_DistinctReceiverPathsMintOneLabelSet(t *testing.T) {
 	t.Parallel()
@@ -250,7 +250,7 @@ func TestMetrics_DistinctReceiverPathsMintOneLabelSet(t *testing.T) {
 	// The scrape must not republish the UUIDs it was driven with.
 	// They are the receiver's only credential.
 	for _, p := range paths {
-		id := strings.TrimPrefix(p, "/webhook/")
+		id := strings.TrimPrefix(p, "/h/")
 		for label := range labels {
 			assert.NotContains(
 				t, label, id,
@@ -354,7 +354,7 @@ func TestMetrics_UnmatchedPathsCollapseToTheSentinel(t *testing.T) {
 		if i%2 == 0 {
 			paths = append(paths, "/"+id)
 		} else {
-			paths = append(paths, "/webhook/"+id+"/"+id)
+			paths = append(paths, "/h/"+id+"/"+id)
 		}
 	}
 

internal/middleware/middleware.go

@@ -6,6 +6,7 @@ import (
 	"log/slog"
 	"net"
 	"net/http"
+	"net/url"
 	"sync"
 	"time"
 
@@ -257,7 +258,7 @@ func concreteLogURL(r *http.Request) string {
 //
 // 3xx and 4xx responses get the chi route pattern instead. Those are
 // the outcomes an unauthenticated client drives for free: 404 or 429
-// on any invented /webhook/ path, 303 to the login page on any
+// on any invented /h/ path, 303 to the login page on any
 // invented /user/ path. Logging the concrete URL there lets a flood
 // write attacker-chosen text, of attacker-chosen length, into the
 // operator's log at one line per request. The pattern comes from the
@@ -366,6 +367,30 @@ func (s *Middleware) CORS() func(http.Handler) http.Handler {
 	}
 }
 
+// NextParam is the query parameter on the login redirect, and the
+// login form field, that holds the page to return to after login.
+const NextParam = "next"
+
+// MaxNextBytes bounds the NextParam value. The login page writes it
+// into its form, and every page is rendered into a buffer first, so
+// without a bound a request would choose the size of that buffer.
+const MaxNextBytes = 2048
+
+// loginURL is the login page RequireAuth redirects to. A GET carries
+// its own path and query in NextParam so that logging in returns to
+// it, unless they are longer than MaxNextBytes; loginDestination in
+// the handlers package checks whether that value is safe to follow.
+// Other methods carry nothing, since a redirect cannot repeat them.
+func loginURL(r *http.Request) string {
+	next := r.URL.RequestURI()
+
+	if r.Method != http.MethodGet || len(next) > MaxNextBytes {
+		return "/pages/login"
+	}
+
+	return "/pages/login?" + url.Values{NextParam: {next}}.Encode()
+}
+
 // RequireAuth returns middleware that checks for a valid session.
 // Unauthenticated users are redirected to the login page.
 func (s *Middleware) RequireAuth() func(http.Handler) http.Handler {
@@ -381,7 +406,7 @@ func (s *Middleware) RequireAuth() func(http.Handler) http.Handler {
 					"error", err,
 				)
 				http.Redirect(
-					w, r, "/pages/login", http.StatusSeeOther,
+					w, r, loginURL(r), http.StatusSeeOther,
 				)
 
 				return
@@ -409,7 +434,7 @@ func (s *Middleware) RequireAuth() func(http.Handler) http.Handler {
 					),
 				)
 				http.Redirect(
-					w, r, "/pages/login", http.StatusSeeOther,
+					w, r, loginURL(r), http.StatusSeeOther,
 				)
 
 				return
@@ -560,7 +585,7 @@ func (s *Middleware) MaxBodySize(
 				// internal/server/routes.go), so an
 				// unauthenticated client reaches it with a path
 				// of its own choosing and its own length —
-				// POST /source/<8 KB>/edit with an oversize
+				// POST /hook/<8 KB>/edit with an oversize
 				// declared Content-Length costs nothing to
 				// send. At WARN, on by default, that is a
 				// write into the operator's log sized by the

internal/middleware/middleware_test.go

@@ -338,6 +338,76 @@ func TestRequireAuth_NoSession_RedirectsToLogin(t *testing.T) {
 			"unauthenticated request",
 	)
 	assert.Equal(t, http.StatusSeeOther, w.Code)
+	assert.Equal(
+		t, "/pages/login?next=%2Fdashboard", w.Header().Get("Location"),
+	)
+}
+
+// TestRequireAuth_LoginRedirectCarriesOnlyAGet pins what the login
+// redirect carries: a GET's path and query, so logging in can return
+// there, and nothing for a POST, which a redirect cannot repeat.
+func TestRequireAuth_LoginRedirectCarriesOnlyAGet(t *testing.T) {
+	t.Parallel()
+
+	m, _ := testMiddleware(t, config.EnvironmentDev)
+
+	handler := m.RequireAuth()(http.HandlerFunc(
+		func(_ http.ResponseWriter, _ *http.Request) {},
+	))
+
+	get := httptest.NewRequestWithContext(
+		context.Background(),
+		http.MethodGet, "/hook/abc/events?page=2", nil,
+	)
+	w := httptest.NewRecorder()
+	handler.ServeHTTP(w, get)
+
+	assert.Equal(
+		t, "/pages/login?next=%2Fhook%2Fabc%2Fevents%3Fpage%3D2",
+		w.Header().Get("Location"),
+	)
+
+	post := httptest.NewRequestWithContext(
+		context.Background(),
+		http.MethodPost, "/hook/abc/delete", nil,
+	)
+	w = httptest.NewRecorder()
+	handler.ServeHTTP(w, post)
+
+	assert.Equal(t, "/pages/login", w.Header().Get("Location"))
+}
+
+// TestRequireAuth_LoginRedirectLeavesOutALongURL: a GET whose path
+// and query are longer than the login page accepts goes to the plain
+// login page, so a long URL does not make the redirect long.
+func TestRequireAuth_LoginRedirectLeavesOutALongURL(t *testing.T) {
+	t.Parallel()
+
+	m, _ := testMiddleware(t, config.EnvironmentDev)
+
+	handler := m.RequireAuth()(http.HandlerFunc(
+		func(_ http.ResponseWriter, _ *http.Request) {},
+	))
+
+	atLimit := "/" + strings.Repeat("a", middleware.MaxNextBytes-1)
+
+	get := httptest.NewRequestWithContext(
+		context.Background(), http.MethodGet, atLimit, nil,
+	)
+	w := httptest.NewRecorder()
+	handler.ServeHTTP(w, get)
+
+	assert.Equal(
+		t, "/pages/login?next=%2F"+atLimit[1:],
+		w.Header().Get("Location"),
+	)
+
+	get = httptest.NewRequestWithContext(
+		context.Background(), http.MethodGet, atLimit+"a", nil,
+	)
+	w = httptest.NewRecorder()
+	handler.ServeHTTP(w, get)
+
 	assert.Equal(t, "/pages/login", w.Header().Get("Location"))
 }
 
@@ -443,7 +513,9 @@ func TestRequireAuth_UnauthenticatedSession_RedirectsToLogin(
 			"unauthenticated session",
 	)
 	assert.Equal(t, http.StatusSeeOther, w.Code)
-	assert.Equal(t, "/pages/login", w.Header().Get("Location"))
+	assert.Equal(
+		t, "/pages/login?next=%2Fdashboard", w.Header().Get("Location"),
+	)
 }
 
 // --- RequireAuth Session Expiry Tests ---
@@ -541,7 +613,9 @@ func TestRequireAuth_IdleExpiredSession_RedirectsToLogin(
 		"handler should not run for an idle-expired session",
 	)
 	assert.Equal(t, http.StatusSeeOther, w.Code)
-	assert.Equal(t, "/pages/login", w.Header().Get("Location"))
+	assert.Equal(
+		t, "/pages/login?next=%2Fdashboard", w.Header().Get("Location"),
+	)
 	assert.Empty(
 		t, sessionCookies(w),
 		"an expired session must not be refreshed",
@@ -640,7 +714,7 @@ func TestNoCache_SetsHeaders(t *testing.T) {
 
 	req := httptest.NewRequestWithContext(
 		context.Background(),
-		http.MethodGet, "/sources", nil,
+		http.MethodGet, "/hooks", nil,
 	)
 	w := httptest.NewRecorder()
 

internal/middleware/ratelimit.go

@@ -63,7 +63,7 @@ const (
 
 	// receiverAggregateMultiplier scales the configured
 	// per-entrypoint receiver limit into the aggregate limit one
-	// client IP may spend across the whole /webhook/* route. Ten
+	// client IP may spend across the whole /h/* route. Ten
 	// entrypoints' worth lets a single sender address drive several
 	// entrypoints at their full rate, while still capping what one
 	// address costs the unauthenticated receiver.
@@ -123,9 +123,8 @@ func bucketKey(addr netip.Addr) string {
 	return prefix.String()
 }
 
-// isTrustedProxy reports whether addr belongs to a network the
-// operator listed in TRUSTED_PROXIES. The list is empty by default,
-// so by default nothing is trusted.
+// isTrustedProxy reports whether addr belongs to a network in
+// TRUSTED_PROXIES, which by default is the RFC 1918 private ranges.
 func (m *Middleware) isTrustedProxy(addr netip.Addr) bool {
 	for _, prefix := range m.params.Config.TrustedProxies {
 		if prefix.Contains(addr) {
@@ -390,7 +389,7 @@ func (m *Middleware) postRateLimit(
 // It is Config.ReceiverRateLimit requests per minute.
 //
 // That limit alone bounds nothing in aggregate. The route pattern
-// /webhook/{uuid} matches any single segment, so a client that
+// /h/{uuid} matches any single segment, so a client that
 // invents a fresh path per request mints a fresh bucket per request
 // and never refills one — and every such request still reaches the
 // handler's entrypoint lookup before it 404s. The outer limit is

internal/middleware/ratelimit_test.go

@@ -275,7 +275,7 @@ func TestReceiverRateLimit_LimitsPerIPAndPath(t *testing.T) {
 	// pass.
 	for i := range limit {
 		w := receiverPost(
-			handler, "9.9.9.9:1234", "/webhook/uuid-a",
+			handler, "9.9.9.9:1234", "/h/uuid-a",
 		)
 		assert.Equal(
 			t, http.StatusOK, w.Code,
@@ -286,7 +286,7 @@ func TestReceiverRateLimit_LimitsPerIPAndPath(t *testing.T) {
 	// The next request over the limit is rejected with a 429
 	// carrying a Retry-After header.
 	w := receiverPost(
-		handler, "9.9.9.9:1234", "/webhook/uuid-a",
+		handler, "9.9.9.9:1234", "/h/uuid-a",
 	)
 	assert.Equal(t, http.StatusTooManyRequests, w.Code)
 	assert.NotEmpty(
@@ -296,7 +296,7 @@ func TestReceiverRateLimit_LimitsPerIPAndPath(t *testing.T) {
 
 	// The same IP is not limited on a different entrypoint.
 	w = receiverPost(
-		handler, "9.9.9.9:1234", "/webhook/uuid-b",
+		handler, "9.9.9.9:1234", "/h/uuid-b",
 	)
 	assert.Equal(
 		t, http.StatusOK, w.Code,
@@ -305,7 +305,7 @@ func TestReceiverRateLimit_LimitsPerIPAndPath(t *testing.T) {
 
 	// A different IP is not limited on the same entrypoint.
 	w = receiverPost(
-		handler, "8.8.8.8:1234", "/webhook/uuid-a",
+		handler, "8.8.8.8:1234", "/h/uuid-a",
 	)
 	assert.Equal(
 		t, http.StatusOK, w.Code,
@@ -322,7 +322,7 @@ func TestReceiverRateLimit_CountsEveryMethod(t *testing.T) {
 	const (
 		limit = 2
 		ip    = "7.7.7.7:1234"
-		path  = "/webhook/uuid-c"
+		path  = "/h/uuid-c"
 	)
 
 	handler := receiverLimitedHandler(t, limit)
@@ -384,8 +384,8 @@ const (
 	// trustedProxyCIDR is the proxy network the forwarded-path
 	// tests configure, and trustedPeer an address inside it. A
 	// production deployment is required to run behind a reverse
-	// proxy with TRUSTED_PROXIES set, so this is the shape the
-	// bucketing has to hold in.
+	// proxy that TRUSTED_PROXIES covers, either by the default or by
+	// a set value, so this is the shape the bucketing has to hold in.
 	trustedProxyCIDR = "10.0.0.0/8"
 	trustedPeer      = "10.0.0.1:44444"
 )
@@ -426,8 +426,8 @@ func assertSharedBucket(
 }
 
 // TestRateLimitKey_SpoofedForwardedFromUntrustedPeer is the test
-// this gating exists for: with no trusted proxies configured (the
-// default), a client that rotates a forwarded header on every
+// this gating exists for: from a peer that is not a trusted
+// proxy, a client that rotates a forwarded header on every
 // request must stay in one bucket. If forwarded headers were
 // trusted unconditionally, each spoofed value would mint a fresh
 // bucket and the limit would stop no one.
@@ -715,7 +715,7 @@ func TestReceiverRateLimit_LimitsAggregateAcrossInventedPaths(
 	// none of them shares a per-entrypoint bucket with another.
 	for i := range aggregate {
 		w := receiverPost(
-			handler, ip, fmt.Sprintf("/webhook/invented-%d", i),
+			handler, ip, fmt.Sprintf("/h/invented-%d", i),
 		)
 		assert.Equal(
 			t, http.StatusOK, w.Code,
@@ -724,17 +724,17 @@ func TestReceiverRateLimit_LimitsAggregateAcrossInventedPaths(
 	}
 
 	w := receiverPost(
-		handler, ip, fmt.Sprintf("/webhook/invented-%d", aggregate),
+		handler, ip, fmt.Sprintf("/h/invented-%d", aggregate),
 	)
 	assert.Equal(
 		t, http.StatusTooManyRequests, w.Code,
 		"a client must not be able to raise its aggregate rate "+
-			"against /webhook/* by varying the path",
+			"against /h/* by varying the path",
 	)
 
 	// The aggregate limit is still per client IP: exhausting one
 	// address must not throttle another.
-	w = receiverPost(handler, "6.6.6.7:1234", "/webhook/invented-0")
+	w = receiverPost(handler, "6.6.6.7:1234", "/h/invented-0")
 	assert.Equal(
 		t, http.StatusOK, w.Code,
 		"a different client IP must not be affected",
@@ -771,7 +771,7 @@ func TestReceiverRateLimit_RejectedRequestsCountTowardAggregate(
 	// limit requests are served; the rest are rejected by the
 	// per-entrypoint limiter but still count against the aggregate.
 	for i := range aggregate {
-		w := receiverPost(handler, ip, "/webhook/exhausted")
+		w := receiverPost(handler, ip, "/h/exhausted")
 
 		want := http.StatusTooManyRequests
 		if i < limit {
@@ -784,7 +784,7 @@ func TestReceiverRateLimit_RejectedRequestsCountTowardAggregate(
 		)
 	}
 
-	w := receiverPost(handler, ip, "/webhook/never-used")
+	w := receiverPost(handler, ip, "/h/never-used")
 	assert.Equal(
 		t, http.StatusTooManyRequests, w.Code,
 		"requests rejected per entrypoint must still count "+
@@ -823,7 +823,7 @@ func TestReceiverRateLimit_IgnoresForwardedFromUntrustedPeer(
 	const (
 		limit = 3
 		peer  = "203.0.113.10:44444"
-		path  = "/webhook/uuid-d"
+		path  = "/h/uuid-d"
 	)
 
 	handler := receiverLimitedHandler(t, limit)
@@ -1097,8 +1097,9 @@ func TestPostRateLimit_IPv4IndependentPerAddress(t *testing.T) {
 // that arrives from trustedPeer — a configured trusted proxy — and
 // names forwarded as its client in X-Forwarded-For. That is the
 // production path: a deployment is required to run behind a reverse
-// proxy with TRUSTED_PROXIES set, so the forwarded address, not the
-// peer, is what the limiters bucket on there.
+// proxy that TRUSTED_PROXIES covers, either by the default or by a
+// set value, so the forwarded address, not the peer, is what the
+// limiters bucket on there.
 func forwardedKeyFor(
 	t *testing.T, m *middleware.Middleware, forwarded string,
 ) string {
@@ -1178,9 +1179,9 @@ func TestRateLimitKey_ForwardedIPv6BucketsByPrefix(t *testing.T) {
 //
 // Every existing test of this fallback uses an IPv4 proxy, where
 // bucketKey is the identity function, so replacing the call with
-// peer.String() leaves the whole suite green. Only operator-listed
-// addresses reach this line and the fallback is fail-closed, so this
-// pins behaviour rather than fixing a defect.
+// peer.String() leaves the whole suite green. Only addresses inside
+// TRUSTED_PROXIES reach this line and the fallback is fail-closed, so
+// this pins behaviour rather than fixing a defect.
 func TestRateLimitKey_TrustedPeerUnusableForwardedMasksPeer(
 	t *testing.T,
 ) {

internal/resetpw/resetpw_test.go

@@ -140,7 +140,7 @@ func (n *noopEvictor) EvictWebhook(string) {}
 // and the database, exactly as internal/handlers builds them.
 //
 // One application per test function, not per case: every start that
-// finds no account seeds one at 64 MB of Argon2id, and this package's
+// finds no account seeds one with an Argon2id hash, and this package's
 // budget is not the place to spend that repeatedly.
 func newServerApp(
 	t *testing.T, dir string,

internal/server/routes.go

@@ -92,11 +92,25 @@ func (s *Server) setupGlobalMiddleware() {
 func (s *Server) setupRoutes() {
 	s.router.Get("/", s.h.HandleIndex())
 
-	s.router.Mount(
-		"/s",
-		http.StripPrefix("/s", http.FileServer(http.FS(static.Static))),
+	// Static assets answer GET and HEAD only. chi's default 405
+	// carries no Allow header, so this group supplies its own.
+	staticFiles := http.StripPrefix(
+		"/s", http.FileServer(http.FS(static.Static)),
 	)
 
+	s.router.Route("/s", func(r chi.Router) {
+		r.MethodNotAllowed(func(w http.ResponseWriter, _ *http.Request) {
+			w.Header().Set("Allow", "GET, HEAD")
+			http.Error(
+				w,
+				"Method Not Allowed",
+				http.StatusMethodNotAllowed,
+			)
+		})
+		r.Method(http.MethodGet, "/*", staticFiles)
+		r.Method(http.MethodHead, "/*", staticFiles)
+	})
+
 	s.router.Route("/api/v1", func(_ chi.Router) {
 		// API routes will be added here.
 	})
@@ -140,11 +154,12 @@ func (s *Server) setupPageRoutes() {
 		r.Use(s.mw.NoCache())
 
 		// The login POST carries no pre-emptive rate limiter. Behind
-		// the reverse proxy production requires, with TRUSTED_PROXIES
-		// unset, every client shares one bucket, so a limiter spent
-		// on arrival lets any stranger deny the operator the only
-		// administrative path. The handler verifies credentials first
-		// and charges only failures; see Handlers.authenticateUser.
+		// the reverse proxy production requires, when TRUSTED_PROXIES
+		// does not cover it, every client shares one bucket, so a
+		// limiter spent on arrival lets any stranger deny the operator
+		// the only administrative path. The handler verifies
+		// credentials first and charges only failures; see
+		// Handlers.authenticateUser.
 		r.Get("/login", s.h.HandleLoginPage())
 		r.Post("/login", s.h.HandleLoginSubmit())
 
@@ -168,7 +183,7 @@ func (s *Server) setupUserRoutes() {
 }
 
 func (s *Server) setupSourceRoutes() {
-	s.router.Route("/sources", func(r chi.Router) {
+	s.router.Route("/hooks", func(r chi.Router) {
 		// MaxBodySize precedes CSRF and RequireAuth deliberately;
 		// see maxFormBodySize for why, and for what it costs.
 		r.Use(s.mw.MaxBodySize(maxFormBodySize))
@@ -180,7 +195,7 @@ func (s *Server) setupSourceRoutes() {
 		r.Post("/new", s.h.HandleSourceCreateSubmit())
 	})
 
-	s.router.Route("/source/{sourceID}", func(r chi.Router) {
+	s.router.Route("/hook/{sourceID}", func(r chi.Router) {
 		// MaxBodySize precedes CSRF and RequireAuth deliberately;
 		// see maxFormBodySize for why, and for what it costs.
 		r.Use(s.mw.MaxBodySize(maxFormBodySize))
@@ -191,14 +206,14 @@ func (s *Server) setupSourceRoutes() {
 		r.Get("/edit", s.h.HandleSourceEdit())
 		r.Post("/edit", s.h.HandleSourceEditSubmit())
 		r.Post("/delete", s.h.HandleSourceDelete())
-		r.Get("/logs", s.h.HandleSourceLogs())
+		r.Get("/events", s.h.HandleSourceLogs())
 		// The log page renders each body only up to its cap, so
 		// this is the only route that serves a whole one. It
 		// belongs to this group for its RequireAuth and
 		// NoCache; see HandleEventBodyDownload for the headers
 		// that keep the bytes it returns inert.
 		r.Get(
-			"/logs/{eventID}/body",
+			"/events/{eventID}/body",
 			s.h.HandleEventBodyDownload(),
 		)
 		// Replay is the one page action that queues outbound work:
@@ -265,7 +280,7 @@ func (s *Server) setupSourceRoutes() {
 
 func (s *Server) setupWebhookRoutes() {
 	s.router.With(s.mw.ReceiverRateLimit()).HandleFunc(
-		"/webhook/{uuid}",
+		"/h/{uuid}",
 		s.h.HandleWebhook(),
 	)
 }

internal/server/routes_test.go

@@ -7,6 +7,7 @@ import (
 	"net/http/httptest"
 	"net/url"
 	"regexp"
+	"slices"
 	"strconv"
 	"strings"
 	"testing"
@@ -46,8 +47,8 @@ type noopNotifier struct{}
 func (n *noopNotifier) Notify([]delivery.Task) {}
 
 // noopEvictor satisfies handlers.New's delivery.WebhookEvictor
-// dependency. These tests never delete a webhook, so there is
-// nothing to record.
+// dependency. No test here checks what gets evicted, so it records
+// nothing.
 type noopEvictor struct{}
 
 func (e *noopEvictor) EvictWebhook(string) {}
@@ -220,13 +221,45 @@ func (e *testEnv) csrfFrom(
 	// out of the markup has to be unescaped before it is submitted.
 	token := html.UnescapeString(match[1])
 
-	combined := make([]*http.Cookie, 0, len(cookies))
-	combined = append(combined, cookies...)
-	combined = append(combined, w.Result().Cookies()...)
+	// A cookie the page sets replaces the one of the same name, as in
+	// a browser. Sent both, the server would read the first, older one.
+	set := w.Result().Cookies()
+	combined := make([]*http.Cookie, 0, len(cookies)+len(set))
+
+	for _, c := range cookies {
+		replaced := slices.ContainsFunc(set, func(n *http.Cookie) bool {
+			return n.Name == c.Name
+		})
+		if !replaced {
+			combined = append(combined, c)
+		}
+	}
+
+	combined = append(combined, set...)
 
 	return token, combined
 }
 
+// urlFrom renders the page at path and returns the link or form
+// action that pattern's one group captures, so a test requests the
+// URL the template emitted rather than one it wrote itself.
+func (e *testEnv) urlFrom(
+	t *testing.T,
+	path, pattern string,
+	cookies []*http.Cookie,
+) string {
+	t.Helper()
+
+	w := e.get(path, cookies)
+	require.Equal(t, http.StatusOK, w.Code)
+
+	match := regexp.MustCompile(pattern).
+		FindStringSubmatch(w.Body.String())
+	require.Len(t, match, 2, "%s should render %s", path, pattern)
+
+	return html.UnescapeString(match[1])
+}
+
 // authCookies forges an authenticated session for the given user.
 func (e *testEnv) authCookies(
 	t *testing.T,
@@ -396,13 +429,15 @@ func (e *testEnv) storedHash(t *testing.T, username string) string {
 
 // --- /s static group ---
 
-// TestStaticServesEveryMethod pins what the static mount actually
-// answers. chi's Mount registers the handler for all methods and
-// http.FileServer only special-cases HEAD (by suppressing the body),
-// so a POST or a DELETE to an asset is served the file rather than
-// refused. The README documents this; the test is what keeps the two
-// from drifting.
-func TestStaticServesEveryMethod(t *testing.T) {
+// TestStaticServesOnlyGetAndHead pins the methods the static group
+// answers: GET and HEAD are served the asset, and the other methods
+// chi routes (POST, PUT, DELETE and the rest) are refused with 405
+// and an Allow header naming those two. A method chi does not route,
+// such as PROPFIND, is refused with 405 by the top-level router
+// before it reaches the static group, so it gets no Allow header.
+// The README documents this; the test is what keeps the two from
+// drifting.
+func TestStaticServesOnlyGetAndHead(t *testing.T) {
 	t.Parallel()
 
 	env := newTestEnv(t)
@@ -417,6 +452,7 @@ func TestStaticServesEveryMethod(t *testing.T) {
 		http.MethodPost,
 		http.MethodPut,
 		http.MethodDelete,
+		"PROPFIND",
 	} {
 		t.Run(method, func(t *testing.T) {
 			t.Parallel()
@@ -428,18 +464,38 @@ func TestStaticServesEveryMethod(t *testing.T) {
 			w := httptest.NewRecorder()
 			env.router.ServeHTTP(w, req)
 
-			assert.Equal(t, http.StatusOK, w.Code,
-				"static mount answers every method")
-
-			if method == http.MethodHead {
+			switch method {
+			case http.MethodGet:
+				assert.Equal(t, http.StatusOK, w.Code)
+				assert.Equal(t, body, w.Body.Bytes(),
+					"the asset itself is returned")
+			case http.MethodHead:
+				assert.Equal(t, http.StatusOK, w.Code)
 				assert.Empty(t, w.Body.Bytes(),
 					"HEAD must not carry a body")
-
-				return
+			case "PROPFIND":
+				assert.Equal(
+					t, http.StatusMethodNotAllowed, w.Code,
+				)
+				assert.Empty(t, w.Header().Get("Allow"),
+					"chi refuses a method it does not route "+
+						"before the static group runs")
+				assert.NotContains(
+					t, w.Body.String(), string(body),
+					"a refused method must not get the asset",
+				)
+			default:
+				assert.Equal(
+					t, http.StatusMethodNotAllowed, w.Code,
+				)
+				assert.Equal(
+					t, "GET, HEAD", w.Header().Get("Allow"),
+				)
+				assert.NotContains(
+					t, w.Body.String(), string(body),
+					"a refused method must not get the asset",
+				)
 			}
-
-			assert.Equal(t, body, w.Body.Bytes(),
-				"the asset itself is returned")
 		})
 	}
 }
@@ -591,6 +647,97 @@ func TestPagesLogin_CorrectPasswordSurvivesASpentBudget(
 	)
 }
 
+// TestPagesLogin_CookiesFromAnEarlierDatabase is
+// https://git.eeqj.de/sneak/webhooker/issues/359. A new database
+// brings a new session key, and the operator's browser still holds
+// the session and CSRF cookies signed with the old one. Logging in
+// must work as from a fresh browser and leave cookies the new key
+// accepts.
+func TestPagesLogin_CookiesFromAnEarlierDatabase(t *testing.T) {
+	t.Parallel()
+
+	const (
+		username = "operator"
+		password = "correct-horse-battery-staple"
+	)
+
+	earlier := newTestEnv(t)
+	earlierID, _ := earlier.seedUser(t, username, password)
+	_, stale := earlier.csrfFrom(t, "/pages/login", nil)
+	stale = append(stale, earlier.authCookies(t, earlierID, username)...)
+
+	env := newTestEnv(t)
+	env.seedUser(t, username, password)
+
+	token, cookies := env.csrfFrom(t, "/pages/login", stale)
+
+	form := url.Values{}
+	form.Set("csrf_token", token)
+	form.Set("username", username)
+	form.Set("password", password)
+
+	w := env.post("/pages/login", form, cookies)
+	require.Equal(
+		t, http.StatusSeeOther, w.Code,
+		"a session cookie from another key must not fail the login",
+	)
+
+	// The response deletes the old session cookie and then sets the
+	// new one; a browser keeps the last.
+	var fresh *http.Cookie
+
+	for _, c := range w.Result().Cookies() {
+		if c.Name == session.SessionName {
+			fresh = c
+		}
+	}
+
+	require.NotNil(t, fresh, "login must set a session cookie")
+	assert.Equal(
+		t, "/hooks",
+		env.get("/", []*http.Cookie{fresh}).Header().Get("Location"),
+		"the new session cookie must authenticate",
+	)
+}
+
+// TestPagesLogin_ReturnsToTheRequestedPage is
+// https://git.eeqj.de/sneak/webhooker/issues/384: a page opened while
+// logged out leads to the login page, and logging in from there lands
+// on that page, query included.
+func TestPagesLogin_ReturnsToTheRequestedPage(t *testing.T) {
+	t.Parallel()
+
+	const (
+		username = "operator"
+		password = "correct-horse-battery-staple"
+	)
+
+	env := newTestEnv(t)
+	userID, _ := env.seedUser(t, username, password)
+	asked := "/hook/" + env.seedWebhook(t, userID).ID + "/events?page=2"
+
+	bounced := env.get(asked, nil)
+	require.Equal(t, http.StatusSeeOther, bounced.Code)
+
+	loginPage := bounced.Header().Get("Location")
+
+	match := regexp.MustCompile(`name="next" value="([^"]*)"`).
+		FindStringSubmatch(env.get(loginPage, nil).Body.String())
+	require.Len(t, match, 2, "the login form must carry the page")
+
+	token, cookies := env.csrfFrom(t, loginPage, nil)
+
+	form := url.Values{}
+	form.Set("csrf_token", token)
+	form.Set("username", username)
+	form.Set("password", password)
+	form.Set("next", html.UnescapeString(match[1]))
+
+	w := env.post("/pages/login", form, cookies)
+	require.Equal(t, http.StatusSeeOther, w.Code)
+	assert.Equal(t, asked, w.Header().Get("Location"))
+}
+
 // --- /user/{username} group ---
 
 // TestPasswordChange_OversizeBody_RejectedAndPasswordUnchanged
@@ -652,7 +799,344 @@ func TestPasswordChange_UnderLimit_Succeeds(t *testing.T) {
 	)
 }
 
-// --- /source/{sourceID} group ---
+// --- /hooks group ---
+
+// TestHooks_ListAndNewWebhookForm gets the webhook list through the
+// production router, follows both of its links to the new-webhook
+// form, then submits the form to the action and with the token the
+// page rendered. A mistyped route, link or form action fails here;
+// the handler tests cannot catch any of them, because they never
+// route a request.
+func TestHooks_ListAndNewWebhookForm(t *testing.T) {
+	t.Parallel()
+
+	env := newTestEnv(t)
+
+	userID, _ := env.seedUser(t, "lister", "somepassword")
+	cookies := env.authCookies(t, userID, "lister")
+
+	// The list shows its "Create Webhook" link only while it is empty.
+	createLink := env.urlFrom(
+		t, "/hooks", `href="([^"]+)"[^>]*>Create Webhook<`, cookies,
+	)
+
+	existing := env.seedWebhook(t, userID)
+
+	list := env.get("/hooks", cookies)
+	require.Equal(t, http.StatusOK, list.Code)
+	assert.Contains(
+		t, list.Body.String(), `href="/hook/`+existing.ID+`"`,
+		"the list should link the user's webhook",
+	)
+
+	// The "New Webhook" link has an icon between its href and its text.
+	newLink := env.urlFrom(
+		t, "/hooks", `href="([^"]+)"[^>]*>(?:\s*<[^>]*>)*\s*New Webhook`,
+		cookies,
+	)
+
+	token, cookies := env.csrfFrom(t, newLink, cookies)
+	action := env.urlFrom(t, newLink, `action="(/hooks[^"]*)"`, cookies)
+	assert.Equal(
+		t, action,
+		env.urlFrom(t, createLink, `action="(/hooks[^"]*)"`, cookies),
+		"both links should open the new-webhook form",
+	)
+
+	form := url.Values{}
+	form.Set("csrf_token", token)
+	form.Set("name", "created")
+
+	w := env.post(action, form, cookies)
+	require.Equal(t, http.StatusSeeOther, w.Code)
+
+	var created database.Webhook
+
+	require.NoError(t,
+		env.db.DB().Where("name = ?", "created").First(&created).Error,
+	)
+	assert.Equal(
+		t, "/hook/"+created.ID, w.Header().Get("Location"),
+		"creating a webhook should redirect to its page",
+	)
+}
+
+// --- /hook/{sourceID} group ---
+
+// TestHook_EditFormAndDelete follows the webhook page's Edit link to
+// the edit form and submits it, then deletes the webhook with the
+// form on its page, every URL and token taken from the rendered
+// pages.
+func TestHook_EditFormAndDelete(t *testing.T) {
+	t.Parallel()
+
+	env := newTestEnv(t)
+
+	userID, _ := env.seedUser(t, "editor", "somepassword")
+	cookies := env.authCookies(t, userID, "editor")
+	wh := env.seedWebhook(t, userID)
+	page := "/hook/" + wh.ID
+
+	editPage := env.urlFrom(t, page, `href="(/hook/[^/"]+/edit)"`, cookies)
+	token, cookies := env.csrfFrom(t, editPage, cookies)
+
+	form := url.Values{}
+	form.Set("csrf_token", token)
+	form.Set("name", "renamed")
+
+	w := env.post(
+		env.urlFrom(t, editPage, `action="(/hook/[^/"]+/edit)"`, cookies),
+		form, cookies,
+	)
+	require.Equal(t, http.StatusSeeOther, w.Code)
+	assert.Equal(t, page, w.Header().Get("Location"))
+
+	var edited database.Webhook
+
+	require.NoError(t, env.db.DB().First(&edited, "id = ?", wh.ID).Error)
+	assert.Equal(t, "renamed", edited.Name)
+
+	form = url.Values{}
+	form.Set("csrf_token", token)
+
+	w = env.post(
+		env.urlFrom(t, page, `action="(/hook/[^/"]+/delete)"`, cookies),
+		form, cookies,
+	)
+	require.Equal(t, http.StatusSeeOther, w.Code)
+	assert.Equal(t, "/hooks", w.Header().Get("Location"))
+	assert.Equal(
+		t, http.StatusNotFound, env.get(page, cookies).Code,
+		"a deleted webhook's page should be gone",
+	)
+}
+
+// TestHook_EntrypointActions adds, deactivates and deletes an
+// entrypoint with the forms on the webhook page, each submitted to
+// the action and with the token the page rendered.
+func TestHook_EntrypointActions(t *testing.T) {
+	t.Parallel()
+
+	env := newTestEnv(t)
+
+	userID, _ := env.seedUser(t, "epuser", "somepassword")
+	cookies := env.authCookies(t, userID, "epuser")
+	wh := env.seedWebhook(t, userID)
+	page := "/hook/" + wh.ID
+
+	token, cookies := env.csrfFrom(t, page, cookies)
+
+	form := url.Values{}
+	form.Set("csrf_token", token)
+
+	// submit posts the webhook page's form whose action pattern
+	// captures, and requires the redirect back to that page.
+	submit := func(pattern string) {
+		t.Helper()
+
+		w := env.post(env.urlFrom(t, page, pattern, cookies), form, cookies)
+		require.Equal(t, http.StatusSeeOther, w.Code)
+		require.Equal(t, page, w.Header().Get("Location"))
+	}
+
+	submit(`action="(/hook/[^/"]+/entrypoints)"`)
+
+	var added database.Entrypoint
+
+	require.NoError(t,
+		env.db.DB().First(&added, "webhook_id = ?", wh.ID).Error,
+	)
+	require.True(t, added.Active)
+
+	submit(`action="(/hook/[^/"]+/entrypoints/[^/"]+/toggle)"`)
+
+	var toggled database.Entrypoint
+
+	require.NoError(t,
+		env.db.DB().First(&toggled, "id = ?", added.ID).Error,
+	)
+	assert.False(t, toggled.Active, "the toggle should deactivate it")
+
+	submit(`action="(/hook/[^/"]+/entrypoints/[^/"]+/delete)"`)
+
+	var left int64
+
+	require.NoError(t, env.db.DB().Model(&database.Entrypoint{}).
+		Where("webhook_id = ?", wh.ID).Count(&left).Error)
+	assert.Zero(t, left, "the delete should remove the entrypoint")
+}
+
+// TestHook_TargetActions adds a target with the form on the webhook
+// page, follows its Edit link to the target edit form and submits
+// it, then deactivates and deletes it, every URL and token taken from
+// the rendered pages.
+func TestHook_TargetActions(t *testing.T) {
+	t.Parallel()
+
+	env := newTestEnv(t)
+
+	userID, _ := env.seedUser(t, "tgtuser", "somepassword")
+	cookies := env.authCookies(t, userID, "tgtuser")
+	wh := env.seedWebhook(t, userID)
+	page := "/hook/" + wh.ID
+
+	token, cookies := env.csrfFrom(t, page, cookies)
+
+	// submit posts form, with the token, to the action pattern
+	// captures on the page at from, and requires the redirect back to
+	// the webhook page.
+	submit := func(from, pattern string, form url.Values) {
+		t.Helper()
+
+		form.Set("csrf_token", token)
+
+		w := env.post(env.urlFrom(t, from, pattern, cookies), form, cookies)
+		require.Equal(t, http.StatusSeeOther, w.Code)
+		require.Equal(t, page, w.Header().Get("Location"))
+	}
+
+	submit(page, `action="(/hook/[^/"]+/targets)"`, url.Values{
+		"name": {"added"},
+		"type": {string(database.TargetTypeLog)},
+	})
+
+	editPage := env.urlFrom(
+		t, page, `href="(/hook/[^/"]+/targets/[^/"]+/edit)"`, cookies,
+	)
+	submit(editPage, `action="(/hook/[^/"]+/targets/[^/"]+/edit)"`,
+		url.Values{"name": {"renamed"}})
+
+	var edited database.Target
+
+	require.NoError(t,
+		env.db.DB().First(&edited, "webhook_id = ?", wh.ID).Error,
+	)
+	assert.Equal(t, "renamed", edited.Name)
+	require.True(t, edited.Active)
+
+	submit(page, `action="(/hook/[^/"]+/targets/[^/"]+/toggle)"`,
+		url.Values{})
+
+	var toggled database.Target
+
+	require.NoError(t,
+		env.db.DB().First(&toggled, "id = ?", edited.ID).Error,
+	)
+	assert.False(t, toggled.Active, "the toggle should deactivate it")
+
+	submit(page, `action="(/hook/[^/"]+/targets/[^/"]+/delete)"`,
+		url.Values{})
+
+	var left int64
+
+	require.NoError(t, env.db.DB().Model(&database.Target{}).
+		Where("webhook_id = ?", wh.ID).Count(&left).Error)
+	assert.Zero(t, left, "the delete should remove the target")
+}
+
+// TestHook_ResubmitFromEventLog follows the webhook page's "Full
+// Event Log" link, then resubmits a stored event with the form on
+// that page, submitted to the action and with the token the page
+// rendered.
+func TestHook_ResubmitFromEventLog(t *testing.T) {
+	t.Parallel()
+
+	env := newTestEnv(t)
+
+	userID, _ := env.seedUser(t, "resubmitter", "somepassword")
+	cookies := env.authCookies(t, userID, "resubmitter")
+	wh := env.seedWebhook(t, userID)
+	env.seedEvent(t, wh.ID, `{"resubmit":"me"}`)
+
+	logsPath := env.urlFrom(
+		t, "/hook/"+wh.ID, `href="([^"]+)"[^>]*>Full Event Log<`, cookies,
+	)
+
+	token, cookies := env.csrfFrom(t, logsPath, cookies)
+
+	form := url.Values{}
+	form.Set("csrf_token", token)
+
+	w := env.post(
+		env.urlFrom(t, logsPath, `action="(/hook/[^"]+/resubmit)"`, cookies),
+		form, cookies,
+	)
+	require.Equal(t, http.StatusSeeOther, w.Code)
+	assert.Equal(
+		t, logsPath+"?resubmit=no-targets", w.Header().Get("Location"),
+	)
+
+	webhookDB, err := env.dbMgr.GetDB(wh.ID)
+	require.NoError(t, err)
+
+	var events int64
+
+	require.NoError(t,
+		webhookDB.Model(&database.Event{}).Count(&events).Error,
+	)
+	assert.Equal(t, int64(2), events, "the resubmit stores a new event")
+}
+
+// TestHook_LinksBetweenPages follows each link to a webhook page that
+// the tests above do not: the navbar's "Webhooks" links, the back and
+// Cancel links, the list's link to a webhook, the "Full Event Log"
+// link beside the recent events, and the event log's page links. Each
+// must point where it should, and that page must render.
+func TestHook_LinksBetweenPages(t *testing.T) {
+	t.Parallel()
+
+	env := newTestEnv(t)
+
+	userID, _ := env.seedUser(t, "navigator", "somepassword")
+	cookies := env.authCookies(t, userID, "navigator")
+	wh := env.seedWebhook(t, userID)
+	tgt := env.seedTarget(t, wh.ID)
+
+	// The event log shows 25 events a page; one more gives it a second
+	// page, so it renders its Next and Previous links.
+	for range 26 {
+		env.seedEvent(t, wh.ID, "paged")
+	}
+
+	list := "/hooks"
+	newForm := list + "/new"
+	page := "/hook/" + wh.ID
+	targetEdit := page + "/targets/" + tgt.ID + "/edit"
+	events := page + "/events"
+	back := `href="([^"]+)"[^>]*>&larr; Back to `
+	cancel := `href="([^"]+)"[^>]*>Cancel<`
+
+	for _, link := range []struct{ from, pattern, want string }{
+		// The navbar on the profile page: its desktop link, then its
+		// mobile menu link.
+		{
+			"/user/navigator/",
+			`href="([^"]+)" class="btn-text">Webhooks<`,
+			list,
+		},
+		{
+			"/user/navigator/",
+			`href="([^"]+)" class="btn-text w-full[^"]*">Webhooks<`,
+			list,
+		},
+		{list, `href="(/hook/[^"]+)"`, page},
+		{newForm, back, list},
+		{newForm, cancel, list},
+		{page, back, list},
+		{page, `Recent Events</h2>\s*<a href="([^"]+)"`, events},
+		{page + "/edit", back, page},
+		{page + "/edit", cancel, page},
+		{targetEdit, back, page},
+		{targetEdit, cancel, page},
+		{events, back, page},
+		{events, `href="([^"]+)"[^>]*>Next &rarr;<`, events + "?page=2"},
+		{events + "?page=2", `href="([^"]+)"[^>]*>&larr; Previous<`, events + "?page=1"},
+	} {
+		got := env.urlFrom(t, link.from, link.pattern, cookies)
+		assert.Equal(t, link.want, got, "%s: %s", link.from, link.pattern)
+		assert.Equal(t, http.StatusOK, env.get(got, cookies).Code, got)
+	}
+}
 
 // TestSourceLogs_TruncationLinkDownloadsTheBody walks the whole
 // feature the way a user does: render the event log page through
@@ -680,11 +1164,11 @@ func TestSourceLogs_TruncationLinkDownloadsTheBody(t *testing.T) {
 	wh := env.seedWebhook(t, userID)
 	env.seedEvent(t, wh.ID, stored)
 
-	page := env.get("/source/"+wh.ID+"/logs", cookies)
+	page := env.get("/hook/"+wh.ID+"/events", cookies)
 	require.Equal(t, http.StatusOK, page.Code)
 
 	link := regexp.MustCompile(
-		`href="(/source/[^"]+/body)"`,
+		`href="(/hook/[^"]+/body)"`,
 	).FindStringSubmatch(page.Body.String())
 	require.Len(
 		t, link, 2,
@@ -730,7 +1214,7 @@ func TestSourceLogsBody_OtherUser404s(t *testing.T) {
 	const payload = "OWNERS-PAYLOAD-77c1"
 
 	evt := env.seedEvent(t, wh.ID, payload)
-	path := "/source/" + wh.ID + "/logs/" + evt.ID + "/body"
+	path := "/hook/" + wh.ID + "/events/" + evt.ID + "/body"
 
 	intruderID, _ := env.seedUser(t, "intruder", "somepassword")
 	intruder := env.authCookies(t, intruderID, "intruder")
@@ -741,7 +1225,10 @@ func TestSourceLogsBody_OtherUser404s(t *testing.T) {
 
 	anon := env.get(path, nil)
 	assert.Equal(t, http.StatusSeeOther, anon.Code)
-	assert.Equal(t, "/pages/login", anon.Header().Get("Location"))
+	assert.Equal(
+		t, "/pages/login?next="+url.QueryEscape(path),
+		anon.Header().Get("Location"),
+	)
 }
 
 // TestDeliveryReplay_PostOnlyAndCSRFProtected walks the replay action
@@ -764,7 +1251,7 @@ func TestDeliveryReplay_PostOnlyAndCSRFProtected(t *testing.T) {
 	evt := env.seedEvent(t, wh.ID, `{"replay":"me"}`)
 	dlv := env.seedFailedDelivery(t, wh.ID, evt.ID, tgt.ID)
 
-	path := "/source/" + wh.ID + "/deliveries/" + dlv.ID +
+	path := "/hook/" + wh.ID + "/deliveries/" + dlv.ID +
 		"/replay"
 
 	assert.Equal(
@@ -790,7 +1277,7 @@ func TestDeliveryReplay_PostOnlyAndCSRFProtected(t *testing.T) {
 	// The token and the action URL both come out of the rendered
 	// page, so a typo in either the route pattern or the template
 	// fails here.
-	logsPath := "/source/" + wh.ID + "/logs"
+	logsPath := "/hook/" + wh.ID + "/events"
 
 	token, cookies := env.csrfFrom(t, logsPath, cookies)
 
@@ -798,7 +1285,7 @@ func TestDeliveryReplay_PostOnlyAndCSRFProtected(t *testing.T) {
 	require.Equal(t, http.StatusOK, page.Code)
 
 	action := regexp.MustCompile(
-		`action="(/source/[^"]+/replay)"`,
+		`action="(/hook/[^"]+/replay)"`,
 	).FindStringSubmatch(page.Body.String())
 	require.Len(
 		t, action, 2,
@@ -823,6 +1310,59 @@ func TestDeliveryReplay_PostOnlyAndCSRFProtected(t *testing.T) {
 	)
 }
 
+// --- /h/{uuid} receiver ---
+
+// TestReceiver_EntrypointURLIsRateLimited takes the entrypoint URL
+// the webhook page shows and posts to it through the production
+// router until the receiver rate limit refuses it. The URL has to
+// reach the receiver, and the limit has to apply to it.
+func TestReceiver_EntrypointURLIsRateLimited(t *testing.T) {
+	t.Parallel()
+
+	const limit = 2
+
+	env := newTestEnvWithConfig(t, &config.Config{
+		DataDir:           t.TempDir(),
+		Environment:       config.EnvironmentDev,
+		ReceiverRateLimit: limit,
+	})
+
+	userID, _ := env.seedUser(t, "receiver", "somepassword")
+	cookies := env.authCookies(t, userID, "receiver")
+
+	wh := env.seedWebhook(t, userID)
+	require.NoError(t, env.db.DB().Omit(clause.Associations).Create(
+		&database.Entrypoint{
+			WebhookID: wh.ID,
+			Path:      "6f1e2a9c-4b7d-4e3a-9c2f-1d8b5a7e3c60",
+			Active:    true,
+		},
+	).Error)
+
+	page := env.get("/hook/"+wh.ID, cookies)
+	require.Equal(t, http.StatusOK, page.Code)
+
+	shown := regexp.MustCompile(`(/h/[^<]+)</code>`).
+		FindStringSubmatch(page.Body.String())
+	require.Len(
+		t, shown, 2, "the webhook page should show the entrypoint URL",
+	)
+
+	for i := range limit {
+		assert.Equal(
+			t, http.StatusOK,
+			env.post(shown[1], url.Values{}, nil).Code,
+			"request %d should reach the receiver", i,
+		)
+	}
+
+	assert.Equal(
+		t, http.StatusTooManyRequests,
+		env.post(shown[1], url.Values{}, nil).Code,
+		"the receiver rate limit must apply to the entrypoint URL",
+	)
+}
+
 // metricsConfig is a Config differing from the routing default only
 // in the two /metrics credentials.
 func metricsConfig(

internal/server/sentry.go

@@ -55,7 +55,7 @@ func sentryClientOptions(dsn, release string) sentry.ClientOptions {
 //
 // URL is the third such field. NewRequest builds it as
 // scheme://host/path (interfaces.go:183), and on the receiver route
-// that path is /webhook/<uuid> in full — a write capability, not an
+// that path is /h/<uuid> in full — a write capability, not an
 // identifier. It is rebuilt here from the chi route pattern, on every
 // route, keeping the scheme and the host.
 //

internal/server/sentry_test.go

@@ -153,7 +153,7 @@ func (c sentryCase) router() http.Handler {
 		sentryhttp.New(sentryhttp.Options{Repanic: true}).Handle,
 	)
 	router.HandleFunc("/pages/login", handler)
-	router.HandleFunc("/webhook/{uuid}", handler)
+	router.HandleFunc("/h/{uuid}", handler)
 
 	return router
 }
@@ -191,7 +191,7 @@ func sentryLoginRequest(client *sentry.Client) *http.Request {
 // concrete path carries the entrypoint capability.
 func sentryReceiverRequest(client *sentry.Client) *http.Request {
 	return sentryRequest(
-		client, "/webhook/"+sentryReceiverUUID, "payload=hello",
+		client, "/h/"+sentryReceiverUUID, "payload=hello",
 	)
 }
 
@@ -316,7 +316,7 @@ func TestSentryScrub_ReplacesTheCapabilityPathWithTheRoutePattern(
 		t, marshalEvent(t, event), sentryReceiverUUID,
 	)
 	assert.Equal(
-		t, "http://example.com/webhook/{uuid}", event.Request.URL,
+		t, "http://example.com/h/{uuid}", event.Request.URL,
 	)
 }
 
@@ -401,7 +401,7 @@ func TestSentryScrub_TransactionDispatchIsUnscrubbedWithoutTheHook(
 func TestSentryScrub_FallsBackWithoutARoutePattern(t *testing.T) {
 	t.Parallel()
 
-	concrete := "https://example.com/webhook/" + sentryReceiverUUID
+	concrete := "https://example.com/h/" + sentryReceiverUUID
 
 	// A request with no chi routing context on it at all, which is
 	// what an event captured outside the router would carry.
@@ -426,7 +426,7 @@ func TestSentryScrub_FallsBackWithoutARoutePattern(t *testing.T) {
 
 			event := sentry.NewEvent()
 			event.Request = &sentry.Request{URL: concrete}
-			event.Transaction = "POST /webhook/" +
+			event.Transaction = "POST /h/" +
 				sentryReceiverUUID
 
 			scrubbed := server.ScrubSentryRequestForTest(
@@ -459,9 +459,9 @@ func TestSentryScrub_WithholdsUnparseableValues(t *testing.T) {
 
 	event := sentry.NewEvent()
 	event.Request = &sentry.Request{
-		URL: "/webhook/" + sentryReceiverUUID,
+		URL: "/h/" + sentryReceiverUUID,
 	}
-	event.Transaction = "/webhook/" + sentryReceiverUUID
+	event.Transaction = "/h/" + sentryReceiverUUID
 
 	scrubbed := server.ScrubSentryRequestForTest(event, nil)
 	require.NotNil(t, scrubbed)

internal/server/static_assets_test.go

@@ -13,9 +13,9 @@ import (
 
 // TestBaseTemplateScriptsAreServed walks every /s/ script the base
 // template loads on each page and fetches it through the real router.
-// Alpine.js is fetched at build time rather than committed, so nothing
-// in the repo guarantees it is present: this is the check that the page
-// still gets the JavaScript it asks for.
+// Alpine.js is extracted from its tarball in 3p/ at build time, so the
+// file is not in the tree: this is the check that the page still gets
+// the JavaScript it asks for.
 func TestBaseTemplateScriptsAreServed(t *testing.T) {
 	t.Parallel()
 

internal/session/codec_test.go

@@ -19,8 +19,8 @@ import (
 )
 
 // The tests below exercise the securecookie codecs underneath the
-// store and nothing else: Session.Get only decodes, so no server-side
-// expiry check takes part in the result. They exist because
+// store and nothing else: they decode through the store itself, so no
+// server-side expiry check takes part in the result. They exist because
 // NewCookieStore gives its codecs a 30-day max age that assigning
 // store.Options does not override, which would let the codec accept a
 // cookie weeks past the cap the cookie attribute advertises.
@@ -75,10 +75,11 @@ func restamp(
 	return base64.URLEncoding.EncodeToString(payload)
 }
 
-// decodeCookie feeds value back through the store's decode path.
+// decodeCookie feeds value back through the store's decode path. It
+// asks the store rather than Session.Get, which treats a cookie that
+// does not decode as absent and so hides the codec's reason.
 func decodeCookie(
 	t *testing.T,
-	s *session.Session,
 	value string,
 ) (*sessions.Session, error) {
 	t.Helper()
@@ -94,7 +95,7 @@ func decodeCookie(
 		SameSite: http.SameSiteLaxMode,
 	})
 
-	sess, err := s.Get(req)
+	sess, err := session.NewStore(testKey()).Get(req, session.SessionName)
 	require.NotNil(t, sess)
 
 	return sess, err
@@ -105,7 +106,7 @@ func TestCodec_AcceptsCookieInsideAbsoluteCap(t *testing.T) {
 
 	s := testSession(t)
 
-	sess, err := decodeCookie(t, s, restamp(
+	sess, err := decodeCookie(t, restamp(
 		t,
 		issuedCookie(t, s),
 		time.Now().Add(-(testAbsoluteMaxAge-time.Hour)),
@@ -126,7 +127,7 @@ func TestCodec_RejectsCookiePastAbsoluteCap(t *testing.T) {
 
 	s := testSession(t)
 
-	sess, err := decodeCookie(t, s, restamp(
+	sess, err := decodeCookie(t, restamp(
 		t,
 		issuedCookie(t, s),
 		time.Now().Add(-(testAbsoluteMaxAge+time.Hour)),

internal/session/session.go

@@ -224,10 +224,22 @@ func New(
 }
 
 // Get retrieves a session for the request.
+//
+// A session cookie that does not decode -- one signed with an earlier
+// session key, say, because the database was made anew -- is treated
+// as absent: the caller gets a new, empty session and no error, and
+// the next save replaces the cookie.
 func (s *Session) Get(
 	r *http.Request,
 ) (*sessions.Session, error) {
-	return s.store.Get(r, SessionName)
+	sess, err := s.store.Get(r, SessionName)
+	if sess == nil {
+		return nil, err
+	}
+
+	// For a cookie that does not decode, gorilla/sessions returns a
+	// new, empty session alongside the error that is dropped here.
+	return sess, nil
 }
 
 // GetKey returns the raw 32-byte authentication key used for

internal/versionscript/version_script_test.go

@@ -115,8 +115,8 @@ func TestVersion_EnclosingRepositoryIsNotUsed(t *testing.T) {
 	require.Equal(t, unknown, runScript(t, inner, nil))
 }
 
-// The Docker build has no git metadata, so the version arrives as an
-// environment override. It wins over anything derivable.
+// An explicit VERSION, such as the Dockerfile's build arg, wins over
+// anything derivable.
 func TestVersion_EnvironmentOverrideWins(t *testing.T) {
 	t.Parallel()
 
@@ -128,8 +128,8 @@ func TestVersion_EnvironmentOverrideWins(t *testing.T) {
 }
 
 // An empty VERSION is treated as unset rather than stamping an empty
-// string: the Dockerfile's build arg has a non-empty default, but a
-// caller exporting VERSION= must not produce a binary reporting "".
+// string: a caller exporting VERSION= must not produce a binary
+// reporting "".
 func TestVersion_EmptyOverrideFallsBackToGit(t *testing.T) {
 	t.Parallel()
 
@@ -168,8 +168,8 @@ func TestMakefile_BuildComposesVersionAndExtraFlags(t *testing.T) {
 }
 
 // A caller can define VERSION as the empty string -- `make build
-// VERSION=`, or a `--build-arg VERSION=` reaching the Dockerfile's `make
-// build VERSION="$VERSION"`. script/version's own guard does not cover
+// VERSION=`, or the Dockerfile's `make build VERSION="$VERSION"` when no
+// VERSION build arg was given. script/version's own guard does not cover
 // that: the value never passes through the script. Stamping "" would
 // leave the binary reporting no version and the footer on "dev", which
 // is the defect this package exists for.
@@ -231,7 +231,7 @@ func TestDockerfile_BuildsThroughTheMakeTarget(t *testing.T) {
 
 	require.NotContains(t, dockerfile, "go build",
 		"a raw go build bypasses the Makefile's -X flag")
-	require.Contains(t, dockerfile, "ARG VERSION=")
+	require.Contains(t, dockerfile, "ARG VERSION")
 	require.Contains(t, dockerfile,
 		`make build VERSION="$VERSION" GO_LDFLAGS='-extldflags "-static"'`)
 }

script/assets

@@ -0,0 +1,16 @@
+#!/bin/sh
+# script/assets: extract Alpine.js from its npm package tarball, committed
+# in 3p/, to static/js/alpine.min.js, where go:embed reads it. The
+# extracted file is not committed. script/test, make build and make dev run
+# this first.
+set -eu
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+
+main() {
+    cd "$ROOT"
+    tar -xzOf 3p/alpinejs-3.14.9.tgz package/dist/cdn.min.js \
+        >static/js/alpine.min.js
+}
+
+main "$@"

script/bootstrap

@@ -4,9 +4,7 @@
 # installed tools are skipped. Base tooling comes from nix, apt, brew,
 # or apk (detected in that order); assumes NOTHING is present (not git,
 # make, or go). golangci-lint is deliberately not installed: linting runs
-# only in docker, via script/lint and Dockerfile.lint. Finishes by running
-# script/fetch-assets, which installs the hash-pinned third-party browser
-# assets the repo does not commit.
+# only in docker, via script/lint and Dockerfile.lint.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
@@ -69,11 +67,6 @@ main() {
 
     go mod download
 
-    # Third-party browser assets are not committed; fetch and verify them
-    # so a fresh clone can build and test.
-    if missing curl; then pkg_install curl curl curl curl; fi
-    "$ROOT/script/fetch-assets"
-
     echo "bootstrap complete"
 }
 

script/check

@@ -1,6 +1,7 @@
 #!/bin/sh
 # script/check: run all checks (test, lint, fmt-check). Our own
-# extension to scripts-to-rule-them-all. Must not modify any files.
+# extension to scripts-to-rule-them-all.
+# Writes only the ignored static/js/alpine.min.js, through script/test.
 # Generic: usually needs no adaptation.
 set -eu
 

script/docker

@@ -2,9 +2,9 @@
 # script/docker: build the Docker image tagged with the project name.
 # The tag comes from script/projectname.
 #
-# .dockerignore excludes .git/, so the builder stage cannot derive the
-# version itself. It is resolved here, where the checkout is, and passed
-# in as a build arg; without it the image would stamp itself "unknown".
+# The version script/version resolves here goes in as the VERSION build
+# arg, which takes precedence over what the build would derive from the
+# .git in its context.
 set -eu
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"

script/fetch-assets

@@ -1,104 +0,0 @@
-#!/bin/sh
-# script/fetch-assets: download the third-party browser assets the web UI
-# ships and install them under static/. Minified bundles are not committed
-# (REPO_POLICIES.md: no build artifacts in version control), so the build
-# fetches them here. Every download is verified against a hardcoded sha256
-# before it is installed, and any mismatch aborts. Idempotent: an asset
-# already present with its pinned hash is left alone.
-set -eu
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-
-# The sha256 of each installed asset lives in static/vendor.sha256, in
-# sha256sum(1) format, with paths relative to static/. That file is the
-# single source of truth: this script verifies against it, and
-# static/vendor_test.go asserts the bytes embedded into the binary match
-# it, so the hash cannot rot into a value nothing checks.
-MANIFEST="static/vendor.sha256"
-
-# Alpine.js 3.14.9, 2026-08-17. Fetched from registry.npmjs.org, the
-# publisher of record; the jsDelivr and unpkg copies are mirrors of this
-# same tarball. dist/cdn.min.js is the browser build Alpine publishes for
-# a <script> tag.
-ALPINE_VERSION="3.14.9"
-ALPINE_URL="https://registry.npmjs.org/alpinejs/-/alpinejs-${ALPINE_VERSION}.tgz"
-# sha256 of alpinejs-3.14.9.tgz
-ALPINE_TARBALL_SHA256="97dad7c0c81e659cfc8e7700055da9770f8186187cb9a8a76efb57e00d5ce52a"
-ALPINE_MEMBER="package/dist/cdn.min.js"
-ALPINE_DEST="js/alpine.min.js"
-
-sha256_of() {
-    if command -v sha256sum >/dev/null 2>&1; then
-        sha256sum "$1" | cut -d' ' -f1
-    else
-        shasum -a 256 "$1" | cut -d' ' -f1
-    fi
-}
-
-# expected_sha256 <path-relative-to-static>
-expected_sha256() {
-    awk -v want="$1" '$2 == want { print $1; found = 1 }
-        END { if (!found) exit 1 }' "$ROOT/$MANIFEST"
-}
-
-# verify <file> <expected-sha256> <what>
-verify() {
-    actual="$(sha256_of "$1")"
-    if [ "$actual" != "$2" ]; then
-        echo "fetch-assets: sha256 mismatch for $3" >&2
-        echo "  expected: $2" >&2
-        echo "  actual:   $actual" >&2
-        exit 1
-    fi
-}
-
-# up_to_date <path-relative-to-static> <expected-sha256>
-up_to_date() {
-    [ -f "$ROOT/static/$1" ] || return 1
-    [ "$(sha256_of "$ROOT/static/$1")" = "$2" ]
-}
-
-fetch_alpine() {
-    want="$(expected_sha256 "$ALPINE_DEST")"
-
-    if up_to_date "$ALPINE_DEST" "$want"; then
-        echo "fetch-assets: static/$ALPINE_DEST already at $want"
-        return 0
-    fi
-
-    echo "fetch-assets: fetching Alpine.js $ALPINE_VERSION from $ALPINE_URL"
-    tmp="$(mktemp -d)"
-    trap 'rm -rf "$tmp"' EXIT INT TERM
-    curl -fsSL -o "$tmp/alpine.tgz" "$ALPINE_URL"
-    verify "$tmp/alpine.tgz" "$ALPINE_TARBALL_SHA256" "alpinejs-${ALPINE_VERSION}.tgz"
-    tar -xzOf "$tmp/alpine.tgz" "$ALPINE_MEMBER" >"$tmp/alpine.min.js"
-    verify "$tmp/alpine.min.js" "$want" "$ALPINE_MEMBER from alpinejs-${ALPINE_VERSION}.tgz"
-
-    mkdir -p "$(dirname "$ROOT/static/$ALPINE_DEST")"
-    cp "$tmp/alpine.min.js" "$ROOT/static/$ALPINE_DEST"
-    rm -rf "$tmp"
-    trap - EXIT INT TERM
-    echo "fetch-assets: installed static/$ALPINE_DEST ($want)"
-}
-
-# Re-check every manifest entry against what is now on disk, so an entry
-# no script installs fails loudly instead of passing silently.
-verify_manifest() {
-    while read -r want path; do
-        case "$want" in '' | '#'*) continue ;; esac
-        if [ ! -f "$ROOT/static/$path" ]; then
-            echo "fetch-assets: $MANIFEST lists static/$path, which is missing" >&2
-            exit 1
-        fi
-        verify "$ROOT/static/$path" "$want" "static/$path"
-    done <"$ROOT/$MANIFEST"
-}
-
-main() {
-    cd "$ROOT"
-    fetch_alpine
-    verify_manifest
-    echo "fetch-assets: all assets in $MANIFEST verified"
-}
-
-main "$@"

script/test

@@ -22,13 +22,24 @@
 # The one figure above 90s is GOMAXPROCS 1, a synthetic core floor rather than
 # a condition CI runs under. If a CPU-limited runner ever puts a real run near
 # 67s, that is the datum to revisit the org figure with.
+#
+# -p 4 -parallel 8 keep the run under 2 GB of memory: at most four test
+# binaries build or run at once, each with at most eight parallel tests. Under
+# -race every test binary and every link costs a few hundred MB, so the
+# defaults (one per core) add up to several GB on a many-core host.
+#
+# No -v: the Docker build cuts each step's log off at 2 MiB, and verbose output
+# from the whole suite passes that before a failure is printed. Without it, go
+# test prints one result line per package and, for a package that fails,
+# everything its tests wrote, application log lines included.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    go test -v -race -timeout 90s ./...
+    "$ROOT/script/assets"
+    go test -race -p 4 -parallel 8 -timeout 90s ./...
 }
 
 main "$@"

script/version

@@ -7,18 +7,16 @@
 #
 # Order of precedence:
 #
-#   1. $VERSION, if set and non-empty. This is how the value reaches a
-#      build that cannot derive it: .dockerignore excludes .git/, so the
-#      builder stage has no git metadata and the Dockerfile takes the
-#      value as a build arg instead.
+#   1. $VERSION, if set and non-empty: an explicit value, such as the
+#      Dockerfile's VERSION build arg.
 #   2. `git describe --tags --always --dirty` against this checkout. At
 #      a clean tagged commit that is exactly the tag; otherwise it
 #      carries the short SHA, the commit distance when a tag is
 #      reachable, and a -dirty suffix for uncommitted changes.
 #   3. "unknown", for a tree with no git metadata and no $VERSION -- a
-#      source tarball, or `docker build .` with no --build-arg. That
-#      case must not fail the build and must not name a tag the tree may
-#      not be at, so it names nothing.
+#      source tarball, or a `docker build` with no .git in its context
+#      and no VERSION build arg. That case must not fail the build and
+#      must not name a tag the tree may not be at, so it names nothing.
 #
 # The git step insists the enclosing repository is this checkout, not
 # merely some repository above it: an unpacked tarball sitting inside an

static/vendor.sha256

@@ -1 +0,0 @@
-3ed1eed252488921df65e363d6715deb04d7f92aaedb9e52199fdf73cb1e0ad3  js/alpine.min.js

static/vendor_test.go

@@ -1,92 +0,0 @@
-package static_test
-
-import (
-	"bufio"
-	"crypto/sha256"
-	"encoding/hex"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"sneak.berlin/go/webhooker/static"
-)
-
-const manifestPath = "vendor.sha256"
-
-// fetchHint is appended to every failure here: the assets the manifest
-// covers are fetched by the build, not committed, so a fresh clone that
-// has not run script/fetch-assets fails this test and should be told why.
-const fetchHint = "run `script/fetch-assets` (or `make assets`) to install " +
-	"the pinned third-party assets"
-
-// TestVendoredAssetsMatchManifest asserts that every asset listed in
-// static/vendor.sha256 is embedded in the binary with exactly the pinned
-// bytes. script/fetch-assets verifies the same hashes at download time;
-// this test verifies them again on what actually ships, so a build that
-// skipped, cached, or subverted the fetch cannot produce a binary serving
-// unpinned third-party JavaScript.
-func TestVendoredAssetsMatchManifest(t *testing.T) {
-	t.Parallel()
-
-	entries := readManifest(t)
-	require.NotEmpty(t, entries, "%s lists no assets", manifestPath)
-
-	for path, want := range entries {
-		t.Run(path, func(t *testing.T) {
-			t.Parallel()
-
-			data, err := static.Static.ReadFile(path)
-			require.NoErrorf(
-				t, err,
-				"%s is listed in %s but is not embedded; %s",
-				path, manifestPath, fetchHint,
-			)
-
-			sum := sha256.Sum256(data)
-			got := hex.EncodeToString(sum[:])
-			require.Equalf(
-				t, want, got,
-				"embedded %s does not match its pinned sha256 in %s; %s",
-				path, manifestPath, fetchHint,
-			)
-		})
-	}
-}
-
-// readManifest parses static/vendor.sha256, which is in sha256sum(1)
-// format with paths relative to static/.
-func readManifest(t *testing.T) map[string]string {
-	t.Helper()
-
-	f, err := os.Open(manifestPath)
-	require.NoError(t, err, "opening %s", manifestPath)
-
-	defer func() { require.NoError(t, f.Close()) }()
-
-	entries := make(map[string]string)
-	scanner := bufio.NewScanner(f)
-
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-
-		fields := strings.Fields(line)
-		require.Lenf(
-			t, fields, 2,
-			"%s: malformed entry %q, want \"<sha256>  <path>\"",
-			manifestPath, line,
-		)
-
-		sum, path := fields[0], fields[1]
-		require.Lenf(t, sum, 64, "%s: %q is not a sha256", manifestPath, sum)
-		entries[path] = sum
-	}
-
-	require.NoError(t, scanner.Err(), "reading %s", manifestPath)
-
-	return entries
-}

templates/login.html

@@ -24,6 +24,7 @@
 
             <form method="POST" action="/pages/login" class="space-y-6">
                 <input type="hidden" name="csrf_token" value="{{.CSRFToken}}">
+                <input type="hidden" name="next" value="{{.Next}}">
                 <div class="form-group">
                     <label for="username" class="label">Username</label>
                     <input