Can't track HTTP response code in middleware

I'm using the go-openapi to generate from a swagger config an http server and handle all handlers.
The schema of my middleware would be request -> override func -> do http stuff -> logs response code -> response.

Here's my middleware:

func (pm *PrometheusMetrics) HTTPMiddleware(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()
		statusRecoder := &utils.StatusRecorder{ResponseWriter: w, StatusCode: 200}
		logrus.Infof("--> %v %v", r.Method, r.URL.Path)
		// statusRecoder := negroni.NewResponseWriter(w) <-- tried this solution, didn't worked

		h.ServeHTTP(statusRecoder, r)

		logrus.Infof("<-- %v", statusRecoder.Status()) // should display status code
		duration := time.Since(start)
		statusCode := strconv.Itoa(statusRecoder.Status())

		pm.PushHTTPMetrics(r.URL.Path, statusCode, duration.Seconds())
	})
}

And here's how I pass the middleware:

func setupGlobalMiddleware(handler http.Handler, promMetrics *apihandlers.PrometheusMetrics) http.Handler {
	middle := interpose.New()
	middle.UseHandler(handler)

	recoveryMiddleware := recovr.New()
	middle.Use(recoveryMiddleware)

	logrusMiddleware := interposeMiddleware.NegroniLogrus()
	middle.Use(logrusMiddleware)
	middle.Use(func(h http.Handler) http.Handler {
		return promMetrics.HTTPMiddleware(h)
	})

	corsMiddleware := cors.New(cors.Options{
		AllowedHeaders:     []string{"*"},
		AllowedOrigins:     []string{"*"},
		AllowedMethods:     []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
		MaxAge:             1000,
		OptionsPassthrough: false,
	})
	if log.GetLevel() >= log.DebugLevel {
		corsMiddleware.Log = log.StandardLogger()
	}

	return corsMiddleware.Handler(middle)
}

And finally, where I call the setupGlobalMiddleware function:

func configureAPI(api *operations.KubeesAPI) http.Handler { // operations is package generated by go-openapi
    // Some setup...
    return setupGlobalMiddleware(api.Serve(setupMiddlewares), promMetrics)
}

The override of statusRecoder:

type StatusRecorder struct {
	http.ResponseWriter
	StatusCode int
}

// WriteHeader is the fake function to record status code
func (rec *StatusRecorder) WriteHeader(statusCode int) {
	logrus.Infof("hello there: %v", statusCode)
	rec.StatusCode = statusCode
	rec.ResponseWriter.WriteHeader(statusCode)
}

As you can see, I'm overriding the WriteHeader function from the http.Handler to just store the status code and access it outside, then call the original WriteHeader function. The problem here, is that my function WriteHeader is never called. And can't figure out why it's not.

> The problem here, is that my function WriteHeader is never called. And can't figure out why it's not.

Because Go uses composition, not inheretence. WriteHeader is most frequently called automatically by the first call to Write(). From the http.ResponseWriter documentation:

> // Write writes the data to the connection as part of an HTTP reply.
> //
> // If WriteHeader has not yet been called, Write calls
> // WriteHeader(http.StatusOK) before writing the data. If the Header
> // does not contain a Content-Type line, Write adds a Content-Type set
> // to the result of passing the initial 512 bytes of written data to
> // DetectContentType. Additionally, if the total size of all written
> // data is under a few KB and there are no Flush calls, the
> // Content-Length header is added automatically.

But since you haven't defined your own Write method, the embedded one (provided by the embedded instance of http.ResponseWriter) is called instead. When that Write() method is called, and it then calls WriteHeader, it calls the original WriteHeader method, not your version.

The solution is to also provide your own Write method, which wraps the original, and calls your version of WriteHeader when needed.

type StatusRecorder struct {
    http.ResponseWriter
    StatusCode int
    written bool
}

// WriteHeader is the fake function to record status code
func (rec *StatusRecorder) WriteHeader(statusCode int) {
    rec.written = true
    logrus.Infof("hello there: %v", statusCode)
    rec.StatusCode = statusCode
    rec.ResponseWriter.WriteHeader(statusCode)
}

func (rec *StatusRecorder) Write(p []byte) (int, error) {method
    if !rec.written {
        rec.WriteHeader(http.StatusOK)
    }
    return rec.Write(p)
}

Well the answer was a little bit more complex to understand if you didn't have the entire package list.<br>
The problem was the way that go-openapi and go-swagger implement middlewares in the code and handle them. Many other installed packages have this problem.<br>
To make sure I retrieve properly the status code, I put the middleware at the rigth bottom of middlewares declaration.<br>

Code:

func setupGlobalMiddleware(handler http.Handler, promMetrics *apihandlers.PrometheusMetrics) http.Handler {
	middle := interpose.New()
	middle.UseHandler(handler)

	recoveryMiddleware := recovr.New()
	middle.Use(recoveryMiddleware)

	logrusMiddleware := interposeMiddleware.NegroniLogrus()
	middle.Use(logrusMiddleware)

    // the old declaration was here

	corsMiddleware := cors.New(cors.Options{
		AllowedHeaders:     []string{"*"},
		AllowedOrigins:     []string{"*"},
		AllowedMethods:     []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
		MaxAge:             1000,
		OptionsPassthrough: false,
	})
	if log.GetLevel() >= log.DebugLevel {
		corsMiddleware.Log = log.StandardLogger()
	}

    // notice the changement where the promMetrics.HTTPMiddleware is now in the bottom
	return corsMiddleware.Handler(promMetrics.HTTPMiddleware(middle))
	// return corsMiddleware.Handler(middle) <-- old line
}