golang带堆栈跟踪和对象转储功能的日志记录插件库go-log的使用

golang带堆栈跟踪和对象转储功能的日志记录插件库go-log的使用

介绍

go-log是一个Golang日志库,提供了带堆栈跟踪和对象转储功能的日志记录功能。

使用示例

下面是一个完整的go-log使用示例:

package main

import (
    "errors"
    "github.com/pieterclaerhout/go-log"
)

// 模拟一个返回错误的函数
func funcWithError() error {
    return errors.New("something went wrong")
}

func main() {
    // 配置日志参数
    log.DebugMode = true      // 启用调试模式
    log.PrintTimestamp = true // 打印时间戳
    log.PrintColors = true    // 启用颜色输出
    log.TimeFormat = "2006-01-02 15:04:05.000" // 时间格式

    // 定义一个测试变量
    myVar := map[string]string{"hello": "world"}

    // 调试级别日志
    log.Debug("arg1", "arg2")                     // 调试日志
    log.Debugf("arg1 %d", 1)                      // 格式化调试日志
    log.DebugDump(myVar, "prefix")                // 调试输出变量内容
    log.DebugSeparator("title")                   // 调试分隔线

    // 信息级别日志
    log.Info("arg1", "arg2")                      // 信息日志
    log.Infof("arg1 %d", 1)                       // 格式化信息日志
    log.InfoDump(myVar, "prefix")                 // 信息输出变量内容
    log.InfoSeparator("title")                    // 信息分隔线

    // 警告级别日志
    log.Warn("arg1", "arg2")                      // 警告日志
    log.Warnf("arg1 %d", 1)                       // 格式化警告日志
    log.WarnDump(myVar, "prefix")                 // 警告输出变量内容
    log.WarnSeparator("title")                    // 警告分隔线

    // 错误级别日志
    log.Error("arg1", "arg2")                     // 错误日志
    log.Errorf("arg1 %d", 1)                      // 格式化错误日志
    log.ErrorDump(myVar, "prefix")                // 错误输出变量内容
    log.ErrorSeparator("title")                   // 错误分隔线

    // 致命错误日志(会终止程序)
    // log.Fatal("arg1", "arg2")                   // 致命错误日志
    // log.Fatalf("arg1 %d", 1)                    // 格式化致命错误日志

    // 错误处理
    err1 := funcWithError()
    log.StackTrace(err1)                          // 打印错误堆栈跟踪

    err2 := funcWithError()
    log.CheckError(err2)                          // 检查错误并打印
}

环境变量配置

可以通过环境变量来配置go-log的默认行为:

  • DEBUG: 控制log.DebugMode,启用或禁用调试模式
  • PRINT_TIMESTAMP: 控制log.PrintTimestamp,启用或禁用时间戳打印

功能说明

  1. 日志级别:支持Debug、Info、Warn、Error和Fatal多种日志级别
  2. 格式化输出:提供类似fmt.Printf的格式化日志方法(如Debugf、Infof等)
  3. 变量转储:可以方便地转储变量内容(DebugDump、InfoDump等方法)
  4. 分隔线:可以输出带标题的分隔线(DebugSeparator、InfoSeparator等方法)
  5. 错误处理:提供StackTrace和CheckError方法来处理错误并打印堆栈跟踪
  6. 自定义配置:可以配置时间格式、颜色输出等参数

这个库非常适合需要详细日志记录和调试信息的Golang项目。


更多关于golang带堆栈跟踪和对象转储功能的日志记录插件库go-log的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang带堆栈跟踪和对象转储功能的日志记录插件库go-log的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


go-log 日志库使用指南

go-log 是一个功能强大的 Go 语言日志记录库,提供了堆栈跟踪和对象转储功能,非常适合调试和问题排查。下面我将详细介绍其使用方法。

安装

go get github.com/ipfs/go-log

基本使用

package main

import (
	"github.com/ipfs/go-log"
)

var logger = log.Logger("example")

func main() {
	// 设置日志级别
	log.SetLogLevel("example", "info")

	// 基本日志记录
	logger.Debug("这是一条调试信息")  // 不会输出,因为级别是info
	logger.Info("这是一条普通信息")
	logger.Warn("这是一条警告信息")
	logger.Error("这是一条错误信息")
}

带堆栈跟踪的日志

func someFunction() {
	// 记录错误并附带堆栈跟踪
	err := someOperation()
	if err != nil {
		logger.Errorf("操作失败: %v", err)
		// 或者使用带堆栈的版本
		logger.Errorw("操作失败", "error", err, "stack", log.Stack())
	}
}

func someOperation() error {
	return fmt.Errorf("模拟错误")
}

对象转储功能

type User struct {
	Name string
	Age  int
}

func dumpExample() {
	user := User{
		Name: "张三",
		Age:  30,
	}

	// 转储对象结构
	logger.Debugf("用户对象: %+v", user)
	// 或者使用专门的转储方法
	logger.Debugw("用户详情", "user", log.Dump(user))
}

高级配置

func setupLogger() {
	// 配置日志输出
	cfg := log.Config{
		Format: log.JSONOutput, // 或者 log.ColorizedOutput
		Stderr: true,          // 输出到标准错误
		Level:  log.LevelInfo, // 日志级别
	}

	// 应用配置
	log.SetupLogging(cfg)

	// 或者单独配置某个logger
	log.SetLogLevelRegex("example", "debug")
}

完整示例

package main

import (
	"fmt"
	"time"

	"github.com/ipfs/go-log"
)

var logger = log.Logger("demo")

type Order struct {
	ID     string
	Amount float64
	Items  []string
}

func processOrder(order Order) error {
	logger.Infow("开始处理订单", 
		"orderID", order.ID,
		"amount", order.Amount,
		"items", order.Items,
		"time", time.Now())

	// 模拟处理
	time.Sleep(100 * time.Millisecond)

	// 模拟错误
	if order.Amount > 1000 {
		return fmt.Errorf("金额超过限制")
	}

	logger.Debug("订单处理完成")
	return nil
}

func main() {
	// 配置日志
	log.SetLogLevel("demo", "debug")
	log.SetupLogging(log.Config{
		Format: log.ColorizedOutput,
		Stderr: true,
	})

	order := Order{
		ID:     "12345",
		Amount: 1500.00,
		Items:  []string{"商品A", "商品B"},
	}

	err := processOrder(order)
	if err != nil {
		logger.Errorw("订单处理失败",
			"error", err,
			"stack", log.Stack(),  // 包含堆栈跟踪
			"order", log.Dump(order)) // 转储订单对象
	}
}

日志级别

go-log 支持以下日志级别(从低到高):

  • Debug
  • Info
  • Warn
  • Error
  • DPanic
  • Panic
  • Fatal

性能考虑

对于生产环境:

  1. 适当提高日志级别(如Info或Warn)
  2. 避免在高频路径中使用Debug日志
  3. 复杂对象的转储操作应谨慎使用

go-log 提供了丰富的日志功能,特别适合需要详细调试信息的场景。通过堆栈跟踪和对象转储,可以快速定位问题所在。

回到顶部