Gin middleware to log http requests using slog.
See also:
- slog-multi:
slog.Handler
chaining, fanout, routing, failover, load balancing... - slog-formatter:
slog
attribute formatting - slog-sampling:
slog
sampling policy - slog-gin: Gin middleware for
slog
logger - slog-echo: Echo middleware for
slog
logger - slog-fiber: Fiber middleware for
slog
logger - slog-chi: Chi middleware for
slog
logger - slog-datadog: A
slog
handler forDatadog
- slog-rollbar: A
slog
handler forRollbar
- slog-sentry: A
slog
handler forSentry
- slog-syslog: A
slog
handler forSyslog
- slog-logstash: A
slog
handler forLogstash
- slog-fluentd: A
slog
handler forFluentd
- slog-graylog: A
slog
handler forGraylog
- slog-loki: A
slog
handler forLoki
- slog-slack: A
slog
handler forSlack
- slog-telegram: A
slog
handler forTelegram
- slog-mattermost: A
slog
handler forMattermost
- slog-microsoft-teams: A
slog
handler forMicrosoft Teams
- slog-webhook: A
slog
handler forWebhook
- slog-kafka: A
slog
handler forKafka
- slog-nats: A
slog
handler forNATS
- slog-parquet: A
slog
handler forParquet
+Object Storage
- slog-zap: A
slog
handler forZap
- slog-zerolog: A
slog
handler forZerolog
- slog-logrus: A
slog
handler forLogrus
go get github.com/samber/slog-gin
Compatibility: go >= 1.21
No breaking changes will be made to exported APIs before v2.0.0.
import (
"github.com/gin-gonic/gin"
sloggin "github.com/samber/slog-gin"
"log/slog"
)
// Create a slog logger, which:
// - Logs to stdout.
logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
router := gin.New()
// Add the sloggin middleware to all routes.
// The middleware will log all requests attributes.
router.Use(sloggin.New(logger))
router.Use(gin.Recovery())
// Example pong request.
router.GET("/pong", func(c *gin.Context) {
c.String(http.StatusOK, "pong")
})
router.Run(":1234")
// output:
// time=2023-04-10T14:00:0.000000Z level=INFO msg="Incoming request" status=200 method=GET path=/pong route=/pong ip=127.0.0.1 latency=25.5µs user-agent=curl/7.77.0 time=2023-04-10T14:00:00.000Z
logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
config := sloggin.Config{
WithSpanID: true,
WithTraceID: true,
}
router := chi.NewRouter()
router.Use(sloggin.NewWithConfig(logger, config))
logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
config := sloggin.Config{
WithRequestBody: true,
WithResponseBody: true,
WithRequestHeader: true,
WithResponseHeader: true,
}
router := chi.NewRouter()
router.Use(sloggin.NewWithConfig(logger, config))
logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
router := gin.New()
router.Use(
sloggin.NewWithFilters(
logger,
sloggin.Accept(func (c *gin.Context) bool {
return xxx
}),
sloggin.IgnoreStatus(401, 404),
),
)
router.Use(gin.Recovery())
Available filters:
- Accept / Ignore
- AcceptMethod / IgnoreMethod
- AcceptStatus / IgnoreStatus
- AcceptStatusGreaterThan / IgnoreStatusLessThan
- AcceptStatusGreaterThanOrEqual / IgnoreStatusLessThanOrEqual
- AcceptPath / IgnorePath
- AcceptPathContains / IgnorePathContains
- AcceptPathPrefix / IgnorePathPrefix
- AcceptPathSuffix / IgnorePathSuffix
- AcceptPathMatch / IgnorePathMatch
- AcceptHost / IgnoreHost
- AcceptHostContains / IgnoreHostContains
- AcceptHostPrefix / IgnoreHostPrefix
- AcceptHostSuffix / IgnoreHostSuffix
- AcceptHostMatch / IgnoreHostMatch
import (
"github.com/gin-gonic/gin"
sloggin "github.com/samber/slog-gin"
slogformatter "github.com/samber/slog-formatter"
"log/slog"
)
// Create a slog logger, which:
// - Logs to stdout.
// - RFC3339 with UTC time format.
logger := slog.New(
slogformatter.NewFormatterHandler(
slogformatter.TimezoneConverter(time.UTC),
slogformatter.TimeFormatter(time.DateTime, nil),
)(
slog.NewTextHandler(os.Stdout, nil),
),
)
router := gin.New()
// Add the sloggin middleware to all routes.
// The middleware will log all requests attributes.
router.Use(sloggin.New(logger))
router.Use(gin.Recovery())
// Example pong request.
router.GET("/pong", func(c *gin.Context) {
c.String(http.StatusOK, "pong")
})
router.Run(":1234")
// output:
// time="2023-04-10 14:00:00" level=INFO msg="Incoming request" status=200 method=GET path=/pong route=/pong ip=127.0.0.1 latency=25.5µs user-agent=curl/7.77.0 time="2023-04-10 14:00:00"
logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
router := gin.New()
// Add the sloggin middleware to all routes.
// The middleware will log all requests attributes under a "http" group.
router.Use(sloggin.New(logger.WithGroup("http")))
router.Use(gin.Recovery())
// Example pong request.
router.GET("/pong", func(c *gin.Context) {
c.String(http.StatusOK, "pong")
})
router.Run(":1234")
// output:
// time=2023-04-10T14:00:0.000000+02:00 level=INFO msg="Incoming request" http.status=200 http.method=GET http.path=/pong http.route=/pong http.ip=127.0.0.1 http.latency=20.125µs http.user-agent=curl/7.77.0 time=2023-04-10T14:00:00.000+02:00
logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
router := gin.New()
router.Use(gin.Recovery())
// Example pong request.
// Add the sloggin middleware to a single routes.
router.GET("/pong", sloggin.New(logger), func(c *gin.Context) {
c.String(http.StatusOK, "pong")
})
router.Run(":1234")
// output:
// time="2023-04-10 14:00:00" level=INFO msg="Incoming request" status=200 method=GET path=/pong route=/pong ip=127.0.0.1 latency=25.5µs user-agent=curl/7.77.0 time="2023-04-10 14:00:00"
logger := slog.New(slog.NewTextHandler(os.Stdout, nil)).
With("environment", "production").
With("server", "gin/1.9.0").
With("server_start_time", time.Now()).
With("gin_mode", gin.EnvGinMode)
router := gin.New()
// Add the sloggin middleware to all routes.
// The middleware will log all requests attributes.
router.Use(sloggin.New(logger))
router.Use(gin.Recovery())
// Example pong request.
router.GET("/pong", func(c *gin.Context) {
// Add an attribute to a single log entry.
sloggin.AddCustomAttributes(c, slog.String("foo", "bar"))
c.String(http.StatusOK, "pong")
})
router.Run(":1234")
// output:
// time=2023-04-10T14:00:0.000000+02:00 level=INFO msg="Incoming request" environment=production server=gin/1.9.0 gin_mode=release server_start_time=2023-04-10T10:00:00.000+02:00 status=200 method=GET path=/pong route=/pong ip=127.0.0.1 latency=25.5µs user-agent=curl/7.77.0 time=2023-04-10T14:00:00.000+02:00 foo=bar
logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
router := gin.New()
// Add the sloggin middleware to all routes.
// The middleware will log all requests attributes.
router.Use(sloggin.New(logger))
router.Use(gin.Recovery())
// Example pong request.
router.GET("/pong", func(c *gin.Context) {
c.String(http.StatusOK, "pong")
})
router.Run(":1234")
// output:
// {"time":"2023-04-10T14:00:0.000000+02:00","level":"INFO","msg":"Incoming request","gin_mode":"GIN_MODE","status":200,"method":"GET","path":"/pong","ip":"127.0.0.1","latency":15542,"user-agent":"curl/7.77.0","time":"2023-04-10T14:00:0.000000+02:00"}
- Ping me on twitter @samuelberthe (DMs, mentions, whatever :))
- Fork the project
- Fix open issues or request new features
Don't hesitate ;)
# Install some dev dependencies
make tools
# Run tests
make test
# or
make watch-test
Give a ⭐️ if this project helped you!
Copyright © 2023 Samuel Berthe.
This project is MIT licensed.