clawbot
e628dfe6cf
check / check (push) Waiting to run
Recoverer comes first, so it wrote the 500 only after the panic had passed the request log and the metrics, which both recorded 200. Write500OnPanic, placed after the request log and after the metrics, writes the 500 as the panic passes and panics again, so Sentry and Recoverer still get it. Recoverer now writes its 500 only when no status was written, so the server logs no superfluous WriteHeader call. The test also requires Recoverer's log line for the handler's panic, so it fails if Write500OnPanic stops passing the panic on. Model: opus-5-5
91 lines
3.0 KiB
Go
91 lines
3.0 KiB
Go
package server
|
|
|
|
import (
|
|
"time"
|
|
|
|
sentryhttp "github.com/getsentry/sentry-go/http"
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/go-chi/chi/v5/middleware"
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
"github.com/prometheus/client_golang/prometheus/collectors"
|
|
"github.com/prometheus/client_golang/prometheus/promhttp"
|
|
)
|
|
|
|
const (
|
|
requestTimeout = 60 * time.Second
|
|
|
|
// maxRequestBodyBytes caps every request body. A route group
|
|
// can mount s.mw.MaxBodyBytes with a smaller value to lower
|
|
// its bound, but cannot raise it: this cap runs first.
|
|
maxRequestBodyBytes int64 = 1 << 20 // 1 MiB
|
|
|
|
// metricsRequestsPerMinute is how many requests to /metrics each
|
|
// client address may make a minute, whatever their credentials. A
|
|
// scraper polling every 2 seconds sends half of it, which httprate
|
|
// never refuses.
|
|
metricsRequestsPerMinute = 60
|
|
)
|
|
|
|
// SetupRoutes configures the chi router with middleware and
|
|
// all application routes.
|
|
func (s *Server) SetupRoutes() {
|
|
s.router = chi.NewRouter()
|
|
|
|
s.router.Use(s.mw.Recoverer())
|
|
s.router.Use(middleware.RequestID)
|
|
s.router.Use(s.mw.Logging())
|
|
// s.mw.Recoverer would write a panic's 500 only after the panic has
|
|
// passed the request log, so it is written here, where the log sees it.
|
|
s.router.Use(s.mw.Write500OnPanic())
|
|
s.router.Use(s.mw.SecurityHeaders())
|
|
s.router.Use(s.mw.CORS(s.params.Config.CORSAllowedOrigins))
|
|
s.router.Use(s.mw.MaxBodyBytes(maxRequestBodyBytes))
|
|
s.router.Use(middleware.Timeout(requestTimeout))
|
|
|
|
// Sentry reports a panic, then panics again, so that it still
|
|
// reaches s.mw.Recoverer.
|
|
if s.params.Config.SentryDSN != "" {
|
|
s.router.Use(sentryhttp.New(sentryhttp.Options{Repanic: true}).Handle)
|
|
}
|
|
|
|
// The metrics go in a registry of this server's own, not in
|
|
// Prometheus' default one, which takes them only once per process.
|
|
registry := prometheus.NewRegistry()
|
|
registry.MustRegister(
|
|
collectors.NewGoCollector(),
|
|
collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}),
|
|
)
|
|
|
|
// Requests are measured only once chi has matched them to one of
|
|
// these routes, by path and method. The metrics are labelled with
|
|
// both, which any client can make up, so measuring every request
|
|
// would let clients add labels without bound. A Route here would
|
|
// be matched by its path prefix alone, so each path is given in
|
|
// full.
|
|
s.router.Group(func(r chi.Router) {
|
|
// config.New refuses one of the two credentials without the
|
|
// other.
|
|
if s.params.Config.MetricsUsername != "" {
|
|
r.Use(s.mw.Metrics(registry))
|
|
// Likewise inside the metrics.
|
|
r.Use(s.mw.Write500OnPanic())
|
|
}
|
|
|
|
r.Get("/.well-known/healthcheck", s.h.HandleHealthCheck())
|
|
|
|
r.With(s.mw.RateLimit(s.params.Config.ReportsPerMinute)).
|
|
Post("/api/v1/reports", s.h.HandleReport())
|
|
})
|
|
|
|
// The rate limit comes before the basic auth, so a client past it
|
|
// gets 429 and its password is not checked.
|
|
if s.params.Config.MetricsUsername != "" {
|
|
s.router.With(
|
|
s.mw.RateLimit(metricsRequestsPerMinute),
|
|
s.mw.MetricsAuth(),
|
|
).Get("/metrics", promhttp.HandlerFor(
|
|
registry, promhttp.HandlerOpts{},
|
|
).ServeHTTP)
|
|
}
|
|
}
|