如何在 go 微服务中为每个日志添加跟踪 ID

Question

I wanted to add trace id to logging done for each request to the micro service.I want this in similar as for springboot application we can set trace id in MDC and fetch it and use it while logging.

I have done some research and I found that MDC equivalent in go lang is context. So, I have set the trace id in my context. Now the problem is where ever I have to log with trace id,I need to pass context to that function which is very ugly way. I am looking for a better solution for this problem.

func HandlerFunction(f gin.HandlerFunc) gin.HandlerFunc{
    return func(cxt *gin.Context) {
        reqraceId := cxt.Request.Header.Get("trace-id")
        requid , _ := uuid.NewRandom()

        if reqTraceId == "" {
            c.Request.Header.Set("trace-id", requid.String())
        }

        f(c)
    }
}

Answer 1

It might be worth reading up on context.Context particularly this article which has a section that says:

At Google, we require that Go programmers pass a Context parameter as the first argument to every function on the call path between incoming and outgoing requests.

TL;DR - it's fine to pass the context, but what's the best way?

There's two main patterns

1. Ask the context to give you a logger
2. Give the logger the context

Context can be used to store values:

context.WithValue(ctx, someKey, someValue)

This means we can either do:

somepackage.Log(ctx).Info("hello world")
// or
sompackage.Info(ctx, "hello world")

The implementation of these two sample APIs could interact with the context to retrieve the values required with out needing to worry about the extra information that would have been in MDC at any of the logging call sites.

Answer 2

This issue can also be solved using a dependency injection container.

We can implement "request-scoped" injections, and as a result, for each request, we will recreate all dependency tree that uses request-scoped dependency(logger, error reporter, clients which send requests to another service with context propagation).

But as I understood using dependency injection containers is not a best practice in go and not an "idiomatic" way.

Also, this approach can have some performance and memory issues since we will recreate objects for each request.

Answer 3

From my side I found that using the default log package we could set a prefix as log.SetPrefix(traceId) , doing so, the log will print the trace id as the prefix in the actual and sub-functions/structs.

import (
    "log"
    "github.com/google/uuid"
)

func (hdl *HTTPHandler) example() {
    var traceId string = uuid.NewString()
    log.SetPrefix(traceId + " - ")
    log.SetFlags(log.LstdFlags)
    // ...
    // ...
    log.Println("......")
}