pkg/web: closure-style middlewares (#51238)

* pkg/web: closure-style middlewares

Switches the middleware execution model from web.Handlers in a slice to
web.Middleware.
Middlewares are temporarily kept in a slice to preserve ordering, but
prior to execution they are applied, forming a giant call-stack, giving
granular control over the execution flow.

* pkg/middleware: adapt to web.Middleware

* pkg/middleware/recovery: use c.Req over req

c.Req gets updated by future handlers, while req stays static.

The current recovery implementation needs this newer information

* pkg/web: correct middleware ordering

* pkg/webtest: adapt middleware

* pkg/web/hack: set w and r onto web.Context

By adopting std middlewares, it may happen they invoke next(w,r) without
putting their modified w,r into the web.Context, leading old-style
handlers to operate on outdated fields.

pkg/web now takes care of this

* pkg/middleware: selectively use future context

* pkg/web: accept closure-style on Use()

* webtest: Middleware testing

adds a utility function to web/webtest to obtain a http.ResponseWriter,
http.Request and http.Handler the same as a middleware that runs would receive

* *: cleanup

* pkg/web: don't wrap Middleware from Router

* pkg/web: require chain to write response

* *: remove temp files

* webtest: don't require chain write

* *: cleanup

pkg/middleware/request_metrics.go

@@ -46,57 +46,60 @@ func init() {
 }
 
 // RequestMetrics is a middleware handler that instruments the request.
-func RequestMetrics(features featuremgmt.FeatureToggles) web.Handler {
+func RequestMetrics(features featuremgmt.FeatureToggles) web.Middleware {
 	log := log.New("middleware.request-metrics")
 
-	return func(res http.ResponseWriter, req *http.Request, c *web.Context) {
-		rw := res.(web.ResponseWriter)
-		now := time.Now()
-		httpRequestsInFlight.Inc()
-		defer httpRequestsInFlight.Dec()
-		c.Next()
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			rw := web.Rw(w, r)
+			now := time.Now()
+			httpRequestsInFlight.Inc()
+			defer httpRequestsInFlight.Dec()
+			next.ServeHTTP(w, r)
 
-		status := rw.Status()
-		code := sanitizeCode(status)
+			status := rw.Status()
+			code := sanitizeCode(status)
 
-		handler := "unknown"
-		if routeOperation, exists := routeOperationName(c.Req); exists {
-			handler = routeOperation
-		} else {
-			// if grafana does not recognize the handler and returns 404 we should register it as `notfound`
-			if status == http.StatusNotFound {
-				handler = "notfound"
+			handler := "unknown"
+			// TODO: do not depend on web.Context from the future
+			if routeOperation, exists := routeOperationName(web.FromContext(r.Context()).Req); exists {
+				handler = routeOperation
 			} else {
-				// log requests where we could not identify handler so we can register them.
-				if features.IsEnabled(featuremgmt.FlagLogRequestsInstrumentedAsUnknown) {
-					log.Warn("request instrumented as unknown", "path", c.Req.URL.Path, "status_code", status)
+				// if grafana does not recognize the handler and returns 404 we should register it as `notfound`
+				if status == http.StatusNotFound {
+					handler = "notfound"
+				} else {
+					// log requests where we could not identify handler so we can register them.
+					if features.IsEnabled(featuremgmt.FlagLogRequestsInstrumentedAsUnknown) {
+						log.Warn("request instrumented as unknown", "path", r.URL.Path, "status_code", status)
+					}
 				}
 			}
-		}
 
-		// avoiding the sanitize functions for in the new instrumentation
-		// since they dont make much sense. We should remove them later.
-		histogram := httpRequestDurationHistogram.
-			WithLabelValues(handler, code, req.Method)
-		if traceID := tracing.TraceIDFromContext(c.Req.Context(), true); traceID != "" {
-			// Need to type-convert the Observer to an
-			// ExemplarObserver. This will always work for a
-			// HistogramVec.
-			histogram.(prometheus.ExemplarObserver).ObserveWithExemplar(
-				time.Since(now).Seconds(), prometheus.Labels{"traceID": traceID},
-			)
-			return
-		}
-		histogram.Observe(time.Since(now).Seconds())
+			// avoiding the sanitize functions for in the new instrumentation
+			// since they dont make much sense. We should remove them later.
+			histogram := httpRequestDurationHistogram.
+				WithLabelValues(handler, code, r.Method)
+			if traceID := tracing.TraceIDFromContext(r.Context(), true); traceID != "" {
+				// Need to type-convert the Observer to an
+				// ExemplarObserver. This will always work for a
+				// HistogramVec.
+				histogram.(prometheus.ExemplarObserver).ObserveWithExemplar(
+					time.Since(now).Seconds(), prometheus.Labels{"traceID": traceID},
+				)
+				return
+			}
+			histogram.Observe(time.Since(now).Seconds())
 
-		switch {
-		case strings.HasPrefix(req.RequestURI, "/api/datasources/proxy"):
-			countProxyRequests(status)
-		case strings.HasPrefix(req.RequestURI, "/api/"):
-			countApiRequests(status)
-		default:
-			countPageRequests(status)
-		}
+			switch {
+			case strings.HasPrefix(r.RequestURI, "/api/datasources/proxy"):
+				countProxyRequests(status)
+			case strings.HasPrefix(r.RequestURI, "/api/"):
+				countApiRequests(status)
+			default:
+				countPageRequests(status)
+			}
+		})
 	}
 }