no ServeHTTP method to conform to http.Handler chainability?

[sneak]

I'm trying to use this as an http.Handler wrapper for chi, a mux that accepts "standard" http.Handler wrapper go middlewares. It doesn't have a ServeHTTP method though, so it can't be chained in this way like my others, unless I'm misunderstanding something.

[slok]

Hi @sneak!

I haven't use Chi myself, however, I've been reading how to use it and I come with an example using go-http-metrics std middleware (is the same example as default but for chi).

package main

import (
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/go-chi/chi"
	"github.com/prometheus/client_golang/prometheus/promhttp"
	metrics "github.com/slok/go-http-metrics/metrics/prometheus"
	"github.com/slok/go-http-metrics/middleware"
	"github.com/slok/go-http-metrics/middleware/std"
)

const (
	srvAddr     = ":8080"
	metricsAddr = ":8081"
)

// this example will show the simplest way of enabling the middleware
// using go std handlers without frameworks with the Prometheues recorder.
// it uses the prometheus default registry, the middleware default options
// and doesn't set the handler ID, so the middleware will set the handler id
// (handler label) to the request URL, WARNING: this creates high cardinality because
// `/profile/123` and `/profile/567` are different handlers. If you want to be safer
// you will need to tell the middleware what is the handler id.
func main() {
	// Create our middleware.
	mdlw := middleware.New(middleware.Config{
		Recorder: metrics.NewRecorder(metrics.Config{}),
	})

	// Create our server.
	r := chi.NewRouter()

	// Wrap our middleware using Chi way.
	r.Use(func(next http.Handler) http.Handler {
		return std.Handler("", mdlw, next)
	})

	// Add paths.
	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
		time.Sleep(200 * time.Millisecond)
		w.WriteHeader(http.StatusOK)
	})
	r.Get("/test1", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusCreated) })
	r.Get("/test1/test2", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusAccepted) })
	r.Get("/test1/test4", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusNonAuthoritativeInfo) })
	r.Get("/test2", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusNoContent) })
	r.Get("/test3", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusResetContent) })

	// Serve our handler.
	go func() {
		log.Printf("server listening at %s", srvAddr)
		if err := http.ListenAndServe(srvAddr, r); err != nil {
			log.Panicf("error while serving: %s", err)
		}
	}()

	// Serve our metrics.
	go func() {
		log.Printf("metrics listening at %s", metricsAddr)
		if err := http.ListenAndServe(metricsAddr, promhttp.Handler()); err != nil {
			log.Panicf("error while serving metrics: %s", err)
		}
	}()

	// Wait until some signal is captured.
	sigC := make(chan os.Signal, 1)
	signal.Notify(sigC, syscall.SIGTERM, syscall.SIGINT)
	<-sigC
}

The key is here:

// Wrap our middleware using Chi way.
r.Use(func(next http.Handler) http.Handler {
    return std.Handler("", mdlw, next)
})

If you want I could add support for Chi on the library, with proper wrapper (as in the example) unit and integration tests, example...

Just let me know if it works for you and if you would like me to add support for it.

Sorry for the inconvenience!

[sneak]

Ahh, I didn't think to inline a conversion handler-to-handler function as you did there. That'll work fine for my case, thank you.

[sneak]

The reason I asked is because a lot of stuff (gorilla/mux, chi, alice, et c) seem to expect a func(http.Handler) http.Handler as their value for "middleware" to be passed in to .Use().

[slok]

@sneak FYI, I just published v0.9.0, with std.HandlerProvider helper and add examples/tests for Chi, Gorilla and Alice using this provider.

Example of usage:

//...
r := chi.NewRouter()
r.Use(std.HandlerProvider("", mdlw))
//...