Golang的log库如何实现结构化日志集成context和自定义输出-Golang-PHP中文网

Golang的log库如何实现结构化日志集成context和自定义输出

P粉602998670

发布： 2025-08-04 09:30:02

原创

590人浏览过

如何使用golang的log库实现结构化日志？1.自定义formatter将日志格式化为json等结构化格式；2.通过context集成上下文信息如请求id、用户id；3.使用setoutput方法控制日志输出目标。通过自定义logentry结构和jsonformatter格式化器，将日志转换为json格式；在中间件中将请求相关信息存入context，并在记录日志时提取；最后可将日志输出到文件、网络等目标，只需实现io.writer接口即可。

Golang的log库如何实现结构化日志集成context和自定义输出

Golang的log库实现结构化日志，关键在于自定义日志格式和利用

context

登录后复制

传递信息，同时可以灵活地控制日志的输出目标。通过自定义格式化器，可以将日志信息组织成JSON或其他结构化格式，方便后续的分析和处理。而集成

context

登录后复制

，则允许在日志中包含请求ID、用户ID等上下文信息，便于追踪和调试。

解决方案

自定义日志格式： 使用
```
log
```
登录后复制
包提供的
```
SetOutput
```
登录后复制
和
```
SetFlags
```
登录后复制
方法可以控制日志的输出目标和格式。但是，要实现真正的结构化日志，需要自定义
```
Formatter
```
登录后复制
，将日志信息转换为JSON或其他结构化格式。
集成Context： 通过中间件将请求ID、用户ID等信息存储到
```
context
```
登录后复制
中。然后在日志记录时，从
```
context
```
登录后复制
中提取这些信息，并将其包含在日志消息中。
自定义输出：
```
log
```
登录后复制
包默认输出到标准输出，可以通过
```
SetOutput
```
登录后复制
方法将日志输出到文件、网络或其他目标。

如何自定义Golang log库的结构化日志格式？

自定义结构化日志格式，通常涉及创建一个自定义的

Formatter

登录后复制

。这个

Formatter

登录后复制

负责将日志消息转换为特定的结构化格式，比如JSON。以下是一个简单的例子：

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
    "time"
)

type LogEntry struct {
    Time    string      `json:"time"`
    Level   string      `json:"level"`
    Message string      `json:"message"`
    Data    interface{} `json:"data,omitempty"` // 可选的额外数据
}

type JSONFormatter struct{}

func (f *JSONFormatter) Format(level string, message string, data interface{}) ([]byte, error) {
    entry := LogEntry{
        Time:    time.Now().Format(time.RFC3339),
        Level:   level,
        Message: message,
        Data:    data,
    }
    return json.Marshal(entry)
}

var (
    InfoLogger  *log.Logger
    ErrorLogger *log.Logger
)

func init() {
    formatter := &JSONFormatter{}

    InfoLogger = log.New(os.Stdout, "INFO: ", 0)
    ErrorLogger = log.New(os.Stderr, "ERROR: ", 0)
}

func LogInfo(message string, data interface{}) {
    formatter := &JSONFormatter{}
    logData, err := formatter.Format("INFO", message, data)
    if err != nil {
        ErrorLogger.Println("Failed to format log message:", err)
        return
    }
    InfoLogger.Println(string(logData))
}

func LogError(message string, data interface{}) {
    formatter := &JSONFormatter{}
    logData, err := formatter.Format("ERROR", message, data)
    if err != nil {
        ErrorLogger.Println("Failed to format log message:", err)
        return
    }
    ErrorLogger.Println(string(logData))
}

func main() {
    LogInfo("User logged in", map[string]interface{}{"user_id": 123, "username": "example"})
    LogError("Failed to process request", map[string]interface{}{"error": "Timeout", "request_id": "abc-123"})
}

登录后复制

这个例子定义了一个

JSONFormatter

登录后复制

，它将日志消息格式化为JSON。然后，创建了两个

Logger

登录后复制

实例，分别用于记录Info和Error级别的日志。注意，这里并没有使用

log.SetOutput

登录后复制

和

log.SetFlags

登录后复制

，而是直接创建了新的

Logger

登录后复制

实例，并指定了输出目标。

立即学习“go语言免费学习笔记（深入）”；

如何在Golang的log库中集成context传递上下文信息？

集成

context

登录后复制

的关键在于，在处理请求的中间件中，将必要的信息存储到

context

登录后复制

中，然后在日志记录时，从

context

登录后复制

中提取这些信息。

豆绘AI

豆绘AI是国内领先的AI绘图与设计平台，支持照片、设计、绘画的一键生成。

485

查看详情

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"
    "time"
)

type contextKey string

const (
    requestIDKey contextKey = "requestID"
)

var (
    InfoLogger  *log.Logger
    ErrorLogger *log.Logger
)

func init() {
    InfoLogger = log.New(os.Stdout, "INFO: ", log.Ldate|log.Ltime)
    ErrorLogger = log.New(os.Stderr, "ERROR: ", log.Ldate|log.Ltime)
}

func LogWithContext(ctx context.Context, level string, message string) {
    requestID := ctx.Value(requestIDKey)
    if requestID == nil {
        requestID = "N/A"
    }

    logMessage := fmt.Sprintf("[%s] RequestID: %v, Message: %s", level, requestID, message)

    switch level {
    case "INFO":
        InfoLogger.Println(logMessage)
    case "ERROR":
        ErrorLogger.Println(logMessage)
    default:
        InfoLogger.Println(logMessage)
    }
}

func RequestIDMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        requestID := fmt.Sprintf("%d", time.Now().UnixNano())
        ctx := context.WithValue(r.Context(), requestIDKey, requestID)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        LogWithContext(ctx, "INFO", "Handling request")
        fmt.Fprintln(w, "Hello, World!")
    })

    wrappedHandler := RequestIDMiddleware(http.DefaultServeMux)

    server := &http.Server{
        Addr:    ":8080",
        Handler: wrappedHandler,
    }

    InfoLogger.Println("Server starting on :8080")
    if err := server.ListenAndServe(); err != nil {
        ErrorLogger.Fatalf("Server failed to start: %v", err)
    }
}

登录后复制

在这个例子中，

RequestIDMiddleware

登录后复制

中间件生成一个唯一的请求ID，并将其存储到

context

登录后复制

中。然后，

LogWithContext

登录后复制

函数从

context

登录后复制

中提取请求ID，并将其包含在日志消息中。

如何自定义Golang log库的输出目标？

log

登录后复制

包提供了

SetOutput

登录后复制

方法，可以方便地将日志输出到不同的目标，例如文件。

package main

import (
    "log"
    "os"
)

var (
    InfoLogger  *log.Logger
    ErrorLogger *log.Logger
)

func init() {
    file, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        log.Fatal("Failed to open log file:", err)
    }

    InfoLogger = log.New(file, "INFO: ", log.Ldate|log.Ltime)
    ErrorLogger = log.New(file, "ERROR: ", log.Ldate|log.Ltime)
}

func main() {
    InfoLogger.Println("Application started")
    ErrorLogger.Println("An error occurred")
}

登录后复制

在这个例子中，