当前位置：首页 > 文章列表 > Golang > Go教程 > Golang日志库使用与格式自定义教程

Golang日志库使用与格式自定义教程

2025-06-29 09:45:09 0浏览收藏

推广推荐

支持 PC / 移动端，安全直达

Golang小白一枚，正在不断学习积累知识，现将学习到的知识记录一下，也是将我的所得分享给大家！而今天这篇文章《Golang日志库使用与自定义格式详解》带大家来了解一下##content_title##，希望对大家的知识积累有所帮助，从而弥补自己的不足，助力实战开发！

在Golang中实现带颜色的日志输出，需借助第三方库如github.com/fatih/color；1. 引入color库并创建颜色对象，使用color.New()定义不同颜色和样式；2. 使用Fprintf、Printf或Println方法输出带颜色文本；3. 可结合Logger实例，通过SetPrefix设置带颜色的前缀，实现更灵活控制。

Golang的log库如何实现日志记录分享自定义日志格式与输出方法

Golang的log库提供了一套简单但功能强大的日志记录机制。通过自定义格式和输出，我们可以更好地控制日志信息的呈现方式和存储位置，方便问题追踪和系统监控。

自定义日志格式与输出方法主要涉及log.New()函数、log.SetOutput()、log.SetFlags()以及自定义io.Writer接口的实现。

解决方案

使用log.New()创建自定义Logger实例： 这是实现自定义日志格式的核心。log.New()函数接收三个参数：一个io.Writer接口的实例（用于指定日志输出位置）、一个前缀字符串（会添加到每条日志消息的前面）和一个标志位（用于控制日志消息的格式）。

package main

import (
    "io"
    "log"
    "os"
)

func main() {
    // 创建一个输出到标准输出的logger
    logger := log.New(os.Stdout, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile)
    logger.Println("This is an informational message.")

    // 创建一个输出到文件的logger
    file, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    fileLogger := log.New(file, "DEBUG: ", log.Ldate|log.Ltime|log.Lshortfile)
    fileLogger.Println("This is a debug message.")
}

使用log.SetOutput()修改默认Logger的输出位置： 如果不想创建新的Logger实例，可以使用log.SetOutput()函数修改默认Logger的输出位置。

package main

import (
    "log"
    "os"
)

func main() {
    file, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    log.SetOutput(file)
    log.Println("This message will be written to app.log")
}

使用log.SetFlags()修改默认Logger的标志位： log.SetFlags()函数用于设置默认Logger的标志位，控制日期、时间、文件名等信息的显示。

package main

import (
    "log"
)

func main() {
    log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds)
    log.Println("This message will include date, time, and microseconds.")
}

自定义io.Writer接口实现更复杂的日志输出： 如果需要更复杂的日志输出，例如将日志同时输出到多个位置，或者根据日志级别进行不同的处理，可以自定义一个实现了io.Writer接口的类型。

package main

import (
    "io"
    "log"
    "os"
)

// MultiWriter 将日志同时写入多个 io.Writer
type MultiWriter struct {
    writers []io.Writer
}

func (mw *MultiWriter) Write(p []byte) (n int, err error) {
    for _, w := range mw.writers {
        n, err = w.Write(p)
        if err != nil {
            return
        }
    }
    return
}

func main() {
    file, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    mw := &MultiWriter{
        writers: []io.Writer{os.Stdout, file},
    }

    logger := log.New(mw, "CUSTOM: ", log.Ldate|log.Ltime|log.Lshortfile)
    logger.Println("This message will be written to both stdout and app.log")
}

如何在Golang中实现带颜色的日志输出？

要实现带颜色的日志输出，通常需要借助第三方库，例如github.com/fatih/color。这个库允许你在控制台中输出带有ANSI颜色代码的文本。

package main

import (
    "log"
    "os"

    "github.com/fatih/color"
)

func main() {
    // 创建一个logger实例
    logger := log.New(os.Stdout, "", 0)

    // 使用颜色
    red := color.New(color.FgRed).Add(color.Bold)
    green := color.New(color.FgGreen).Add(color.Underline)
    blue := color.New(color.FgBlue)

    // 打印不同颜色的日志
    red.Fprintf(os.Stdout, "This is a red error message.\n")
    green.Printf("This is a green success message.\n")
    blue.Println("This is a blue informational message.")

    // 将颜色与logger结合
    logger.SetPrefix(red.Sprint("ERROR: "))
    logger.Println("This is an error message using the logger.")
}

关键在于使用color.New()创建颜色对象，然后使用Fprintf、Printf或Println方法输出带颜色的文本。也可以通过设置Logger的Prefix来实现更灵活的颜色控制。

如何将Golang日志输出到Elasticsearch或Kafka？

将日志输出到Elasticsearch或Kafka需要使用相应的客户端库。

输出到Elasticsearch:

使用github.com/olivere/elastic/v7库。
创建一个Elasticsearch客户端。
将日志消息格式化为JSON。
使用Bulk Processor高效地将日志数据发送到Elasticsearch。

package main

import (
    "context"
    "encoding/json"
    "log"
    "os"
    "time"

    "github.com/olivere/elastic/v7"
)

type LogMessage struct {
    Timestamp time.Time `json:"timestamp"`
    Level     string    `json:"level"`
    Message   string    `json:"message"`
}

func main() {
    // Elasticsearch 配置
    esURL := "http://localhost:9200"
    indexName := "app-logs"

    // 创建 Elasticsearch 客户端
    client, err := elastic.NewClient(elastic.SetURL(esURL), elastic.SetSniff(false))
    if err != nil {
        log.Fatalf("Error creating Elasticsearch client: %v", err)
    }

    // 创建 Bulk Processor
    bulkProcessor, err := client.BulkProcessor().
        Name("BulkProcessor").
        Workers(2).               // Number of workers
        BulkActions(1000).         // How many actions must be enqueued until a flush
        BulkSize(2 << 20).        // Flush whenever the bulk size exceeds 2 MB
        FlushInterval(10 * time.Second). // Flush every 10 seconds
        Do(context.Background())

    if err != nil {
        log.Fatalf("Error creating Bulk Processor: %v", err)
    }

    defer bulkProcessor.Close()

    // 创建 Logger
    logger := log.New(os.Stdout, "", 0)

    // 模拟日志消息
    for i := 0; i < 10; i++ {
        message := LogMessage{
            Timestamp: time.Now(),
            Level:     "INFO",
            Message:   "This is a test log message.",
        }

        // 序列化为 JSON
        jsonMessage, err := json.Marshal(message)
        if err != nil {
            logger.Printf("Error marshaling JSON: %v", err)
            continue
        }

        // 添加到 Bulk Processor
        req := elastic.NewBulkIndexRequest().Index(indexName).Doc(string(jsonMessage))
        bulkProcessor.Add(req)

        time.Sleep(1 * time.Second)
    }

    logger.Println("Finished sending logs to Elasticsearch.")
}

输出到Kafka:

使用github.com/segmentio/kafka-go库。
创建一个Kafka Writer。
将日志消息序列化为字符串或JSON。
使用Kafka Writer将消息发送到Kafka Topic。

package main

import (
    "context"
    "encoding/json"
    "log"
    "time"

    "github.com/segmentio/kafka-go"
)

type LogMessage struct {
    Timestamp time.Time `json:"timestamp"`
    Level     string    `json:"level"`
    Message   string    `json:"message"`
}

func main() {
    // Kafka 配置
    topic := "app-logs"
    brokerAddress := "localhost:9092"

    // 创建 Kafka Writer
    w := &kafka.Writer{
        Addr:         kafka.TCP(brokerAddress),
        Topic:        topic,
        Balancer:     &kafka.LeastBytes{},
        WriteTimeout: 10 * time.Second,
        ReadTimeout:  10 * time.Second,
    }

    defer w.Close()

    // 创建 Logger
    logger := log.New(log.Writer(), "", 0)

    // 模拟日志消息
    for i := 0; i < 10; i++ {
        message := LogMessage{
            Timestamp: time.Now(),
            Level:     "INFO",
            Message:   "This is a test log message.",
        }

        // 序列化为 JSON
        jsonMessage, err := json.Marshal(message)
        if err != nil {
            logger.Printf("Error marshaling JSON: %v", err)
            continue
        }

        // 创建 Kafka Message
        msg := kafka.Message{
            Key:   []byte("log"),
            Value: jsonMessage,
        }

        // 发送消息到 Kafka
        err = w.WriteMessages(context.Background(), msg)
        if err != nil {
            logger.Printf("Error writing message to Kafka: %v", err)
        }

        logger.Printf("Sent message to Kafka: %s\n", string(jsonMessage))
        time.Sleep(1 * time.Second)
    }

    logger.Println("Finished sending logs to Kafka.")
}

这些示例展示了如何使用相应的客户端库将日志数据发送到Elasticsearch和Kafka。需要注意的是，实际应用中可能需要根据具体需求进行更详细的配置和错误处理。

如何实现日志级别控制，例如Debug、Info、Warn、Error？

日志级别控制允许我们根据不同的环境或需求，选择性地输出不同级别的日志信息。一种常见的实现方式是定义一组常量表示不同的日志级别，然后在Logger中添加一个级别控制变量。

package main

import (
    "fmt"
    "io"
    "log"
    "os"
)

// LogLevel 定义日志级别
type LogLevel int

const (
    LevelDebug LogLevel = iota
    LevelInfo
    LevelWarn
    LevelError
    LevelNone // 关闭所有日志
)

// Logger 自定义Logger
type Logger struct {
    *log.Logger
    level LogLevel
}

// NewLogger 创建一个新的Logger实例
func NewLogger(out io.Writer, prefix string, flag int, level LogLevel) *Logger {
    return &Logger{
        Logger: log.New(out, prefix, flag),
        level:  level,
    }
}

// Debug 输出Debug级别日志
func (l *Logger) Debug(v ...interface{}) {
    if l.level <= LevelDebug {
        l.Output(2, fmt.Sprintln("[DEBUG]", fmt.Sprint(v...)))
    }
}

// Info 输出Info级别日志
func (l *Logger) Info(v ...interface{}) {
    if l.level <= LevelInfo {
        l.Output(2, fmt.Sprintln("[INFO]", fmt.Sprint(v...)))
    }
}

// Warn 输出Warn级别日志
func (l *Logger) Warn(v ...interface{}) {
    if l.level <= LevelWarn {
        l.Output(2, fmt.Sprintln("[WARN]", fmt.Sprint(v...)))
    }
}

// Error 输出Error级别日志
func (l *Logger) Error(v ...interface{}) {
    if l.level <= LevelError {
        l.Output(2, fmt.Sprintln("[ERROR]", fmt.Sprint(v...)))
    }
}

func main() {
    // 创建一个Logger实例，设置日志级别为Info
    logger := NewLogger(os.Stdout, "", log.Ldate|log.Ltime, LevelInfo)

    // 输出不同级别的日志
    logger.Debug("This is a debug message.") // 不会输出
    logger.Info("This is an info message.")   // 会输出
    logger.Warn("This is a warn message.")   // 会输出
    logger.Error("This is an error message.")  // 会输出

    // 修改日志级别为Debug
    logger.level = LevelDebug
    logger.Debug("This is a debug message after level change.") // 会输出
}

这个例子定义了一个Logger结构体，其中包含一个标准的log.Logger实例和一个level字段。通过比较level字段和日志级别常量，可以决定是否输出相应的日志信息。 Output(2, ...)中的 2 表示调用栈的深度，确保输出正确的调用信息。

理论要掌握，实操不能落！以上关于《Golang日志库使用与格式自定义教程》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！

golang 日志记录