initial prometheus metrics support, simplfied some code

internal/net/http/dummy_response_writer.go

@@ -1,15 +0,0 @@
-package http
-
-import "net/http"
-
-type DummyResponseWriter struct{}
-
-func (w DummyResponseWriter) Header() http.Header {
-	return make(http.Header)
-}
-
-func (w DummyResponseWriter) Write([]byte) (_ int, _ error) {
-	return
-}
-
-func (w DummyResponseWriter) WriteHeader(int) {}

internal/net/http/loadbalancer/loadbalancer.go

@@ -1,7 +1,6 @@
 package loadbalancer
 
 import (
-	"context"
 	"net/http"
 	"sync"
 	"time"
@@ -10,7 +9,6 @@ import (
 	"github.com/yusing/go-proxy/internal/common"
 	idlewatcher "github.com/yusing/go-proxy/internal/docker/idlewatcher/types"
 	E "github.com/yusing/go-proxy/internal/error"
-	gphttp "github.com/yusing/go-proxy/internal/net/http"
 	"github.com/yusing/go-proxy/internal/net/http/middleware"
 	"github.com/yusing/go-proxy/internal/task"
 	"github.com/yusing/go-proxy/internal/watcher/health"
@@ -225,18 +223,15 @@ func (lb *LoadBalancer) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 		return
 	}
 	if r.Header.Get(common.HeaderCheckRedirect) != "" {
-		ctx, cancel := context.WithTimeout(r.Context(), 1*time.Second)
-		defer cancel()
-		// send dummy request to wake all servers
-		var dummyRW gphttp.DummyResponseWriter
+		// wake all servers
 		for _, srv := range srvs {
 			// wake only if server implements Waker
-			_, ok := srv.handler.(idlewatcher.Waker)
-			if !ok {
-				continue
+			waker, ok := srv.handler.(idlewatcher.Waker)
+			if ok {
+				if err := waker.Wake(); err != nil {
+					lb.Err(err).Msgf("failed to wake server %s", srv.Name)
+				}
 			}
-			wakeReq := r.Clone(ctx)
-			srv.ServeHTTP(dummyRW, wakeReq)
 		}
 	}
 	lb.impl.ServeHTTP(srvs, rw, r)

internal/net/http/middleware/middleware.go

@@ -157,8 +157,8 @@ func patchReverseProxy(rpName string, rp *ReverseProxy, middlewares []*Middlewar
 	mid := BuildMiddlewareFromChain(rpName, middlewares)
 
 	if mid.before != nil {
-		ori := rp.ServeHTTP
-		rp.ServeHTTP = func(w http.ResponseWriter, r *http.Request) {
+		ori := rp.HandlerFunc
+		rp.HandlerFunc = func(w http.ResponseWriter, r *http.Request) {
 			mid.before(ori, w, r)
 		}
 	}

internal/net/http/reverse_proxy_mod.go

@@ -10,6 +10,7 @@ package http
 // Copyright (c) 2024 yusing
 
 import (
+	"bufio"
 	"bytes"
 	"context"
 	"errors"
@@ -22,8 +23,11 @@ import (
 	"net/url"
 	"strings"
 	"sync"
+	"time"
 
 	"github.com/rs/zerolog"
+	"github.com/yusing/go-proxy/internal/common"
+	"github.com/yusing/go-proxy/internal/metrics"
 	"github.com/yusing/go-proxy/internal/net/types"
 	U "github.com/yusing/go-proxy/internal/utils"
 	"golang.org/x/net/http/httpguts"
@@ -86,12 +90,52 @@ type ReverseProxy struct {
 	// implementation is used.
 	ModifyResponse func(*http.Response) error
 
-	ServeHTTP http.HandlerFunc
+	HandlerFunc http.HandlerFunc
 
 	TargetName string
 	TargetURL  types.URL
 }
 
+type httpMetricLogger struct {
+	http.ResponseWriter
+	labels metrics.HTTPRouteMetricLabels
+}
+
+// WriteHeader implements http.ResponseWriter.
+func (l *httpMetricLogger) WriteHeader(status int) {
+	l.ResponseWriter.WriteHeader(status)
+	go func() {
+		m := metrics.GetRouteMetrics()
+		m.HTTPReqTotal.Inc()
+
+		// ignore 1xx
+		switch {
+		case status >= 500:
+			m.HTTP5xx.With(l.labels).Inc()
+		case status >= 400:
+			m.HTTP4xx.With(l.labels).Inc()
+		case status >= 200:
+			m.HTTP2xx3xx.With(l.labels).Inc()
+		}
+	}()
+}
+
+// Hijack hijacks the connection.
+func (l *httpMetricLogger) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	if h, ok := l.ResponseWriter.(http.Hijacker); ok {
+		return h.Hijack()
+	}
+
+	return nil, nil, fmt.Errorf("not a hijacker: %T", l.ResponseWriter)
+}
+
+// Flush sends any buffered data to the client.
+func (l *httpMetricLogger) Flush() {
+	if flusher, ok := l.ResponseWriter.(http.Flusher); ok {
+		flusher.Flush()
+	}
+}
+
 func singleJoiningSlash(a, b string) string {
 	aslash := strings.HasSuffix(a, "/")
 	bslash := strings.HasPrefix(b, "/")
@@ -157,7 +201,7 @@ func NewReverseProxy(name string, target types.URL, transport http.RoundTripper)
 		TargetName: name,
 		TargetURL:  target,
 	}
-	rp.ServeHTTP = rp.serveHTTP
+	rp.HandlerFunc = rp.handler
 	return rp
 }
 
@@ -225,9 +269,32 @@ func (p *ReverseProxy) modifyResponse(rw http.ResponseWriter, res *http.Response
 	return true
 }
 
-func (p *ReverseProxy) serveHTTP(rw http.ResponseWriter, req *http.Request) {
-	if _, ok := rw.(DummyResponseWriter); ok {
-		return
+func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+	p.HandlerFunc(rw, req)
+}
+
+func (p *ReverseProxy) handler(rw http.ResponseWriter, req *http.Request) {
+	if common.PrometheusEnabled {
+		t := time.Now()
+		visitor, _, err := net.SplitHostPort(req.RemoteAddr)
+		if err != nil {
+			visitor = req.RemoteAddr
+		}
+		lbls := metrics.HTTPRouteMetricLabels{
+			Service: p.TargetName,
+			Method:  req.Method,
+			Host:    req.Host,
+			Visitor: visitor,
+			Path:    req.URL.Path,
+		}
+		rw = &httpMetricLogger{
+			ResponseWriter: rw,
+			labels:         lbls,
+		}
+		defer func() {
+			duration := time.Since(t)
+			metrics.GetRouteMetrics().HTTPReqElapsed.With(lbls).Set(float64(duration.Milliseconds()))
+		}()
 	}
 
 	transport := p.Transport