What's the proper way to use logger along with context?

I am building a web server in Golang. You know Golang has an context package and it's offically recommended to always pass a context as first argument. context.Context has a Value method to keep variables under a context.

However, most logging libraries also privide a way to inherit logger, say, creating child loggers with fields from its parent. In logrus (or some other logger, doesn't matter), you may create an logrus.Entry and apply WithFields to get a child logger.

For example, when each HTTP request coming an request-id is attached. I hope it being put in context, and also logged as a field in every log.

So, how to do this in a proper way?

THANKS!!

You can set and get requestID in context using http middleware

package requestid

type requestIDKey struct{}

func ContextWithRequestID(ctx context.Context, requestID string) context.Context {
    return context.WithValue(ctx, requestIDKey{}, requestID)
}

func FromContext(ctx context.Context) string {
    val := ctx.Value(requestIDKey{})
    if val == nil {
	   return ""
    }
    return val.(string)
}

func HTTPMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
	    requestID := r.Header.Get("X-Request-ID")
	    if requestID == "" {
		    requestID = uuid.New().String()
	    }
	    ctx := ContextWithRequestID(r.Context(), requestID)
	    next.ServeHTTP(w, r.WithContext(ctx))
    })
}

And then create a global logger with exported wrapper functions that receive context as an argument (in this example i am using zap, but it can be any other logger)

package logger

var globalLogger *zap.SugaredLogger

func init() {
    globalLogger = zap.NewExample().Sugar()
}

func loggerWithRequestID(ctx context.Context) *zap.SugaredLogger {
    return globalLogger.With("request_id", requestid.FromContext(ctx))
}

func Errorf(ctx context.Context, template string, args ...interface{}) {
    loggerWithRequestID(ctx).Errorf(template, args...)
}
//Warn,Warnf...

So it can be used anywhere in code like this:

logger.Error(ctx, "encountered error")

You can get the request-id from the incoming request and then use the context to pass the request-id to the functions you are calling.
Here is an example of that : https://medium.com/@cep21/how-to-correctly-use-context-context-in-go-1-7-8f2c0fafdf39.
For logging: Define your own logger using the std log library

func CreateCustomLogger(requestId string) *log.Logger {
    defaultLoggingFlags := 
log.Ldate|log.Ltime|log.LUTC|log.Lmicroseconds|log.Lshortfile
    return log.New(os.Stderr, requestId + ": ", defaultLoggingFlags)
}

In your function:

customLogger := CreateCustomLogger(requestId)
customLogger.Printf("Custom log message")

You can create custom formatter and set it. Have a look here.

Each Http request has it's own context, i just merge request id in it like this in middleware.

Request = Request.WithContext(context.WithValue(Request.Context(), "request_uuid", uid))