如何使用 Gin 上下文创建的请求 ID 记录 HTTP 客户端的请求

学习知识要善于思考，思考，再思考！今天golang学习网小编就给大家带来《如何使用 Gin 上下文创建的请求 ID 记录 HTTP 客户端的请求》，以下内容主要包含等知识点，如果你正在学习或准备学习Golang，就都不要错过本文啦~让我们一起来看看吧，能帮助到你就更好了！

想法：我想使用唯一的请求 id 记录传入和传出的请求到我的 gin 服务器。另外，我想使用与路由相同的请求 id 来记录我的 gin 路由中的所有 http 客户端请求。

所有这些都应该使用中间件在幕后工作。

记录对我的服务器的请求（和响应）

为了记录到我的服务器的每个请求，我编写了这个中间件：

import (
    "bytes"
    "context"
    "github.com/gin-contrib/requestid"
    "github.com/gin-gonic/gin"
    "github.com/rs/zerolog/log"
    "io/ioutil"
    "net/http"
    "time"
)

type responsebodywriter struct {
    gin.responsewriter
    body *bytes.buffer
}

func (r responsebodywriter) write(b []byte) (int, error) {
    r.body.write(b)
    return r.responsewriter.write(b)
}

func loggermiddleware() gin.handlerfunc {
    return func(c *gin.context) {

        start := time.now()

        w := &responsebodywriter{body: &bytes.buffer{}, responsewriter: c.writer}
        c.writer = w

        msg := "input:"
        path := c.request.url.path
        raw := c.request.url.rawquery
        if raw != "" {
            path = path + "?" + raw
        }

        // read from body and write here again.
        var bodybytes []byte
        if c.request.body != nil {
            bodybytes, _ = ioutil.readall(c.request.body)
        }
        c.request.body = ioutil.nopcloser(bytes.newbuffer(bodybytes))

        inputlogger := log.with().
            str("method", c.request.method).
            str("path", path).
            str("requestid", requestid.get(c)).
            logger()

        if len(bodybytes) > 0 {
            inputlogger.info().rawjson("body", bodybytes).msg(msg)
        } else {
            inputlogger.info().msg(msg)
        }

        c.next()

        end := time.now()
        latency := end.sub(start)

        msg = "output:"
        outputlogger := log.with().
            str("method", c.request.method).
            str("path", path).
            str("requestid", requestid.get(c)).
            rawjson("body", w.body.bytes()).
            int("status", c.writer.status()).
            dur("latency", latency).
            logger()

        switch {
        case c.writer.status() >= http.statusbadrequest && c.writer.status() < http.statusinternalservererror:
            {
                outputlogger.warn().msg(msg)
            }
        case c.writer.status() >= http.statusinternalservererror:
            {
                outputlogger.error().msg(msg)
            }
        default:
            outputlogger.info().msg(msg)
        }

    }
}

记录我的服务器路由内发出的请求

问题是：我不知道如何将 gin 中间件创建的请求 id（或 gin 的上下文）传递给 roundtrip 函数：

type Transport struct {
    Transport  http.RoundTripper
}

var defaultTransport = Transport{
    Transport: http.DefaultTransport,
}

func init() {
    http.DefaultTransport = &defaultTransport
}

func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
    ctx := context.WithValue(req.Context(), ContextKeyRequestStart, time.Now())
    req = req.WithContext(ctx)
    t.logRequest(req)

    resp, err := t.transport().RoundTrip(req)
    if err != nil {
        return resp, err
    }

    t.logResponse(resp)

    return resp, err
}

func (t *Transport) logRequest(req *http.Request) {
    log.Info().
        Str("method", req.Method).
        Str("path", req.URL.String()).
        Str("requestId", "how can I get request id here???").
        Msg("Api request: ")
}

func (t *Transport) logResponse(resp *http.Response) {
    var bodyBytes []byte
    if resp.Body != nil {
        bodyBytes, _ = ioutil.ReadAll(resp.Body)
    }
    resp.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))

    ctx := resp.Request.Context()
    log.Info().
        Str("method", resp.Request.Method).
        Str("path", resp.Request.URL.String()).
        Str("requestId", "how can I get request id here???").
        RawJSON("body", bodyBytes).
        Int("status", resp.StatusCode).
        Dur("latency", time.Now().Sub(ctx.Value(ContextKeyRequestStart).(time.Time))).
        Msg("API response: ")
}

func (t *Transport) transport() http.RoundTripper {
    if t.Transport != nil {
        return t.Transport
    }

    return http.DefaultTransport
}

正确答案

transport.roundtrip 函数采用 *http.request 参数，因此您应该能够通过在处理程序中创建请求来传递 gin 上下文：

func myhandler(c *gin.context) {
        // passing context to the request
        req := http.newrequestwithcontext(c, "get", "http://localhost:8080", nil)
        resp, err := http.defaultclient.do(req)
}

请注意，为了能够使用您覆盖的默认 roundtripper 而无需额外初始化，您应该使用 http.defaultclient。

您可以使用以下内容：
https://github.com/sumit-tembe/gin-requestid

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
    requestid "github.com/sumit-tembe/gin-requestid"
)

func main() {
    // without any middlewares
    router := gin.new()

    // middlewares
    {
        //recovery middleware
        router.use(gin.recovery())
        //middleware which injects a 'requestid' into the context and header of each request.
        router.use(requestid.requestid(nil))
        //middleware which enhance gin request logger to include 'requestid'
        router.use(gin.loggerwithconfig(requestid.getloggerconfig(nil, nil, nil)))
    }

    router.get("/", func(c *gin.context) {
        c.string(http.statusok, "hello world!")
    })

    router.run(":8080")
}

输出：

[GIN-debug] 2019-12-16T18:50:49+05:30 [bzQg6wTpL4cdZ9bM] - "GET /"
[GIN-debug] 2019-12-16T18:50:49+05:30 [bzQg6wTpL4cdZ9bM] - [::1] "GET / HTTP/1.1 200 22.415µs" Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36

它还支持自定义请求id生成器，您可以根据需要设计。

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~