Go语言AWS Lambda带执行UUID的日志实例共享方案咨询

方案1：通过Context传递带Trace ID的Logger #

Lambda的Handler本身就接收context.Context参数，这是天然的请求级上下文载体。我们可以在Handler初始化带UUID的zap.Logger后，将其存入Context，后续Service/Repository层从Context中取出使用，避免逐层传参或循环导入问题。

实现步骤： #

• 定义私有类型作为Context的key，避免和其他Context值冲突：

// 在internal/logger公共包中定义
type loggerKey struct{}

• 在Lambda Handler中生成UUID，初始化Logger并存入Context：

// cmd/lambda/main.go
func Handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
    traceID := uuid.NewString()
    logger, _ := zap.NewProduction(zap.Fields(zap.String("trace_id", traceID)))
    ctx = context.WithValue(ctx, loggerKey{}, logger)
    
    svc := service.NewService(ctx)
    res, err := svc.DoSomething()
    // 后续处理逻辑
}

• 在Service/Repository层从Context中取出Logger：

// cmd/service/service.go
func NewService(ctx context.Context) *Service {
    logger := ctx.Value(loggerKey{}).(*zap.Logger)
    return &Service{logger: logger}
}

func (s *Service) DoSomething() error {
    s.logger.Info("service executing logic")
    repo := repository.NewRepo(ctx)
    return repo.FetchData()
}

方案2：封装请求级日志工具包 #

创建全局日志工具包，但不维护全局Logger实例，而是通过Context传递Trace ID，日志工具自动提取ID并附加到日志字段。这种方式无需传递Logger实例，只需在调用日志方法时传入Context即可。

实现步骤： #

• 日志包提供Trace ID注入和日志方法：

// internal/logger/logger.go
type traceIDKey struct{}

// SetTraceID 将Trace ID存入Context
func SetTraceID(ctx context.Context, traceID string) context.Context {
    return context.WithValue(ctx, traceIDKey{}, traceID)
}

// Info 从Context提取Trace ID并打印结构化日志
func Info(ctx context.Context, msg string, fields ...zap.Field) {
    if traceID, ok := ctx.Value(traceIDKey{}).(string); ok {
        fields = append(fields, zap.String("trace_id", traceID))
    }
    zap.L().Info(msg, fields...)
}

• 在Lambda Handler中生成Trace ID并注入Context：

// cmd/lambda/main.go
func Handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
    traceID := uuid.NewString()
    ctx = logger.SetTraceID(ctx, traceID)
    
    svc := service.NewService()
    res, err := svc.DoSomething(ctx)
    // 后续处理逻辑
}

• Service/Repository层直接调用日志包方法：

// cmd/service/service.go
func (s *Service) DoSomething(ctx context.Context) error {
    logger.Info(ctx, "processing request in service")
    return repository.FetchData(ctx)
}

方案3：依赖注入初始化请求级组件 #

在Lambda Handler中，针对每个请求初始化带Trace ID的Logger，再将Logger注入Service和Repository实例。这种方式避免循环导入（Service/Repository仅依赖zap.Logger接口，不依赖main包），同时保证每个请求使用独立的Logger实例。

实现步骤： #

• Service/Repository定义接收Logger的构造函数：

// cmd/service/service.go
type Service struct {
    logger *zap.Logger
}

func NewService(logger *zap.Logger) *Service {
    return &Service{logger: logger}
}

func (s *Service) DoSomething() error {
    s.logger.Info("executing service business logic")
    repo := repository.NewRepo(s.logger)
    return repo.GetData()
}

• 在Lambda Handler中创建Logger并注入：

// cmd/lambda/main.go
func Handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
    traceID := uuid.NewString()
    logger, _ := zap.NewProduction(zap.Fields(zap.String("trace_id", traceID)))
    
    svc := service.NewService(logger)
    res, err := svc.DoSomething()
    // 后续处理逻辑
}

如果担心重复创建实例的开销，可将组件设计为无状态，仅在方法调用时接收Logger或带Logger的Context。

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