如何使用golang的log库实现结构化日志？1.自定义formatter将日志格式化为json等结构化格式；2.通过context集成上下文信息如请求id、用户id；3.使用setoutput方法控制日志输出目标。通过自定义logentry结构和jsonformatter格式化器，将日志转换为json格式；在中间件中将请求相关信息存入context，并在记录日志时提取；最后可将日志输出到文件、网络等目标，只需实现io.writer接口即可。
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中提取这些信息。
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")
}在这个例子中，
init函数打开一个名为
app.log的文件，并将
InfoLogger和
ErrorLogger的输出目标设置为该文件。如果文件不存在，则创建该文件。
除了文件，还可以将日志输出到网络、数据库等其他目标。只需要实现
io.Writer接口，然后将其传递给
SetOutput方法即可。
