How to pass a logger as an argument to a chain of middleware functions?

I'm new to Go, so please bear with me.

I'm trying to use Uber's Zap logging package. I've poured through the documentation and have looked through many examples, but am struggling to find how best to use it. Their FAQ section says to avoid using Zap as a global logger, so I'm trying to pass what has been initialized in server.go (immediately below) to other functions.

// Initialize logger
logger, err := zap.NewProduction()
if err != nil {
	log.Fatalf("Failed to initialize zap logger: %v", err)
}
defer logger.Sync()
sugar := logger.Sugar()
sugar.Info("Server is starting...")

router := http.NewServeMux()

server := &http.Server{
	Addr:         addr,
	Handler:      middleware.Middleware{middleware.RequestIdentifier, middleware.RequestLogger}.Apply(router),
    // ...other fields
}

Where Middleware is defined, in another file, as

type Middleware []func(http.Handler) http.Handler

// Apply() builds the middleware array into a handler chain
func (midware Middleware) Apply(handler http.Handler) http.Handler {
	if len(midware) == 0 {
		return handler
	}
	return midware[:len(midware)-1].Apply(midware[len(midware)-1](handler))
}

Then in another file (request_identifier.go).

func RequestIdentifier(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        //
		// ...stuff, and use Zap here
        //
		next.ServeHTTP(w, r)
	})
}

And similarly for the other middleware function.

I've tried wrapping RequestIdentifier and have tried toying with the accepted function signature of Middleware, but I can't seem to figure out how I can pass sugar without having my IDE yell at me.

What I would like would be something such as:

Handler: middleware.Middleware{middleware.RequestIdentifier(sugar), middleware.RequestLogger(sugar)}.Apply(router)

Then in my middleware functions, have access to the logger available in some fashion like so:

func RequestIdentifier(next http.Handler, s *zap.SugaredLogger) http.Handler { ... }

You need to add one more layer of closure:

func RequestIdentifier(s *zap.SugaredLogger) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			//
			// ...stuff, and use Zap here
			//
			next.ServeHTTP(w, r)
		})
	}
}

Handler: middleware.Middleware{middleware.RequestIdentifier(sugar), middleware.RequestLogger(sugar)}.Apply(router),