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/logger.go

@@ -27,50 +27,52 @@ import (
 	"github.com/grafana/grafana/pkg/web"
 )
 
-func Logger(cfg *setting.Cfg) web.Handler {
-	return func(res http.ResponseWriter, req *http.Request, c *web.Context) {
-		start := time.Now()
+func Logger(cfg *setting.Cfg) web.Middleware {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			start := time.Now()
 
-		rw := res.(web.ResponseWriter)
-		c.Next()
+			rw := web.Rw(w, r)
+			next.ServeHTTP(rw, r)
 
-		timeTaken := time.Since(start) / time.Millisecond
-		duration := time.Since(start).String()
-		ctx := contexthandler.FromContext(c.Req.Context())
-		if ctx != nil && ctx.PerfmonTimer != nil {
-			ctx.PerfmonTimer.Observe(float64(timeTaken))
-		}
-
-		status := rw.Status()
-		if status == 200 || status == 304 {
-			if !cfg.RouterLogging {
-				return
-			}
-		}
-
-		if ctx != nil {
-			logParams := []interface{}{
-				"method", req.Method,
-				"path", req.URL.Path,
-				"status", status,
-				"remote_addr", c.RemoteAddr(),
-				"time_ms", int64(timeTaken),
-				"duration", duration,
-				"size", rw.Size(),
-				"referer", SanitizeURL(ctx, req.Referer()),
+			timeTaken := time.Since(start) / time.Millisecond
+			duration := time.Since(start).String()
+			ctx := contexthandler.FromContext(r.Context())
+			if ctx != nil && ctx.PerfmonTimer != nil {
+				ctx.PerfmonTimer.Observe(float64(timeTaken))
 			}
 
-			traceID := tracing.TraceIDFromContext(ctx.Req.Context(), false)
-			if traceID != "" {
-				logParams = append(logParams, "traceID", traceID)
+			status := rw.Status()
+			if status == 200 || status == 304 {
+				if !cfg.RouterLogging {
+					return
+				}
 			}
 
-			if status >= 500 {
-				ctx.Logger.Error("Request Completed", logParams...)
-			} else {
-				ctx.Logger.Info("Request Completed", logParams...)
+			if ctx != nil {
+				logParams := []interface{}{
+					"method", r.Method,
+					"path", r.URL.Path,
+					"status", status,
+					"remote_addr", ctx.RemoteAddr(),
+					"time_ms", int64(timeTaken),
+					"duration", duration,
+					"size", rw.Size(),
+					"referer", SanitizeURL(ctx, r.Referer()),
+				}
+
+				traceID := tracing.TraceIDFromContext(ctx.Req.Context(), false)
+				if traceID != "" {
+					logParams = append(logParams, "traceID", traceID)
+				}
+
+				if status >= 500 {
+					ctx.Logger.Error("Request Completed", logParams...)
+				} else {
+					ctx.Logger.Info("Request Completed", logParams...)
+				}
 			}
-		}
+		})
 	}
 }