记录错误日志的关键在于选择合适的日志库、配置日志级别、正确记录错误信息、处理panic、输出日志到不同地方及在分布式系统中追踪日志。1. 日志库推荐logrus（适合灵活配置）、zap和zerolog（适合高性能需求）；2. 日志级别按环境设置，开发设为debug，生产设为info或warn；3. 记录错误需包含时间、位置、上下文，并使用%w包装保留堆栈；4. 使用recover捕获panic并记录；5. 通过logrus的hook机制将日志输出至文件、数据库等；6. 在分布式系统中集成jaeger等追踪系统，实现日志关联与请求追踪。
记录错误日志，简单来说，就是在你的Go程序里，当事情出错的时候，把错误信息保存下来，方便你以后排查问题。这听起来很简单，但做好它能帮你省下大把的时间和精力。
记录错误日志，通常涉及选择合适的日志库，配置日志级别，以及在代码中正确地记录错误信息。
如何选择合适的Golang日志库？
Golang本身自带了log包，但它功能比较基础，只适合简单的日志记录。对于稍微复杂一点的项目，建议使用第三方的日志库，比如logrus、zap、zerolog等等。
立即学习“go语言免费学习笔记（深入）”；
选择哪个库取决于你的需求：
- logrus: 功能全面，配置灵活，社区活跃，但性能相对较慢。适合对性能要求不高的项目，或者需要丰富配置的项目。
- zap: Uber开源的高性能日志库，性能非常出色，但配置相对复杂。适合对性能要求高的项目。
- zerolog: 专注于零分配的日志库，性能也很不错，API简洁。适合对性能有较高要求的项目。
我的个人经验是，如果项目对性能要求不是特别高，logrus是一个不错的选择，它的配置非常灵活，可以满足各种需求。如果对性能有极致的追求，zap或者zerolog会更适合。
如何配置日志级别？
日志级别决定了哪些信息会被记录下来。常见的日志级别包括：
- Debug: 调试信息，一般用于开发阶段。
- Info: 普通信息，用于记录程序的运行状态。
- Warn: 警告信息，表示程序可能存在问题，但不影响正常运行。
- Error: 错误信息，表示程序出现了错误，可能会影响正常运行。
- Fatal: 致命错误，表示程序无法继续运行。
在生产环境中，通常会将日志级别设置为Info或者Warn，避免记录过多的调试信息，影响性能。在开发环境中，可以设置为Debug，方便调试。
以logrus为例，配置日志级别的代码如下：
import (
"github.com/sirupsen/logrus"
)
func main() {
logrus.SetLevel(logrus.DebugLevel) // 设置日志级别为Debug
logrus.Debug("This is a debug message")
logrus.Info("This is an info message")
logrus.Warn("This is a warning message")
logrus.Error("This is an error message")
logrus.Fatal("This is a fatal message")
}如何在代码中正确地记录错误信息？
记录错误信息，最重要的是要包含足够的信息，方便以后排查问题。通常需要包含以下信息：
- 错误发生的时间
- 错误发生的位置（文件名、行号）
- 错误的详细描述
- 相关的上下文信息
Go语言的错误处理机制是基于返回值的，所以通常需要在函数中显式地检查错误，并记录下来。
漂亮的企业网站。NET2.0出来了， 本次升级修改如下： 1、优化了3层结构。 2、优化了后台管理代码，增强了安全性能。 3、增加了系统名称及关键字管理。 4、增加了系统错误日志记录，自动生成Systemlog.log日志文件。 备注：本系统采用ASP.NET 2.O+ACCESS开发，请调试的朋友安装.NET2.0运行环境！ 网站内容 网站栏目包括 首页|企业简介|新闻中心|产品展示|公司展示|
import (
"fmt"
"os"
"github.com/sirupsen/logrus"
)
func readFile(filename string) ([]byte, error) {
file, err := os.Open(filename)
if err != nil {
logrus.Errorf("Failed to open file %s: %v", filename, err)
return nil, fmt.Errorf("failed to open file: %w", err) // 使用 %w 包装原始错误
}
defer file.Close()
fileInfo, err := file.Stat()
if err != nil {
logrus.Errorf("Failed to get file info for %s: %v", filename, err)
return nil, fmt.Errorf("failed to get file info: %w", err)
}
buffer := make([]byte, fileInfo.Size())
_, err = file.Read(buffer)
if err != nil {
logrus.Errorf("Failed to read file %s: %v", filename, err)
return nil, fmt.Errorf("failed to read file: %w", err)
}
return buffer, nil
}
func main() {
logrus.SetLevel(logrus.DebugLevel)
content, err := readFile("nonexistent_file.txt")
if err != nil {
logrus.Errorf("Main function error: %v", err) // 在主函数中也记录错误
return
}
fmt.Println(string(content))
}这段代码展示了如何使用logrus记录错误信息，并且使用了%w来包装原始错误，这样可以保留错误的堆栈信息，方便以后排查问题。同时，在主函数中也记录了错误，这样可以更好地追踪错误的来源。
如何处理panic？
panic是Golang中一种特殊的错误处理机制，表示程序遇到了无法恢复的错误。如果不处理panic，程序会直接崩溃。为了避免程序崩溃，可以使用recover来捕获panic，并记录下来。
import (
"fmt"
"github.com/sirupsen/logrus"
)
func recoverPanic() {
if r := recover(); r != nil {
logrus.Errorf("Recovered from panic: %v", r)
// 这里可以做一些清理工作，比如关闭数据库连接
}
}
func mightPanic() {
defer recoverPanic() // 确保在函数退出时执行 recoverPanic
panic("Something went wrong")
}
func main() {
logrus.SetLevel(logrus.DebugLevel)
mightPanic()
fmt.Println("Program continues after panic") // 如果panic被recover，程序会继续执行
}这段代码展示了如何使用recover捕获panic，并记录下来。需要注意的是，recover只能在defer函数中使用。
如何将日志输出到不同的地方？
通常情况下，我们会将日志输出到控制台或者文件中。但有时候，我们需要将日志输出到不同的地方，比如数据库、消息队列等等。
logrus提供了Hook机制，可以方便地将日志输出到不同的地方。
import (
"github.com/sirupsen/logrus"
"gopkg.in/olivere/elastic.v5" // 注意版本兼容性
)
type ElasticsearchHook struct {
client *elastic.Client
index string
}
func NewElasticsearchHook(client *elastic.Client, index string) (*ElasticsearchHook, error) {
return &ElasticsearchHook{client: client, index: index}, nil
}
func (hook *ElasticsearchHook) Levels() []logrus.Level {
return []logrus.Level{
logrus.ErrorLevel,
logrus.FatalLevel,
logrus.PanicLevel,
}
}
func (hook *ElasticsearchHook) Fire(entry *logrus.Entry) error {
_, err := hook.client.Index().
Index(hook.index).
Type("log").
BodyJson(entry.Data).
Do()
return err
}
func main() {
logrus.SetLevel(logrus.DebugLevel)
// Elasticsearch 配置
esClient, err := elastic.NewClient(elastic.SetURL("http://localhost:9200"))
if err != nil {
logrus.Fatalf("Failed to create Elasticsearch client: %v", err)
}
esHook, err := NewElasticsearchHook(esClient, "my-app-logs")
if err != nil {
logrus.Fatalf("Failed to create Elasticsearch hook: %v", err)
}
logrus.AddHook(esHook)
logrus.Error("This is an error message that will be sent to Elasticsearch")
}这段代码展示了如何使用logrus的Hook机制，将错误日志输出到Elasticsearch中。需要注意的是，需要引入olivere/elastic.v5这个库，并且需要配置Elasticsearch的连接信息。
如何在分布式系统中追踪日志？
在分布式系统中，日志分散在不同的机器上，排查问题非常困难。为了解决这个问题，可以使用分布式追踪系统，比如Jaeger、Zipkin等等。
这些系统可以追踪请求在不同服务之间的调用关系，并将日志关联起来，方便排查问题。
import (
"context"
"fmt"
"io"
"net/http"
"os"
"github.com/opentracing/opentracing-go"
"github.com/opentracing/opentracing-go/ext"
"github.com/uber/jaeger-client-go"
"github.com/uber/jaeger-client-go/config"
)
func initJaeger(service string) (opentracing.Tracer, io.Closer, error) {
cfg := &config.Configuration{
ServiceName: service,
Sampler: &config.SamplerConfig{
Type: jaeger.SamplerTypeConst,
Param: 1,
},
Reporter: &config.ReporterConfig{
LogSpans: true,
// 将span发送到jaeger agent
CollectorEndpoint: "http://localhost:14268/api/traces",
// 如果jaeger agent在本机，则无需配置以下两项
//LocalAgentHostPort: "127.0.0.1:6832",
},
}
tracer, closer, err := cfg.NewTracer(config.Logger(jaeger.StdLogger))
if err != nil {
return nil, nil, err
}
opentracing.SetGlobalTracer(tracer)
return tracer, closer, nil
}
func main() {
tracer, closer, err := initJaeger("my-go-service")
if err != nil {
fmt.Printf("Could not initialize jaeger tracer: %s\n", err.Error())
os.Exit(1)
}
defer closer.Close()
http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
span := tracer.StartSpan("/hello")
defer span.Finish()
ctx := opentracing.ContextWithSpan(context.Background(), span)
helloHandler(ctx, w, r)
})
fmt.Println("Server listening on :8080")
http.ListenAndServe(":8080", nil)
}
func helloHandler(ctx context.Context, w http.ResponseWriter, r *http.Request) {
span := opentracing.SpanFromContext(ctx)
span.LogKV("event", "handling request") // 添加日志
_, err := fmt.Fprintf(w, "Hello, world!\n")
if err != nil {
ext.Error.Set(span, true) // 标记错误
span.LogKV("error", err.Error())
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}这段代码展示了如何使用Jaeger追踪请求，并将日志关联起来。需要注意的是，需要引入github.com/opentracing/opentracing-go和github.com/uber/jaeger-client-go这两个库，并且需要配置Jaeger的连接信息。
总而言之，记录错误日志是一个非常重要的环节，它能帮助你快速定位问题，提高开发效率。选择合适的日志库，配置合适的日志级别，并在代码中正确地记录错误信息，是做好错误日志记录的关键。
