Keep the entrypoint UUID out of webhooker's own logs (closes #531)

On the receiver route the access log and the per-entrypoint 429 line
name the route pattern whatever the status. A request chi never routed,
such as a dev-mode CORS preflight to the receiver, logs (unmatched)
whatever the status. The received line names the entrypoint and webhook
IDs, and the unknown-entrypoint line logs no path. The pattern is
middleware.ReceiverRoute, which routes.go registers the receiver with.

The README says the proxy's access log holds the UUID and must be
protected like the URL, and its access-log, rate-limit, Sentry and
log-size passages now match the code.

Model: opus-5-5

internal/handlers/logbound_test.go

@@ -1,19 +1,15 @@
 package handlers_test
 
-// The handler-side half of the log-field audit. Two slog calls in
-// this package reach a value an UNAUTHENTICATED client picks outright
-// and of a length it picks outright:
+// The handler-side half of the log-field audit. The slog calls in
+// this package that reach a value an UNAUTHENTICATED client picks
+// outright, and of a length it picks outright, are the failed-login
+// DEBUG lines, whose username is a form field.
 //
-//   - 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.
-//
-// Both are at DEBUG, which is off in production by default. That is
+// They are at DEBUG, which is off in production by default. That is
 // not a bound: an operator turning DEBUG on to diagnose a flood must
-// not thereby hand the flood an unbounded write. Both spend the same
-// internal/logfield budget as the access log, and both are held here
-// to middleware.MaxAccessLogLineBytes.
+// not thereby hand the flood an unbounded write. They spend the same
+// internal/logfield budget as the access log, and are held here to
+// middleware.MaxAccessLogLineBytes.
 //
 // The two login lines past the username lookup — "invalid password"
 // and "user logged in" — carry the same cap without needing it, since
@@ -260,43 +256,6 @@ func postLoginWithPassword(
 	return w.Code
 }
 
-// TestUnknownEntrypoint_LogLineDoesNotTrackPathSize drives 8 KB of
-// client-chosen path at the unauthenticated receiver's
-// unknown-entrypoint DEBUG line and holds it to the same ceiling the
-// access log states.
-func TestUnknownEntrypoint_LogLineDoesNotTrackPathSize(t *testing.T) {
-	t.Parallel()
-
-	for handlerName, newHandler := range logHandlers() {
-		for fillName, fill := range escapeFills() {
-			t.Run(handlerName+"/"+fillName, func(t *testing.T) {
-				t.Parallel()
-
-				h, buf := capturingHandlers(t, newHandler)
-				router := receiverRouter(h)
-
-				for i := range floodRequests {
-					assert.Equal(
-						t,
-						http.StatusNotFound,
-						postReceiver(
-							t, router,
-							oversizedFill(fill)+
-								strings.Repeat("y", i),
-						),
-					)
-				}
-
-				lines := logLines(t, buf)
-				require.Len(t, lines, floodRequests)
-				assertNoClientText(t, buf)
-
-				assertBoundedFlood(t, buf.Len())
-			})
-		}
-	}
-}
-
 // TestFailedLogin_LogLineDoesNotTrackUsernameSize drives 8 KB of
 // client-chosen username at the unauthenticated login endpoint's
 // DEBUG line and holds it to the same ceiling.

internal/handlers/webhook.go

@@ -10,7 +10,6 @@ import (
 	"gorm.io/gorm"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/delivery"
-	"sneak.berlin/go/webhooker/internal/logfield"
 	"sneak.berlin/go/webhooker/internal/middleware"
 )
 
@@ -49,14 +48,13 @@ func (h *Handlers) HandleWebhook() http.HandlerFunc {
 			return
 		}
 
-		// Logged only once the UUID is known to name a real
-		// entrypoint. The UUID comes straight out of the path on
-		// the one unauthenticated endpoint, so logging it before
-		// the lookup let a client write an INFO line per invented
-		// path; the request itself is already in the access log
-		// and a miss is already logged at DEBUG.
+		// Logged only once the lookup has found the entrypoint, so
+		// an invented path writes no INFO line; a miss is logged at
+		// DEBUG. The entrypoint is named by its ID: the UUID is its
+		// credential and is never logged.
 		h.log.Info("webhook request received",
-			"entrypoint_uuid", entrypointUUID,
+			"entrypoint_id", entrypoint.ID,
+			"webhook_id", entrypoint.WebhookID,
 			"method", r.Method,
 			"remoteIP", middleware.RemoteIP(r),
 			"clientIP", middleware.ClientIP(r),
@@ -133,17 +131,10 @@ func (h *Handlers) lookupEntrypoint(
 		"path = ?", entrypointUUID,
 	).First(&entrypoint)
 	if result.Error != nil {
-		// 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
-		// turning it on from restoring an unbounded write.
-		h.log.Debug(
-			"entrypoint not found",
-			"path", logfield.Truncate(
-				entrypointUUID, logfield.MaxBytes,
-			),
-		)
+		// Not even an unknown UUID is logged. The receiver's log
+		// lines never carry the path segment, which is a credential
+		// whenever it names an entrypoint.
+		h.log.Debug("entrypoint not found")
 		http.NotFound(w, r)
 
 		return entrypoint, false

internal/handlers/webhook_test.go

@@ -12,12 +12,15 @@ import (
 	"testing"
 
 	"github.com/go-chi/chi"
+	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"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/middleware"
+	"sneak.berlin/go/webhooker/internal/middleware/middlewaretest"
 )
 
 // TestHandleWebhook_LogsClientNextToThePeer checks that the
@@ -99,6 +102,87 @@ func TestHandleWebhook_LogsClientNextToThePeer(t *testing.T) {
 	}
 }
 
+// TestHandleWebhook_LogsNoEntrypointUUID sends an accepted event, a
+// request over the receiver rate limit and a request for an unknown
+// UUID through the receiver as routes.go mounts it, and checks that
+// nothing logged, at any level, carries either UUID.
+func TestHandleWebhook_LogsNoEntrypointUUID(t *testing.T) {
+	t.Parallel()
+
+	var (
+		h  *handlers.Handlers
+		db *database.Database
+	)
+
+	cfg := &config.Config{DataDir: t.TempDir(), ReceiverRateLimit: 1}
+
+	app := newTestAppWithConfig(t, cfg, &h, &db)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	buf := new(bytes.Buffer)
+	log := slog.New(slog.NewJSONHandler(
+		buf, &slog.HandlerOptions{Level: slog.LevelDebug},
+	))
+	h.SetLogForTest(log)
+	mw := middlewaretest.New(t, log, cfg, nil)
+
+	webhook := seedWebhook(t, db)
+	entrypoint := &database.Entrypoint{
+		WebhookID: webhook.ID,
+		Path:      uuid.New().String(),
+		Active:    true,
+	}
+	require.NoError(t, db.DB().Omit(clause.Associations).
+		Create(entrypoint).Error)
+
+	unknownUUID := uuid.New().String()
+
+	router := chi.NewRouter()
+	router.Use(mw.Logging())
+	router.With(mw.ReceiverRateLimit()).HandleFunc(
+		middleware.ReceiverRoute, h.HandleWebhook(),
+	)
+
+	// In order: the limit is one request per minute per path, so the
+	// second request for the known UUID is the rejected one.
+	for _, step := range []struct {
+		entrypointUUID string
+		wantStatus     int
+	}{
+		{entrypoint.Path, http.StatusOK},
+		{entrypoint.Path, http.StatusTooManyRequests},
+		{unknownUUID, http.StatusNotFound},
+	} {
+		req := httptest.NewRequestWithContext(
+			context.Background(), http.MethodPost,
+			"/h/"+step.entrypointUUID, strings.NewReader("{}"),
+		)
+		w := httptest.NewRecorder()
+		router.ServeHTTP(w, req)
+
+		require.Equal(t, step.wantStatus, w.Code)
+	}
+
+	// The lines this test is about were all written, so the checks
+	// below are not passing on an empty log.
+	for _, msg := range []string{
+		"webhook request received",
+		"webhook receiver rate limit exceeded",
+		"entrypoint not found",
+	} {
+		assert.Contains(t, buf.String(), `"msg":"`+msg+`"`)
+	}
+
+	assert.NotContains(t, buf.String(), entrypoint.Path)
+	assert.NotContains(t, buf.String(), unknownUUID)
+
+	line := receivedLine(t, buf)
+	assert.Equal(t, entrypoint.ID, line["entrypoint_id"])
+	assert.Equal(t, webhook.ID, line["webhook_id"])
+}
+
 // receivedLine returns the one "webhook request received" line in the
 // captured JSON log.
 func receivedLine(t *testing.T, buf *bytes.Buffer) map[string]any {

internal/middleware/accesslog_test.go

@@ -7,6 +7,7 @@ import (
 	"log/slog"
 	"net/http"
 	"net/http/httptest"
+	"strconv"
 	"strings"
 	"testing"
 
@@ -27,6 +28,13 @@ const floodRequests = 64
 // line for a redirected or rejected request may contain it.
 const attackerMarker = "QQATTACKERTEXTQQ"
 
+// knownEntrypointUUID and failingEntrypointUUID are the UUIDs the
+// stand-in receiver in accessLogRouter answers 200 and 500 to.
+const (
+	knownEntrypointUUID   = "6f1e2a9c-4b7d-4e3a-9c2f-1d8b5a7e3c60"
+	failingEntrypointUUID = "0b7c3e5a-2d9f-4a61-8e4b-7c1d6f2a9e35"
+)
+
 // maxLineBytes bounds a single access log line whose client-supplied
 // fields are of ordinary size. Well above what the fixed fields need,
 // well below the length of the oversized input the amplification tests
@@ -132,17 +140,21 @@ func accessLogRouter(m *middleware.Middleware) *chi.Mux {
 	)
 
 	router.HandleFunc(
-		"/h/{uuid}",
+		middleware.ReceiverRoute,
 		func(w http.ResponseWriter, r *http.Request) {
-			// Stands in for the real handler: an unknown entrypoint
-			// UUID 404s, a known one succeeds.
-			if chi.URLParam(r, "uuid") != "known" {
+			// Stands in for the real handler: a known entrypoint
+			// UUID succeeds, a failing one is a server error, and
+			// any other 404s.
+			switch chi.URLParam(r, "uuid") {
+			case knownEntrypointUUID:
+				w.WriteHeader(http.StatusOK)
+			case failingEntrypointUUID:
+				http.Error(
+					w, "boom", http.StatusInternalServerError,
+				)
+			default:
 				http.Error(w, "not found", http.StatusNotFound)
-
-				return
 			}
-
-			w.WriteHeader(http.StatusOK)
 		},
 	)
 
@@ -649,17 +661,84 @@ func TestAccessLog_SuccessKeepsConcretePathAndRedactsQuery(
 	router := accessLogRouter(m)
 
 	assert.Equal(
-		t, http.StatusOK, get(t, router, "/h/known?src=ci"),
+		t, http.StatusOK,
+		get(t, router, "/.well-known/healthcheck?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, "/h/known?(redacted)", entries[0]["url"])
+	assert.Equal(
+		t, "/.well-known/healthcheck?(redacted)", entries[0]["url"],
+	)
 	assert.NotContains(t, buf.String(), "src=ci")
 }
 
+// TestAccessLog_ReceiverNeverLogsTheUUID covers the two statuses that
+// keep the concrete path on every other route. On the receiver that
+// path carries the entrypoint UUID, so the line names the route
+// pattern instead.
+func TestAccessLog_ReceiverNeverLogsTheUUID(t *testing.T) {
+	t.Parallel()
+
+	for entrypointUUID, wantStatus := range map[string]int{
+		knownEntrypointUUID:   http.StatusOK,
+		failingEntrypointUUID: http.StatusInternalServerError,
+	} {
+		t.Run(strconv.Itoa(wantStatus), func(t *testing.T) {
+			t.Parallel()
+
+			m, buf := capturingMiddleware(t)
+			router := accessLogRouter(m)
+
+			assert.Equal(
+				t, wantStatus,
+				get(t, router, "/h/"+entrypointUUID+"?src=ci"),
+			)
+
+			entries := accessLogEntries(t, buf)
+			require.Len(t, entries, 1)
+			assert.Equal(t, middleware.ReceiverRoute, entries[0]["url"])
+			assert.NotContains(t, buf.String(), entrypointUUID)
+		})
+	}
+}
+
+// TestAccessLog_ReceiverPreflightNeverLogsTheUUID sends a CORS
+// preflight to the receiver in dev, in the production middleware
+// order. CORS answers it with 200 before chi routes it, so the line
+// names no route and carries no UUID.
+func TestAccessLog_ReceiverPreflightNeverLogsTheUUID(t *testing.T) {
+	t.Parallel()
+
+	m, buf := capturingMiddleware(t)
+
+	router := chi.NewRouter()
+	router.Use(m.Logging())
+	router.Use(m.CORS())
+	router.HandleFunc(
+		middleware.ReceiverRoute,
+		func(w http.ResponseWriter, _ *http.Request) {
+			w.WriteHeader(http.StatusOK)
+		},
+	)
+
+	req := httptest.NewRequestWithContext(
+		context.Background(), http.MethodOptions,
+		"/h/"+knownEntrypointUUID, nil,
+	)
+	req.Header.Set("Origin", "https://sender.example")
+	req.Header.Set("Access-Control-Request-Method", http.MethodPost)
+
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+	assert.Equal(t, http.StatusOK, w.Code)
+
+	entries := accessLogEntries(t, buf)
+	require.Len(t, entries, 1)
+	assert.Equal(t, unmatchedRouteLiteral, entries[0]["url"])
+	assert.NotContains(t, buf.String(), knownEntrypointUUID)
+}
+
 func TestAccessLog_ServerErrorKeepsConcreteURL(t *testing.T) {
 	t.Parallel()
 

internal/middleware/logbound_test.go

@@ -10,8 +10,10 @@ package middleware_test
 //     the client's choosing.
 //   - CSRF's 403 rejection, at WARN, also registered ahead of
 //     RequireAuth.
-//   - The rate limiters' 429 rejection, at WARN, on the
-//     unauthenticated receiver among others.
+//   - The rate limiters' 429 rejection, at WARN. On the receiver
+//     route it names the route pattern rather than the path, and
+//     the limiters that log a path sit behind RequireAuth, so its cap
+//     is defensive.
 //   - RequireAuth's own unauthenticated-request line, at DEBUG.
 //   - RecordLoginFailure's throttle rejection, at WARN. Its cap is
 //     defensive rather than load-bearing today: chi pins the one
@@ -268,10 +270,14 @@ func logSites() map[string]logSite {
 			send:       postNoToken,
 			wantStatus: http.StatusForbidden,
 		},
-		// The per-entrypoint receiver limiter, unauthenticated. Its
-		// bucket is keyed on the path, so the first request through a
-		// fresh path is served and only the ones after it are
-		// rejected; sendUntilLimited absorbs that.
+		// The 429 line every limiter but the aggregate one shares.
+		// Mounted outside any route, as here, it logs the path, as
+		// it does for the limiters behind RequireAuth; on
+		// ReceiverRoute it names the pattern instead. The
+		// per-entrypoint receiver limiter's bucket is keyed on the
+		// path, so the first request through a fresh path is served
+		// and only the ones after it are rejected; sendUntilLimited
+		// absorbs that.
 		"receiver rate limit 429": {
 			build: func(
 				t *testing.T, m *middleware.Middleware,

internal/middleware/metrics.go

@@ -41,7 +41,8 @@ const unmatchedMethod = unmatchedRoute
 // 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.
+// while doing it. The access log and the 429 line read it for the
+// same reason: see ReceiverRoute.
 //
 // chi populates the route context during routeHTTP, so this is only
 // valid once routing has run. Every caller below is on the recording

internal/middleware/middleware.go

@@ -13,7 +13,6 @@ import (
 	"time"
 
 	basicauth "github.com/99designs/basicauth-go"
-	"github.com/go-chi/chi"
 	"github.com/go-chi/chi/middleware"
 	"github.com/go-chi/cors"
 	"github.com/prometheus/client_golang/prometheus"
@@ -96,14 +95,14 @@ const (
 	// It is also the ceiling on every OTHER line this service writes
 	// THROUGH SLOG that carries text an UNAUTHENTICATED client
 	// supplies. Those lines — the MaxBodySize rejection, the CSRF
-	// rejection, the rate-limit rejection, the unauthenticated-request
-	// and unknown-entrypoint DEBUG lines, the failed-login DEBUG
-	// lines, and the two login-throttle WARN lines ("login failure
-	// limit exceeded" in loginguard.go and "password verification
-	// capacity exhausted" in internal/handlers/auth.go) — spend the
-	// same per-field budgets, and each carries strictly fewer
-	// client-supplied fields than the access log does,
-	// so none of them can reach a width the access log cannot. That is
+	// rejection, the unauthenticated-request DEBUG line, the
+	// failed-login DEBUG lines, and the two login-throttle WARN
+	// lines ("login failure limit exceeded" in loginguard.go and
+	// "password verification capacity exhausted" in
+	// internal/handlers/auth.go) — spend the same per-field budgets,
+	// and each carries strictly fewer client-supplied fields than the
+	// access log does, so none of them can reach a width the access
+	// log cannot. That is
 	// asserted directly, per line and under both handlers, rather than
 	// left to the reasoning: see logbound_test.go in this package and
 	// in internal/handlers.
@@ -151,6 +150,12 @@ const (
 	MaxAccessLogLineBytes = 2560
 )
 
+// ReceiverRoute is the route pattern the webhook receiver is served
+// at. Its path carries the entrypoint UUID, which is the receiver's
+// only credential, so the log lines this package writes name a
+// request on this route by the pattern, never by its path.
+const ReceiverRoute = "/h/{uuid}"
+
 //nolint:revive // MiddlewareParams is a standard fx naming convention.
 type MiddlewareParams struct {
 	fx.In
@@ -268,14 +273,14 @@ func (lrw *loggingResponseWriter) Unwrap() http.ResponseWriter {
 // marker.
 //
 // The path on those branches is bounded by the service's routes or by
-// the operator's data — a 2xx on the receiver means the UUID named a
-// stored entrypoint, a 2xx under /s means the file is in the embedded
-// tree. The query is not bounded by anything: /.well-known/healthcheck
-// and /s/* take no authentication and sit behind no rate limiter, and
-// /pages/login behind only the login limiter, so any of them will
-// answer 200 to a URL carrying an arbitrary number of arbitrary bytes
-// after the '?'. Keeping the path and dropping the query is what makes
-// this branch as bounded as the pattern branches below.
+// the operator's data — a 2xx under /s means the file is in the
+// embedded tree. The query is not bounded by anything:
+// /.well-known/healthcheck and /s/* take no authentication and sit
+// behind no rate limiter, and /pages/login behind only the login
+// limiter, so any of them will answer 200 to a URL carrying an
+// arbitrary number of arbitrary bytes after the '?'. Keeping the path
+// and dropping the query is what makes this branch as bounded as the
+// pattern branches below.
 //
 // Nothing debuggable is lost. The only query parameters the service
 // reads are the login page's `next`, the page to return to,
@@ -297,36 +302,40 @@ func concreteLogURL(r *http.Request) string {
 
 // accessLogURL returns the value for the access log's url field.
 //
-// 2xx and 5xx responses get the concrete path (see concreteLogURL). A
-// success resolved against a static route or against the operator's
-// own data — on the receiver, a 2xx means the UUID named a stored
-// entrypoint — and a server error is our own bug, where the exact URL
-// is the primary evidence and which no client can provoke at will.
+// On ReceiverRoute it is the route pattern whatever the status, so
+// the entrypoint UUID in the path is never logged. A request chi never
+// routed gets unmatchedRoute whatever the status, for the same reason:
+// in dev, CORS answers a preflight to the receiver before routing.
+//
+// On every other route, 2xx and 5xx responses get the concrete path
+// (see concreteLogURL). A success resolved against a static route or
+// against the operator's own data, and a server error is our own bug,
+// where the exact URL is the primary evidence and which no client can
+// provoke at will.
 //
 // 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 /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
-// router's own table, so it is bounded by the service's routes while
-// still naming which class of request was rejected.
+// the outcomes an unauthenticated client drives for free, such as a
+// 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 router's own table, so it is
+// bounded by the service's routes while still naming which class of
+// request was rejected.
 //
 // The pattern is only populated once routing has run, so this must be
 // called after the handler returns, not before.
 func accessLogURL(r *http.Request, status int) string {
+	pattern := routePatternID(r.Context())
+	if pattern == ReceiverRoute || pattern == unmatchedRoute {
+		return pattern
+	}
+
 	if status < http.StatusMultipleChoices ||
 		status >= http.StatusInternalServerError {
 		return concreteLogURL(r)
 	}
 
-	if rc := chi.RouteContext(r.Context()); rc != nil {
-		if pattern := rc.RoutePattern(); pattern != "" {
-			return pattern
-		}
-	}
-
-	return unmatchedRoute
+	return pattern
 }
 
 // Logging returns middleware that logs each HTTP request with

internal/middleware/ratelimit.go

@@ -259,26 +259,28 @@ func (m *Middleware) clientAddr(r *http.Request) (netip.Addr, bool) {
 	return peer, true
 }
 
-// tooManyRequests returns the 429 handler used by the
-// password-change and per-entrypoint receiver limiters: it logs the
+// tooManyRequests returns the 429 handler used by the postRateLimit
+// limiters and the per-entrypoint receiver limiter: it logs the
 // rejection with logMessage and answers with responseMessage.
 // httprate adds the Retry-After header (RFC 6585). The aggregate
 // receiver limiter uses floodTooManyRequests instead.
 //
-// The path is capped against the same budget as the access log's url
-// field. The per-entrypoint receiver limiter is unauthenticated and
-// its path is a client-chosen segment of client-chosen length, so at
-// WARN an uncapped path would let a sender pick the size of the line
-// it writes — the same defect the access log capping closed.
+// On ReceiverRoute the line names the route pattern, so the
+// entrypoint UUID in the path is never logged. Elsewhere it names the
+// path, capped against the same budget as the access log's url field;
+// the limiters there sit behind RequireAuth, so the cap is defensive.
 func (m *Middleware) tooManyRequests(
 	logMessage, responseMessage string,
 ) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
+		path := r.URL.Path
+		if routePatternID(r.Context()) == ReceiverRoute {
+			path = ReceiverRoute
+		}
+
 		m.log.Warn(
 			logMessage,
-			"path", logfield.Truncate(
-				r.URL.Path, logfield.MaxBytes,
-			),
+			"path", logfield.Truncate(path, logfield.MaxBytes),
 			"remoteIP", RemoteIP(r),
 			"clientIP", ClientIP(r),
 		)

internal/server/routes.go

@@ -6,7 +6,8 @@ import (
 
 	sentryhttp "github.com/getsentry/sentry-go/http"
 	"github.com/go-chi/chi"
-	"github.com/go-chi/chi/middleware"
+	chimw "github.com/go-chi/chi/middleware"
+	"sneak.berlin/go/webhooker/internal/middleware"
 	"sneak.berlin/go/webhooker/static"
 )
 
@@ -60,7 +61,7 @@ func (s *Server) SetupRoutes() {
 }
 
 func (s *Server) setupGlobalMiddleware() {
-	s.router.Use(middleware.RequestID)
+	s.router.Use(chimw.RequestID)
 	s.router.Use(s.mw.SecurityHeaders())
 	s.router.Use(s.mw.Logging())
 
@@ -345,7 +346,7 @@ func (s *Server) setupWebhookRoutes() {
 	// unauthenticated endpoint's body; TestReceiver_OversizeBodyRefused
 	// pins it.
 	s.router.With(s.mw.ReceiverRateLimit()).HandleFunc(
-		"/h/{uuid}",
+		middleware.ReceiverRoute,
 		s.h.HandleWebhook(),
 	)
 }