Golang中如何记录错误日志 Golang错误日志记录方法

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

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

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，程序会继续执行
}

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

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
    }
}