Логирование через middleware

package main

import (
    "fmt"
    "net/http"

    "go.uber.org/zap"
)

var sugar zap.SugaredLogger

func main() {
    // создаём предустановленный регистратор zap
    logger, err := zap.NewDevelopment()
    if err != nil {
        // вызываем панику, если ошибка
        panic(err)
    }
    defer logger.Sync()

    // делаем регистратор SugaredLogger
    sugar = *logger.Sugar()

    http.Handle("/ping", pingHandler())

    addr := "127.0.0.1:8080"
    // записываем в лог, что сервер запускается
    sugar.Infow(
        "Starting server",
        "addr", addr,
    )
    if err := http.ListenAndServe(addr, nil); err != nil {
        // записываем в лог ошибку, если сервер не запустился
        sugar.Fatalw(err.Error(), "event", "start server")
    }
}

// хендлер для /ping
func pingHandler() http.Handler {
    fn := func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        _, _ = fmt.Fprintf(w, "pong\n")
    }
    return http.HandlerFunc(fn)
} 

// WithLogging добавляет дополнительный код для регистрации сведений о запросе
// и возвращает новый http.Handler.
func WithLogging(h http.Handler) http.Handler {
    logFn := func(w http.ResponseWriter, r *http.Request) {
        // функция Now() возвращает текущее время
        start := time.Now()

        // эндпоинт /ping
        uri := r.RequestURI
        // метод запроса
        method := r.Method

        // точка, где выполняется хендлер pingHandler 
        h.ServeHTTP(w, r) // обслуживание оригинального запроса

        // Since возвращает разницу во времени между start 
        // и моментом вызова Since. Таким образом можно посчитать
        // время выполнения запроса.
        duration := time.Since(start)

        // отправляем сведения о запросе в zap
        sugar.Infoln(
            "uri", uri,
            "method", method,
            "duration", duration,
        )
        
    }
    // возвращаем функционально расширенный хендлер
    return http.HandlerFunc(logFn)
} 

http.Handle("/ping", WithLogging(pingHandler())) 

type ResponseWriter interface {
    Header() Header
    Write([]byte) (int, error)
    WriteHeader(statusCode int)
} 

type (
    // берём структуру для хранения сведений об ответе
    responseData struct {
        status int
        size int
    }

    // добавляем реализацию http.ResponseWriter
    loggingResponseWriter struct {
        http.ResponseWriter // встраиваем оригинальный http.ResponseWriter
        responseData *responseData
    }
)

func (r *loggingResponseWriter) Write(b []byte) (int, error) {
    // записываем ответ, используя оригинальный http.ResponseWriter
    size, err := r.ResponseWriter.Write(b) 
    r.responseData.size += size // захватываем размер
    return size, err
}

func (r *loggingResponseWriter) WriteHeader(statusCode int) {
    // записываем код статуса, используя оригинальный http.ResponseWriter
    r.ResponseWriter.WriteHeader(statusCode) 
    r.responseData.status = statusCode // захватываем код статуса
} 

func WithLogging(h http.Handler) http.Handler {
    logFn := func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()

        responseData := &responseData {
            status: 0,
            size: 0,
        }
        lw := loggingResponseWriter {
            ResponseWriter: w, // встраиваем оригинальный http.ResponseWriter
            responseData: responseData,
        }
        h.ServeHTTP(&lw, r) // внедряем реализацию http.ResponseWriter

        duration := time.Since(start)

        sugar.Infoln(
            "uri", r.RequestURI,
            "method", r.Method,
            "status", responseData.status, // получаем перехваченный код статуса ответа
            "duration", duration,
            "size", responseData.size, // получаем перехваченный размер ответа
        )
    }
    return http.HandlerFunc(logFn)
}