如何在Golang中通过Logrus自动添加日志关联ID无需大量重构？

问题背景 #

我正尝试为Golang项目的日志添加关联/请求ID，以便在出现问题时更易检索和调试。我找到过一种通过中间件添加correlationID，再在处理器函数中手动获取的实现方式：

原中间件实现 #

const ContextKeyRequestID ContextKey = "requestID"

func reqIDMiddleware1(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        id := uuid.New()
        ctx = context.WithValue(ctx, ContextKeyRequestID, id.String())
        r = r.WithContext(ctx)
        
        log.Debugf("Incoming request %s %s %s %s", r.Method, r.RequestURI, r.RemoteAddr, id.String())
        next.ServeHTTP(w, r)
        log.Debugf("Finished handling http req. %s", id.String())
    })
}

原处理器实现 #

const LogFieldKeyRequestID = "requestID"

func handleSomeRequest() http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        reqIDRaw := ctx.Value(ContextKeyRequestID) // reqIDRaw at this point is of type 'interface{}'
        reqID, ok := reqIDRaw.(string)
        if !ok {
            // handler error
        }
        
        // let's use it with logrus FieldLogger!
        logger := log.WithField(LogFieldKeyRequestID, reqID)
        logger.Debugf("What I just did!")
        // Do more, log more. Handle this request seriously
    }
}

但我的项目规模较大，按上述方式实现需要大量修改，因此想了解是否有无需重构所有现有处理器和日志功能的自动配置方式，实现为每条日志自动添加ID。

解决方案 #

1. 封装带Context的日志工具函数 #

无需修改原有处理器逻辑，仅将全局日志调用替换为封装后的工具函数，自动从Context中提取请求ID：

import (
    "context"
    "github.com/sirupsen/logrus"
)

const ContextKeyRequestID = "requestID"

// Debugf 自动注入请求ID的日志函数
func Debugf(ctx context.Context, format string, args ...interface{}) {
    logger := logrus.NewEntry(logrus.StandardLogger())
    if reqID, ok := ctx.Value(ContextKeyRequestID).(string); ok {
        logger = logger.WithField("requestID", reqID)
    }
    logger.Debugf(format, args...)
}

// 同理封装Infof、Errorf等其他日志级别函数

处理器中直接调用封装后的函数：

func handleSomeRequest() http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // 原有业务逻辑完全不变
        Debugf(r.Context(), "What I just did!")
        // ...其他业务操作
    }
}

这种方式仅需替换日志调用，改造量极小，适合大规模项目快速适配。

2. 利用Logrus Hook自动注入请求ID #

如果项目使用Logrus，可通过自定义Hook结合goroutine本地存储实现零侵入式日志ID注入：

首先定义goroutine本地存储用于传递请求ID：

import (
    "sync"
    "github.com/petermattis/goid"
)

var reqIDStorage = sync.Map{} // key: goroutine ID, value: requestID

修改中间件，将请求ID存入goroutine存储：

func reqIDMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        id := uuid.New().String()
        ctx = context.WithValue(ctx, ContextKeyRequestID, id)
        r = r.WithContext(ctx)
        
        // 存入当前goroutine的ID映射
        currentGoid := goid.Get()
        reqIDStorage.Store(currentGoid, id)
        
        // 请求结束后清理存储
        defer reqIDStorage.Delete(currentGoid)
        
        log.Debugf("Incoming request %s %s %s %s", r.Method, r.RequestURI, r.RemoteAddr, id)
        next.ServeHTTP(w, r)
        log.Debugf("Finished handling http req. %s", id)
    })
}

自定义Logrus Hook：

type RequestIDHook struct{}

func (h *RequestIDHook) Levels() []logrus.Level {
    return logrus.AllLevels
}

func (h *RequestIDHook) Fire(entry *logrus.Entry) error {
    currentGoid := goid.Get()
    if reqID, ok := reqIDStorage.Load(currentGoid); ok {
        entry.Data["requestID"] = reqID
    }
    return nil
}

初始化Logrus时注册Hook：

func init() {
    logrus.AddHook(&RequestIDHook{})
}

这种方式完全不需要修改原有日志调用和处理器代码，所有日志会自动带上当前goroutine对应的请求ID。注意：如果业务中手动启动新goroutine，需要手动将请求ID同步到新goroutine的存储中。

3. 使用原生支持Context的日志库 #

比如zap的zapctx扩展，原生支持从Context中提取字段并自动注入日志：

import (
    "context"
    "go.uber.org/zap"
    "go.uber.org/zap/zapctx"
)

// 中间件中把请求ID存入Context
func reqIDMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        id := uuid.New().String()
        ctx := zapctx.WithValues(r.Context(), "requestID", id)
        r = r.WithContext(ctx)
        
        zapctx.Debug(ctx, "Incoming request", zap.String("method", r.Method), zap.String("uri", r.RequestURI))
        next.ServeHTTP(w, r)
        zapctx.Debug(ctx, "Finished handling http req")
    })
}

处理器中直接使用zapctx的日志函数：

func handleSomeRequest() http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // 原有业务逻辑不变
        zapctx.Debug(r.Context(), "What I just did!")
        // ...其他操作
    }
}

如果项目原本使用zap，这种方式改造量极小；若使用其他日志库，可考虑封装适配层或逐步迁移。

内容的提问来源于stack exchange，提问作者indee423