How to implement zap properly?

[tinkitwong]

I have 2 questions regarding logging with zap. Appreciate comments and a healthy discussion on this! 🙏

Q1. Understand that there are ways to implement zap logger. I am having difficulty understanding which of the below (or if there are others) is an appropriate method of logging. Below are my thoughts on each method, hoping to get fact checked on this.

1. Replace default global logger
2. Init in a package, and assign it to a package level variable
3. Context logger
4. Passing logger from main down into functions via args
5. Struct logger

Pros

1. Easy to replace, and use across the entire golang application
2. Not as much boilerplate as Struct Logger setup
3. Easy to piggyback in context, and get logger from which across the entire golang application
4. Init once, and pass it down
5. Can be formally created as part of a struct (ie. Controller / Servicer )

Cons

1. Specifically mentioned in zap FAQ to avoid where possible
2. Seems to be not safe across various go-routines since we are accessing the same address
3. Online literature seems to be on the fence on the pros/cons of this method
4. Explodes function signatures
5. Boiler plate in terms of init-ing them for usage. Also, we have to somehow include methods that defer the logger.Sync() after creating them and before attaching them to the implementing struct.

Q2. I have tried to implement structured logging via point 5 -- Struct Logger but having trouble with reducing duplicate code of calling logger.Sync() after creating loggers at various places (ie. controller / services layer)

// controller/foo.go

type FooController struct {
	logger         *config.Logger
	fooService services.FooServicer
}

func NewFooController() *FooController {
	logger := config.NewLogger()
	defer func(logger *zap.SugaredLogger) {
		_ = logger.Sync()
	}(logger.SugaredLogger) // flushes buffer, if any
       fooService := services.NewFooService()

	return &FooController{
		logger:         logger,
		profileService: fooService,
	}
}

The above is an example of how I would think to implement a Struct Logger -- Pt 5. The problem I have is that I need to constantly write the below after creating loggers at the controller / service layers. I don't think I should move them into the init method as that does nothing when the NewLogger() exists upon creating the logger.

defer func(logger *zap.SugaredLogger) {
	_ = logger.Sync()
}(logger.SugaredLogger) // flushes buffer, if any