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

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.")
}

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.")
}

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.")
}

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.") // 会输出
}