Add WithMinLength option to control when responses are gzipped

Author: takanuva15

README.md

@@ -49,6 +49,42 @@ func main() {
 }
 ```
 
+### Compress only for responses meeting minimum size criteria
+
+```go
+package main
+
+import (
+	"log"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/gin-contrib/gzip"
+	"github.com/gin-gonic/gin"
+)
+
+func main() {
+	r := gin.Default()
+	r.Use(gzip.Gzip(gzip.DefaultCompression, gzip.WithMinLength(2048)))
+	r.GET("/ping", func(c *gin.Context) {
+		sizeStr := c.Query("size")
+		size, _ := strconv.Atoi(sizeStr)
+		c.String(http.StatusOK, strings.Repeat("a", size))
+	})
+
+	// Listen and Server in 0.0.0.0:8080
+	if err := r.Run(":8080"); err != nil {
+		log.Fatal(err)
+	}
+}
+```
+Test with curl:
+```bash
+curl -i --compressed 'http://localhost:8080/ping?size=2047'
+curl -i --compressed 'http://localhost:8080/ping?size=2048'
+```
+
 ### Customized Excluded Extensions
 
 ```go

gzip.go

@@ -2,6 +2,7 @@ package gzip
 
 import (
 	"bufio"
+	"bytes"
 	"compress/gzip"
 	"errors"
 	"net"
@@ -25,15 +26,36 @@ func Gzip(level int, options ...Option) gin.HandlerFunc {
 type gzipWriter struct {
 	gin.ResponseWriter
 	writer *gzip.Writer
+	// minLength is the minimum length of the response body (in bytes) to enable compression
+	minLength int
+	// wasMinLengthMetForCompression indicates whether the minimum length for compression has been met
+	wasMinLengthMetForCompression bool
+	// buffer to store response data in case compression limit not met
+	buffer bytes.Buffer
 }
 
 func (g *gzipWriter) WriteString(s string) (int, error) {
 	g.Header().Del("Content-Length")
-	return g.writer.Write([]byte(s))
+	return g.Write([]byte(s))
 }
 
 func (g *gzipWriter) Write(data []byte) (int, error) {
 	g.Header().Del("Content-Length")
+	// Check if the response body is large enough to be compressed. If so, skip this condition and proceed with the
+	// normal write process. If not, store the data in the buffer in case more data is written later.
+	// (At the end, if the response body is still too small, the caller should check wasMinLengthMetForCompression and
+	// use the data stored in the buffer to write the response instead.)
+	if !g.wasMinLengthMetForCompression && len(data) >= g.minLength {
+		g.wasMinLengthMetForCompression = true
+	} else if !g.wasMinLengthMetForCompression {
+		lenWritten, err := g.buffer.Write(data)
+		if err != nil || g.buffer.Len() < g.minLength {
+			return lenWritten, err
+		}
+		g.wasMinLengthMetForCompression = true
+		data = g.buffer.Bytes()
+	}
+
 	return g.writer.Write(data)
 }
 

gzip_test.go

@@ -13,6 +13,7 @@ import (
 	"net/http/httputil"
 	"net/url"
 	"strconv"
+	"strings"
 	"testing"
 
 	"github.com/gin-gonic/gin"
@@ -377,6 +378,67 @@ func TestCustomShouldCompressFn(t *testing.T) {
 	assert.Equal(t, testResponse, w.Body.String())
 }
 
+func TestMinLengthShortResponse(t *testing.T) {
+	req, _ := http.NewRequestWithContext(context.Background(), "GET", "/", nil)
+	req.Header.Add(headerAcceptEncoding, "gzip")
+
+	router := gin.New()
+	router.Use(Gzip(DefaultCompression, WithMinLength(2048)))
+	router.GET("/", func(c *gin.Context) {
+		c.Header("Content-Length", strconv.Itoa(len(testResponse)))
+		c.String(200, testResponse)
+	})
+
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "", w.Header().Get(headerContentEncoding))
+	assert.Equal(t, "19", w.Header().Get("Content-Length"))
+	assert.Equal(t, testResponse, w.Body.String())
+}
+
+func TestMinLengthLongResponse(t *testing.T) {
+	req, _ := http.NewRequestWithContext(context.Background(), "GET", "/", nil)
+	req.Header.Add(headerAcceptEncoding, "gzip")
+
+	router := gin.New()
+	router.Use(Gzip(DefaultCompression, WithMinLength(2048)))
+	router.GET("/", func(c *gin.Context) {
+		c.Header("Content-Length", "2048")
+		c.String(200, strings.Repeat("a", 2048))
+	})
+
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "gzip", w.Header().Get(headerContentEncoding))
+	assert.NotEqual(t, "2048", w.Header().Get("Content-Length"))
+	assert.Less(t, w.Body.Len(), 2048)
+}
+
+func TestMinLengthMultiWriteResponse(t *testing.T) {
+	req, _ := http.NewRequestWithContext(context.Background(), "GET", "/", nil)
+	req.Header.Add(headerAcceptEncoding, "gzip")
+
+	router := gin.New()
+	router.Use(Gzip(DefaultCompression, WithMinLength(2048)))
+	router.GET("/", func(c *gin.Context) {
+		c.Header("Content-Length", "2048")
+		c.String(200, strings.Repeat("a", 1024))
+		c.String(200, strings.Repeat("b", 1024))
+	})
+
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "gzip", w.Header().Get(headerContentEncoding))
+	assert.NotEqual(t, "2048", w.Header().Get("Content-Length"))
+	assert.Less(t, w.Body.Len(), 2048)
+}
+
 type hijackableResponse struct {
 	Hijacked bool
 	header   http.Header

handler.go

@@ -84,8 +84,22 @@ func (g *gzipHandler) Handle(c *gin.Context) {
 	if originalEtag != "" && !strings.HasPrefix(originalEtag, "W/") {
 		c.Header("ETag", "W/"+originalEtag)
 	}
-	c.Writer = &gzipWriter{c.Writer, gz}
+	gzWriter := gzipWriter{
+		ResponseWriter: c.Writer,
+		writer:         gz,
+		minLength:      g.minLength,
+	}
+	c.Writer = &gzWriter
 	defer func() {
+		// if compression limit not met after all write commands were executed, then the response data is stored in the
+		// internal buffer which should now be written to the response writer directly
+		if !gzWriter.wasMinLengthMetForCompression {
+			c.Writer.Header().Del(headerContentEncoding)
+			c.Writer.Header().Del(headerVary)
+			_, _ = gzWriter.ResponseWriter.Write(gzWriter.buffer.Bytes())
+			gz.Reset(io.Discard)
+		}
+
 		if c.Writer.Size() < 0 {
 			// do not write gzip footer when nothing is written to the response body
 			gz.Reset(io.Discard)

options.go

@@ -47,6 +47,7 @@ type config struct {
 	decompressFn           func(c *gin.Context)
 	decompressOnly         bool
 	customShouldCompressFn func(c *gin.Context) bool
+	minLength              int
 }
 
 // WithExcludedExtensions returns an Option that sets the ExcludedExtensions field of the Options struct.
@@ -117,6 +118,28 @@ func WithCustomShouldCompressFn(fn func(c *gin.Context) bool) Option {
 	})
 }
 
+// WithMinLength returns an Option that sets the MinLength field of the Options struct.
+// Parameters:
+//   - minLength: int - The minimum length of the response body (in bytes) to trigger gzip compression.
+//     If the response body is smaller than this length, it will not be compressed.
+//     This option is useful for avoiding the overhead of compression on small responses, especially since gzip
+//     compression actually increases the size of small responses. 2048 is a recommended value for most cases.
+//
+// Note that specifying this option does not override other options. If a path has been excluded (eg through
+// WithExcludedPaths), it will continue to be excluded.
+//
+// Returns:
+//   - Option - An option that sets the MinLength field of the Options struct.
+//
+// Example:
+//
+//	router.Use(gzip.Gzip(gzip.DefaultCompression, gzip.WithMinLength(2048)))
+func WithMinLength(minLength int) Option {
+	return optionFunc(func(o *config) {
+		o.minLength = minLength
+	})
+}
+
 // Using map for better lookup performance
 type ExcludedExtensions map[string]struct{}