https://github.com/vearne/gin-timeout
Timeout Middleware for Gin framework
https://github.com/vearne/gin-timeout
gin middleware timeout
Last synced: 1 day ago
JSON representation
Timeout Middleware for Gin framework
- Host: GitHub
- URL: https://github.com/vearne/gin-timeout
- Owner: vearne
- License: mit
- Created: 2020-06-11T05:52:17.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2025-09-29T07:41:43.000Z (5 months ago)
- Last Synced: 2025-09-29T08:17:26.671Z (5 months ago)
- Topics: gin, middleware, timeout
- Language: Go
- Size: 4.99 MB
- Stars: 110
- Watchers: 2
- Forks: 30
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# gin-timeout
[](https://github.com/vearne/gin-timeout/actions/workflows/golang-ci.yml)
Timeout Middleware for Gin framework
* [中文 README](https://github.com/vearne/gin-timeout/blob/master/README_zh.md)
### Thanks
Inspired by golang source code [http.TimeoutHandler](https://github.com/golang/go/blob/5f3dabbb79fb3dc8eea9a5050557e9241793dce3/src/net/http/server.go#L3255)
### Usage
Download and install using go module:
```
export GO111MODULE=on
go get github.com/vearne/gin-timeout
```
### Notice:
- If the handler supports to be canceled, you need to pass gin.Context.Request.Context() as parameter.
- If you want to get the status code of the response in middleware, you should put the middleware before the timeout middleware.
```go
package main
import (
"net/http"
"net/http/httptest"
"time"
"github.com/gin-gonic/gin"
timeout "github.com/vearne/gin-timeout"
)
func main() {
req, _ := http.NewRequest("GET", "/test", nil)
engine := gin.New()
engine.Use(func(c *gin.Context) {
c.Next()
println("middleware code: ", c.Writer.Status())
})
engine.Use(timeout.Timeout(timeout.WithTimeout(10 * time.Second)))
engine.GET("/test", func(c *gin.Context) {
c.Status(http.StatusBadRequest)
})
rr := httptest.NewRecorder()
engine.ServeHTTP(rr, req)
println("response code: ", rr.Code)
}
```
### Example
[more example](https://github.com/vearne/gin-timeout/tree/master/example)
```go
package main
import (
"context"
"fmt"
"github.com/gin-gonic/gin"
"github.com/vearne/gin-timeout"
"io/ioutil"
"log"
"net/http"
"time"
)
func main() {
// create new gin without any middleware
engine := gin.Default()
defaultMsg := `{"code": -1, "msg":"http: Handler timeout"}`
// add timeout middleware with 2 second duration
engine.Use(timeout.Timeout(
timeout.WithTimeout(2*time.Second),
timeout.WithErrorHttpCode(http.StatusRequestTimeout), // optional
timeout.WithDefaultMsg(defaultMsg), // optional
timeout.WithCallBack(func(r *http.Request) {
fmt.Println("timeout happen, url:", r.URL.String())
}),
timeout.WithGinCtxCallBack(func(c *gin.Context) {
fmt.Println("timeout happen, url:", c.Request.URL.String())
}))) // optional
// create a handler that will last 1 seconds
engine.GET("/short", short)
// create a handler that will last 5 seconds
engine.GET("/long", long)
// create a handler that will last 5 seconds but can be canceled.
engine.GET("/long2", long2)
// create a handler that will last 20 seconds but can be canceled.
engine.GET("/long3", long3)
engine.GET("/boundary", boundary)
// run the server
log.Fatal(engine.Run(":8080"))
}
func short(c *gin.Context) {
time.Sleep(1 * time.Second)
c.JSON(http.StatusOK, gin.H{"hello": "short"})
}
func long(c *gin.Context) {
time.Sleep(3 * time.Second)
c.JSON(http.StatusOK, gin.H{"hello": "long"})
}
func boundary(c *gin.Context) {
time.Sleep(2 * time.Second)
c.JSON(http.StatusOK, gin.H{"hello": "boundary"})
}
func long2(c *gin.Context) {
if doSomething(c.Request.Context()) {
c.JSON(http.StatusOK, gin.H{"hello": "long2"})
}
}
func long3(c *gin.Context) {
// request a slow service
// see https://github.com/vearne/gin-timeout/blob/master/example/slow_service.go
url := "http://localhost:8882/hello"
// Notice:
// Please use c.Request.Context(), the handler will be canceled where timeout event happen.
req, _ := http.NewRequestWithContext(c.Request.Context(), http.MethodGet, url, nil)
client := http.Client{Timeout: 100 * time.Second}
resp, err := client.Do(req)
if err != nil {
// Where timeout event happen, a error will be received.
fmt.Println("error1:", err)
return
}
defer resp.Body.Close()
s, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("error2:", err)
return
}
fmt.Println(s)
}
// A cancelCtx can be canceled.
// When canceled, it also cancels any children that implement canceler.
func doSomething(ctx context.Context) bool {
select {
case <-ctx.Done():
fmt.Println("doSomething is canceled.")
return false
case <-time.After(5 * time.Second):
fmt.Println("doSomething is done.")
return true
}
}
```
### Thanks
[](https://www.jetbrains.com/community/opensource/#support)