fix(header): disable gzip compression for error responses (#120)

* fix: handle gzip compression correctly for error responses

- Prevent compression and remove gzip-related headers for error (4xx, 5xx) responses
- Ensure gzip writer properly tracks the response status code
- Only close the gzip writer when compression was used and nothing was written, or for error responses
- Add tests verifying that 404 responses are not compressed and do not include gzip-specific headers

fix #98

Signed-off-by: appleboy <appleboy.tw@gmail.com>

* feat: extend gzipWriter with header and response handling

- Add methods to gzipWriter to expose HTTP status, response size, and written state
- Implement WriteHeaderNow to force HTTP header writing through gzipWriter

Signed-off-by: appleboy <appleboy.tw@gmail.com>

---------

Signed-off-by: appleboy <appleboy.tw@gmail.com>

Author: appleboy

gzip.go

@@ -24,26 +24,77 @@ func Gzip(level int, options ...Option) gin.HandlerFunc {
 
 type gzipWriter struct {
 	gin.ResponseWriter
-	writer *gzip.Writer
+	writer        *gzip.Writer
+	statusWritten bool
+	status        int
 }
 
 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 status from ResponseWriter if not set via WriteHeader
+	if !g.statusWritten {
+		g.status = g.ResponseWriter.Status()
+	}
+
+	// For error responses (4xx, 5xx), don't compress
+	if g.status >= 400 {
+		g.removeGzipHeaders()
+		return g.ResponseWriter.Write(data)
+	}
+
 	return g.writer.Write(data)
 }
 
+// Status returns the HTTP response status code
+func (g *gzipWriter) Status() int {
+	if g.statusWritten {
+		return g.status
+	}
+	return g.ResponseWriter.Status()
+}
+
+// Size returns the number of bytes already written into the response http body
+func (g *gzipWriter) Size() int {
+	return g.ResponseWriter.Size()
+}
+
+// Written returns true if the response body was already written
+func (g *gzipWriter) Written() bool {
+	return g.ResponseWriter.Written()
+}
+
+// WriteHeaderNow forces to write the http header
+func (g *gzipWriter) WriteHeaderNow() {
+	g.ResponseWriter.WriteHeaderNow()
+}
+
+// removeGzipHeaders removes compression-related headers for error responses
+func (g *gzipWriter) removeGzipHeaders() {
+	g.Header().Del("Content-Encoding")
+	g.Header().Del("Vary")
+	g.Header().Del("ETag")
+}
+
 func (g *gzipWriter) Flush() {
 	_ = g.writer.Flush()
 	g.ResponseWriter.Flush()
 }
 
 // Fix: https://github.com/mholt/caddy/issues/38
 func (g *gzipWriter) WriteHeader(code int) {
+	g.status = code
+	g.statusWritten = true
+
+	// Remove gzip headers for error responses
+	if code >= 400 {
+		g.removeGzipHeaders()
+	}
+
 	g.Header().Del("Content-Length")
 	g.ResponseWriter.WriteHeader(code)
 }

handler.go

@@ -84,9 +84,13 @@ func (g *gzipHandler) Handle(c *gin.Context) {
 	if originalEtag != "" && !strings.HasPrefix(originalEtag, "W/") {
 		c.Header("ETag", "W/"+originalEtag)
 	}
-	c.Writer = &gzipWriter{c.Writer, gz}
+	gw := &gzipWriter{ResponseWriter: c.Writer, writer: gz}
+	c.Writer = gw
 	defer func() {
-		if c.Writer.Size() < 0 {
+		// Only close gzip writer if it was actually used (not for error responses)
+		if gw.status >= 400 {
+			gz.Reset(io.Discard)
+		} else if c.Writer.Size() < 0 {
 			// do not write gzip footer when nothing is written to the response body
 			gz.Reset(io.Discard)
 		}

handler_test.go

@@ -99,3 +99,59 @@ func TestHandleDecompressGzip(t *testing.T) {
 	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "ok", w.Body.String())
 }
+
+func TestHandle404NoCompression(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	tests := []struct {
+		name           string
+		acceptEncoding string
+		expectedGzip   bool
+	}{
+		{
+			name:           "404 with gzip accept-encoding should not compress",
+			acceptEncoding: "gzip",
+			expectedGzip:   false,
+		},
+		{
+			name:           "404 without gzip accept-encoding",
+			acceptEncoding: "",
+			expectedGzip:   false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			router := gin.New()
+			router.Use(Gzip(DefaultCompression))
+			// Register a route to get proper 404 for unmatched paths
+			router.NoRoute(func(c *gin.Context) {
+				c.String(http.StatusNotFound, "404 page not found")
+			})
+
+			req, _ := http.NewRequestWithContext(context.Background(), "GET", "/nonexistent", nil)
+			if tt.acceptEncoding != "" {
+				req.Header.Set(headerAcceptEncoding, tt.acceptEncoding)
+			}
+
+			w := httptest.NewRecorder()
+			router.ServeHTTP(w, req)
+
+			assert.Equal(t, http.StatusNotFound, w.Code)
+
+			// Check that Content-Encoding header is not set for 404 responses
+			contentEncoding := w.Header().Get("Content-Encoding")
+			if tt.expectedGzip {
+				assert.Equal(t, "gzip", contentEncoding)
+			} else {
+				assert.Empty(t, contentEncoding, "404 responses should not have Content-Encoding: gzip")
+			}
+
+			// Verify that Vary header is also not set for uncompressed 404 responses
+			if !tt.expectedGzip {
+				vary := w.Header().Get("Vary")
+				assert.Empty(t, vary, "404 responses should not have Vary header when not compressed")
+			}
+		})
+	}
+}