How to use context to implement request logging in Go

How to use context to implement request logging in Go

Logging is an important component when developing web applications. It helps developers track application behavior, troubleshoot issues, and monitor system health. In the Go language, we can use the context package in the standard library to implement the request logging function.

context package provides a way to pass request-scoped data to functions and methods. In a web application, each request creates a context.Context object, which contains request-related information, such as request method, path, IP address, etc. By passing context.Context objects to different functions and methods, we can easily record request logs.

Let’s look at an example below to show how to use the context package to implement the request logging function.

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
    "context"
)

func middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()

        // 创建一个新的context对象，并将原有的context作为父context
        ctx := context.WithValue(r.Context(), "start_time", start)

        // 将新的context传递给下一个处理函数
        next.ServeHTTP(w, r.WithContext(ctx))

        elapsed := time.Since(start)
        log.Printf("请求路径：%s 请求时间：%s", r.URL.Path, elapsed)
    })
}

func handler(w http.ResponseWriter, r *http.Request) {
    start := r.Context().Value("start_time").(time.Time)
    elapsed := time.Since(start)

    // 模拟处理请求的耗时
    time.Sleep(time.Second)

    fmt.Fprintf(w, "请求处理时间：%s", elapsed)
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", handler)

    loggedMux := middleware(mux)

    log.Println("服务启动，监听端口8080")
    http.ListenAndServe(":8080", loggedMux)
}

In the above code, we define a middleware function named middleware. The middleware function receives a http.Handler object as a parameter and returns a new http.Handler object. In the middleware function, we obtain the requested context.Context object by calling the r.Context() method, and create a new one using the context.WithValue method context.Context object, and use the original context as the parent context. We then pass the new context.Context object to the next handler function.

In the handler function, we can save it before getting it from the context.Context object by calling the r.Context().Value method. The request start time, and then calculate the processing time of the request.

Finally, in the main function, we create a http.ServeMux object and register the handler function to the root path. We then create a new middleware object by calling the middleware function and passing it as a parameter to the http.ListenAndServe method.

Through the implementation of the above code, we can see the path and processing time of each request in the log, which facilitates our request logging and monitoring.

Summary

Using the context package can easily implement the request logging function. By creating and passing context.Context objects, we can obtain and use request-related data in different functions and methods. This allows us to better track and log the behavior of requests, as well as troubleshoot issues and monitor the health of the system.

The above is the detailed content of How to use context to implement request logging in Go. For more information, please follow other related articles on the PHP Chinese website!