gin
gin copied to clipboard
gin-gonic
Middleware Use behavior undocumented and unintuitive
Please take a look at the following code
package main
import (
"github.com/gin-gonic/gin"
)
func main() {
r := gin.New()
r.GET("/ping", func(c *gin.Context) { c.JSON(200, gin.H{}) })
r.Use(gin.Logger())
r.GET("/pingx", func(c *gin.Context) { c.JSON(200, gin.H{}) })
r.Run()
}
And now please take a look at the documentation for Use() (emphasis mine):
Use attaches a global middleware to the router. ie. the middleware attached though Use() will be included in the handlers chain for every single request
Who in the world would have guessed that the middlewares are only called with the routes that where declared after them, not before?
Steps to reproduce:
go run main.gowith main.go being the code abovecurl localhost:8080/pingxand watch as the logger logs requests on stdoutcurl localhost:8080/pingand watch as nothing is logged anywhere.
To me this is a bug but I have a feeling that this is intended behavior...
If it is intended, I would suggest to update the documentation, but this is not enough.
I would also change the README because this behavior is documented nowhere.
Also I suggest renaming .Use to .UseFromNowOn or to have both calls available.
This bug prevents from using middlewares with OpenAPI go-gin-server generator . OpenAPI generator is a tool that writes API routes (among others). By nature, a lot of users will add the CORS middleware, and will:
- Encounter the bug
- Add code in an auto-generated file as a work-around
Also, this thread shows users struggling with the bug. It has been around for years https://github.com/gin-contrib/cors/issues/29
Thank you for your understanding
- go version: go1.12.7
- gin version (or commit ref): v1.4.0-dev
- operating system: linux/amd64
Note. For some people, it might look intuitive in the code above that Use means UseFromNowOn. But I happened to work on this, where NewRouter is generated code. It is way less explicit.
router := routers.NewRouter()
router.Use(cors.Default())
log.Fatal(router.Run(":8000"))
@sguillia I just confirmed this behavior with Use. I think a clearer documentation that points out this behavior will be a better.
Just encountered the issue myself. I was writing a test to verify the middleware (a logger) is used and I was using a method to override the logger from the test. The logger was only used for the 404 responses and not for the existing routes defined before the call of Use(...). Looking at the code https://github.com/gin-gonic/gin/blob/master/gin.go#L303-L307 I see two methods are called to rebuild 404 and 405 handlers and that's probably the reason why the 404 responses are still covered by the middleware. I guess the same thing should be done for just all handlers. I can work on a fix unless someone argues that the existing behavior is the required one. In that case I can create only a fix for the documentation.
Once you are aware of the issue the workaround is easy, you just set the Use methods before the GET/POST etc handlers.
r := gin.New()
// setting middleware before routes, otherwise it does not work (gin bug)
r.Use(ginzap.Ginzap(zapLogger, time.RFC3339, true))
r.Use(ginzap.RecoveryWithZap(zapLogger, true))
r.GET("/", handler1)
r.POST("/", handler2)
...
Issue is I'm using OpenAPI go-gin-server generator. So my router is already setup before hand. If we can't use Use() after declaring the handlers I can't make it work other than touching the generated code.