When you’re building web applications using the Gin framework in Go, you can’t overlook the importance of logging incoming requests. It’s not just about keeping tabs on things—logging plays a big role in monitoring, debugging, and ensuring your app is running smoothly. Let’s dive into how to effectively log incoming requests using request logger middleware.

Logging is like the eyes and ears of your application. Without it, you’d be pretty much flying blind. It helps you see how your app is performing, track user interactions, and quickly spot and fix any issues. In a production environment, reliable logging is what keeps your app transparent and running like a well-oiled machine.

First things first, let’s get a basic Gin application up and running. Imagine a starter example that gets you up to speed in no time.

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.New()
    r.GET("/test", func(c *gin.Context) {
        c.String(200, "Hello, World!")
    })
    r.Run(":8080")
}

This simple code sets up a Gin server that listens on port 8080 and responds to GET requests aimed at the /test endpoint.

Now, to log incoming requests, middleware packages come to the rescue. One popular option is the gin-contrib/logger package. It combines access and error logs, making your life easier.

First, you need to install the gin-contrib/logger package. With Go modules, it’s a piece of cake:

go get github.com/gin-contrib/logger

Let’s see how to plug this logger middleware into your Gin application:

package main

import (
    "fmt"
    "net/http"
    "time"

    "github.com/gin-contrib/logger"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.New()
    r.Use(logger.SetLogger())
    r.GET("/pong", func(c *gin.Context) {
        c.String(http.StatusOK, "pong "+fmt.Sprint(time.Now().Unix()))
    })
    r.Run(":8080")
}

In this example, logger.SetLogger() logs all incoming requests to the console. Of course, you can tweak this behavior to fit your needs by passing extra options to the logger.

You may have specific requirements for your logging setup, like skipping certain paths or using regular expressions to filter out specific routes. Check out this example that shows how to skip logging for particular paths and use UTC time:

package main

import (
    "fmt"
    "net/http"
    "regexp"
    "time"

    "github.com/gin-contrib/logger"
    "github.com/gin-gonic/gin"
)

var rxURL = regexp.MustCompile(`^/regexp\d*`)

func main() {
    r := gin.New()
    r.Use(logger.SetLogger(
        logger.WithSkipPath([]string{"/skip"}),
        logger.WithUTC(true),
        logger.WithSkipPathRegexps(rxURL),
    ))
    r.GET("/pong", func(c *gin.Context) {
        c.String(http.StatusOK, "pong "+fmt.Sprint(time.Now().Unix()))
    })
    r.GET("/skip", func(c *gin.Context) {
        c.String(http.StatusOK, "This request will not be logged")
    })
    r.Run(":8080")
}

In this setup, requests to the /skip path and any paths matching the regular expression ^/regexp\d* will not be logged.

If you’re into advanced logging, structured logging is the way to go. It involves logging data in a neat, structured format like JSON, making it more digestible for log aggregation tools.

Here’s an example using the zerolog package for structured logging:

package main

import (
    "time"

    "github.com/gin-gonic/gin"
    "github.com/rs/zerolog"
    "github.com/rs/zerolog/log"
)

func DefaultStructuredLogger() gin.HandlerFunc {
    return StructuredLogger(&log.Logger)
}

func StructuredLogger(logger *zerolog.Logger) gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        path := c.Request.URL.Path
        raw := c.Request.URL.RawQuery

        // Process request
        c.Next()

        // Fill the params
        param := gin.LogFormatterParams{}
        param.TimeStamp = time.Now()
        param.Latency = param.TimeStamp.Sub(start)
        if param.Latency > time.Minute {
            param.Latency = param.Latency.Truncate(time.Second)
        }
        param.ClientIP = c.ClientIP()
        param.Method = c.Request.Method
        param.StatusCode = c.Writer.Status()
        param.ErrorMessage = c.Errors.ByType(gin.ErrorTypePrivate).String()
        param.BodySize = c.Writer.Size()
        if raw != "" {
            path = path + "?" + raw
        }
        param.Path = path

        // Log using the params
        var logEvent *zerolog.Event
        if c.Writer.Status() >= 500 {
            logEvent = logger.Error()
        } else {
            logEvent = logger.Info()
        }
        logEvent.Str("client_ip", param.ClientIP).
            Str("method", param.Method).
            Int("status_code", param.StatusCode).
            Str("path", param.Path).
            Dur("latency", param.Latency).
            Int("body_size", param.BodySize)
    }
}

func main() {
    r := gin.New()
    r.Use(DefaultStructuredLogger())
    r.GET("/example", func(c *gin.Context) {
        c.String(http.StatusOK, "Hello, World!")
    })
    r.Run(":8080")
}

This example logs each request in a structured JSON format, capturing details like client IP, method, status code, path, latency, and body size. It’s a cleaner, more organized approach to logging that pays off when you need to parse logs for insights.

Sometimes, you’ll want to skip logging for specific routes, like health checks or internal endpoints. You can achieve this by configuring the logger middleware to bypass logging for these paths.

Here’s an example using the ginlogrus package, which lets you skip logging for certain routes:

package main

import (
    "github.com/gin-gonic/gin"
    "github.com/takt-corp/gin-logrus"
)

func main() {
    r := gin.New()
    r.Use(ginlogrus.LoggerMiddleware(ginlogrus.LoggerMiddlewareParams{
        SkipPaths: []string{"/ping", "/health"},
    }))
    r.GET("/ping", func(c *gin.Context) {
        c.String(http.StatusOK, "pong")
    })
    r.GET("/example", func(c *gin.Context) {
        c.String(http.StatusOK, "Hello, World!")
    })
    r.Run(":8080")
}

In this setup, requests to the /ping and /health paths won’t be logged.

Wrapping it up, logging incoming requests is a vital part of maintaining and debugging your Gin application. With request logger middleware, you get invaluable insights into your app’s performance and can quickly detect and resolve issues. Whether you go for simple text logs or sophisticated structured JSON logs, there’s a middleware package out there to meet your specific needs. Just make sure your logging setup is flexible and can be tailored to the requirements of your application.