Extend default timeout on certain path patterns

.gitignore

@@ -13,4 +13,8 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
-.idea
+.idea
+.vscode
+
+# Environment
+.env

README.md

@@ -102,3 +102,49 @@ func main() {
 	}
 }
 ```
+
+### extended timeout on certain paths
+
+```go
+package main
+
+import (
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/gin-contrib/timeout"
+	"github.com/gin-gonic/gin"
+)
+
+func testResponse(c *gin.Context) {
+	c.String(http.StatusRequestTimeout, "timeout")
+}
+
+func extendedTimeoutMiddleware() gin.HandlerFunc {
+	return timeout.New(
+		timeout.WithTimeout(200*time.Millisecond),          // Default timeout on all routes
+		timeout.WithExtendedTimeout(1000*time.Millisecond), // Extended timeout on pattern based routes
+		timeout.WithExtendedPaths([]string{
+			"/ext.*", // List of patterns to allow extended timeouts
+		}),      
+		timeout.WithHandler(func(c *gin.Context) {
+			c.Next()
+		}),
+		timeout.WithResponse(testResponse),
+	)
+}
+
+func main() {
+	r := gin.New()
+	r.Use(extendedTimeoutMiddleware())
+	r.GET("/extended", func(c *gin.Context) {
+		time.Sleep(800 * time.Millisecond)
+		c.Status(http.StatusOK)
+	})
+
+	if err := r.Run(":8080"); err != nil {
+		log.Fatal(err)
+	}
+}
+```

_example/example03/main.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/gin-contrib/timeout"
+	"github.com/gin-gonic/gin"
+)
+
+func testResponse(c *gin.Context) {
+	c.String(http.StatusRequestTimeout, "timeout")
+}
+
+func extendedTimeoutMiddleware() gin.HandlerFunc {
+	return timeout.New(
+		timeout.WithTimeout(200*time.Millisecond),          // Default timeout on all routes
+		timeout.WithExtendedTimeout(1000*time.Millisecond), // Extended timeout on pattern based routes
+		timeout.WithExtendedPaths([]string{"/ext.*"}),      // List of patterns to allow extended timeouts
+		timeout.WithHandler(func(c *gin.Context) {
+			c.Next()
+		}),
+		timeout.WithResponse(testResponse),
+	)
+}
+
+func main() {
+	r := gin.New()
+	r.Use(extendedTimeoutMiddleware())
+	r.GET("/extended", func(c *gin.Context) {
+		time.Sleep(800 * time.Millisecond)
+		c.Status(http.StatusOK)
+	})
+
+	if err := r.Run(":8080"); err != nil {
+		log.Fatal(err)
+	}
+}

option.go

@@ -2,6 +2,7 @@ package timeout
 
 import (
 	"net/http"
+	"regexp"
 	"time"
 
 	"github.com/gin-gonic/gin"
@@ -17,6 +18,20 @@ func WithTimeout(timeout time.Duration) Option {
 	}
 }
 
+// WithExtendedTimeout set extended paths timeout
+func WithExtendedTimeout(extendedTimeout time.Duration) Option {
+	return func(t *Timeout) {
+		t.extendedTimeout = extendedTimeout
+	}
+}
+
+// WithExtendedPaths set extended paths
+func WithExtendedPaths(extendedPaths []string) Option {
+	return func(t *Timeout) {
+		t.extendedPaths = extendedPaths
+	}
+}
+
 // WithHandler add gin handler
 func WithHandler(h gin.HandlerFunc) Option {
 	return func(t *Timeout) {
@@ -35,9 +50,28 @@ func defaultResponse(c *gin.Context) {
 	c.String(http.StatusRequestTimeout, http.StatusText(http.StatusRequestTimeout))
 }
 
+// shouldExtendPathTimeout receiver matches the current path against the list of extensible timeouts.
+// Not providing extended paths will not override the normal timeout duration.
+func (t *Timeout) shouldExtendPathTimeout(c *gin.Context) bool {
+	for _, b := range t.extendedPaths {
+		matched, err := regexp.MatchString(b, c.Request.URL.Path)
+		if err != nil {
+			return false
+		}
+
+		if matched {
+			return true
+		}
+	}
+
+	return false
+}
+
 // Timeout struct
 type Timeout struct {
-	timeout  time.Duration
-	handler  gin.HandlerFunc
-	response gin.HandlerFunc
+	timeout         time.Duration
+	extendedTimeout time.Duration
+	extendedPaths   []string
+	handler         gin.HandlerFunc
+	response        gin.HandlerFunc
 }

timeout.go

@@ -15,9 +15,10 @@ const (
 // New wraps a handler and aborts the process of the handler if the timeout is reached
 func New(opts ...Option) gin.HandlerFunc {
 	t := &Timeout{
-		timeout:  defaultTimeout,
-		handler:  nil,
-		response: defaultResponse,
+		timeout:         defaultTimeout,
+		extendedTimeout: defaultTimeout,
+		handler:         nil,
+		response:        defaultResponse,
 	}
 
 	// Loop through each option
@@ -46,6 +47,11 @@ func New(opts ...Option) gin.HandlerFunc {
 		c.Writer = tw
 		buffer.Reset()
 
+		timeout := t.timeout
+		if t.shouldExtendPathTimeout(c) {
+			timeout = t.extendedTimeout
+		}
+
 		go func() {
 			defer func() {
 				if p := recover(); p != nil {
@@ -77,7 +83,7 @@ func New(opts ...Option) gin.HandlerFunc {
 			tw.FreeBuffer()
 			bufPool.Put(buffer)
 
-		case <-time.After(t.timeout):
+		case <-time.After(timeout):
 			c.Abort()
 			tw.mu.Lock()
 			defer tw.mu.Unlock()

timeout_test.go

@@ -100,3 +100,48 @@ func TestPanic(t *testing.T) {
 	assert.Equal(t, http.StatusInternalServerError, w.Code)
 	assert.Equal(t, "", w.Body.String())
 }
+
+func TestExtendedSuccess(t *testing.T) {
+	r := gin.New()
+	r.Use(New(
+		WithTimeout(50*time.Microsecond),
+		WithExtendedTimeout(250*time.Microsecond),
+		WithExtendedPaths([]string{"/ex.*"}),
+		WithHandler(emptySuccessResponse),
+	))
+
+	r.GET("/extended")
+
+	w := httptest.NewRecorder()
+
+	reqExFails, _ := http.NewRequestWithContext(context.Background(), "GET", "/extended", nil)
+	r.ServeHTTP(w, reqExFails)
+
+	assert.Equal(t, http.StatusOK, w.Code)
+	assert.Equal(t, "", w.Body.String())
+}
+
+func TestExtendedTimeout(t *testing.T) {
+	r := gin.New()
+	r.Use(New(
+		WithTimeout(50*time.Microsecond),
+		WithExtendedTimeout(200*time.Microsecond),
+		WithExtendedPaths([]string{"/extended"}),
+		WithHandler(extendedTimeout),
+	))
+
+	r.GET("/extended")
+
+	w := httptest.NewRecorder()
+
+	reqExFails, _ := http.NewRequestWithContext(context.Background(), "GET", "/extended", nil)
+	r.ServeHTTP(w, reqExFails)
+
+	assert.Equal(t, http.StatusRequestTimeout, w.Code)
+	assert.Equal(t, http.StatusText(http.StatusRequestTimeout), w.Body.String())
+}
+
+func extendedTimeout(ctx *gin.Context) {
+	// Let the route artificially timeout
+	time.Sleep(250 * time.Microsecond)
+}