Debugging using logs and tracing of the golang framework

Using the logs and tracing of the Golang framework for debugging can ensure the stability of network applications. Logging: Use the log package to record events, with priorities from debug to fatal; the zerolog package provides more customization options. Tracing: Use the trace package to record sequences of events for in-depth debugging. Practical case: Combining logs and tracing to quickly locate the database query timeout problem. The query timed out due to high load on the database server.

Use the logs and traces of the Golang framework for debugging

It is crucial to ensure the stability of network applications, and debugging is one of them Indispensable part. The Golang framework provides powerful logging and tracing functions to facilitate developers to quickly find and solve problems.

Log

##log package : used to record events, the priority is from debug to fatal.

import (
    "log"
)

func ExampleLog() {
    log.Println("Starting the application")
    log.Fatal("Application failed to start")
}

zerolog package: High-performance logging package, providing more customization options.

import (
    "github.com/rs/zerolog"
)

func ExampleZerolog() {
    logger := zerolog.New(os.Stdout).With().Timestamp().Logger()
    logger.Info().Str("event", "started").Msg("Application started")
    logger.Error().Str("error", "timeout").Msg("Request timed out")
}

Trace

trace package: Used to record event sequences for in-depth debugging.

import (
    "context"
    "fmt"
    "github.com/google/uuid"
)

func ExampleTrace() {
    ctx := context.Background()
    tr := trace.Start(ctx, "my-trace-id")
    defer tr.Finish()

    tr.Log(trace.Event{
        Message: "Start processing request",
        Severity: trace.Info,
    })
}

Practical case

In a network service, we encountered a database query timeout problem.

Log: The log records query requests and timeout errors.

log.Println("Starting database query")
err := db.Query("SELECT * FROM users")
if err != nil {
    log.Fatal(err)
}

Tracking: Tracing records the complete execution path, including the execution time of the query.

tr := trace.Start(ctx, "database-query")
defer tr.Finish()

tr.Log(trace.Event{
    Message: "Start database query",
    Severity: trace.Info,
})

defer func() {
    finished := tr.Finished()
    finished.Status = trace.StatusTimeout
    finished.EndTime = message.Timestamp
}

By combining logs and tracing, we quickly located the problem, выяснил, the query timed out due to high load on the database server.

The above is the detailed content of Debugging using logs and tracing of the golang framework. For more information, please follow other related articles on the PHP Chinese website!