From a5b6466e9ecb7cc293f0ca56b65bfab58a468d25 Mon Sep 17 00:00:00 2001 From: Ruben Pari Date: Thu, 29 Oct 2026 16:41:07 +0100 Subject: [PATCH] fix(recovery): honor console color configuration --- logger.go | 19 ++-- logger_test.go | 54 ++++++++- recovery.go | 30 ++++- recovery_test.go | 279 +++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 367 insertions(+), 15 deletions(-) diff --git a/logger.go b/logger.go index cf92553a..e1b710de 100644 --- a/logger.go +++ b/logger.go @@ -160,7 +160,17 @@ func (p *LogFormatterParams) ResetColor() string { // IsOutputColor indicates whether can colors be outputted to the log. func (p *LogFormatterParams) IsOutputColor() bool { - return consoleColorMode == forceColor || (consoleColorMode == autoColor && p.isTerm) + return isColorEnabled(p.isTerm) +} + +func isColorEnabled(isTerm bool) bool { + return consoleColorMode == forceColor || (consoleColorMode == autoColor && isTerm) +} + +func isTerminal(out io.Writer) bool { + file, ok := out.(*os.File) + return ok && os.Getenv("TERM") != "dumb" && + (isatty.IsTerminal(file.Fd()) || isatty.IsCygwinTerminal(file.Fd())) } // defaultLogFormatter is the default log format function Logger middleware uses. @@ -255,12 +265,7 @@ func LoggerWithConfig(conf LoggerConfig) HandlerFunc { notlogged := conf.SkipPaths - isTerm := true - - if w, ok := out.(*os.File); !ok || os.Getenv("TERM") == "dumb" || - (!isatty.IsTerminal(w.Fd()) && !isatty.IsCygwinTerminal(w.Fd())) { - isTerm = false - } + isTerm := isTerminal(out) var skip map[string]struct{} diff --git a/logger_test.go b/logger_test.go index 395d97e6..8e7f6e60 100644 --- a/logger_test.go +++ b/logger_test.go @@ -8,10 +8,12 @@ import ( "errors" "fmt" "net/http" + "os" "strings" "testing" "time" + "github.com/mattn/go-isatty" "github.com/stretchr/testify/assert" ) @@ -341,6 +343,9 @@ func TestResetColor(t *testing.T) { } func TestIsOutputColor(t *testing.T) { + previousMode := consoleColorMode + t.Cleanup(func() { consoleColorMode = previousMode }) + // test with isTerm flag true. p := LogFormatterParams{ isTerm: true, @@ -368,9 +373,54 @@ func TestIsOutputColor(t *testing.T) { DisableConsoleColor() assert.False(t, p.IsOutputColor()) +} - // reset console color mode. - consoleColorMode = autoColor +func TestIsTerminal(t *testing.T) { + t.Setenv("TERM", "xterm") + assert.False(t, isTerminal(nil)) + assert.False(t, isTerminal(new(strings.Builder))) + + file, err := os.Open(os.DevNull) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { assert.NoError(t, file.Close()) }) + assert.False(t, isTerminal(file)) +} + +func TestTerminalColorDetection(t *testing.T) { + terminal, err := os.OpenFile("/dev/ptmx", os.O_RDWR, 0) + if err != nil { + t.Skipf("pseudo-terminal unavailable: %v", err) + } + t.Cleanup(func() { assert.NoError(t, terminal.Close()) }) + if !isatty.IsTerminal(terminal.Fd()) && !isatty.IsCygwinTerminal(terminal.Fd()) { + t.Skip("pseudo-terminal unavailable") + } + + previousMode := consoleColorMode + t.Cleanup(func() { consoleColorMode = previousMode }) + for _, tc := range []struct { + name string + term string + mode consoleColorModeValue + isTerm bool + wantColor bool + }{ + {"automatic terminal", "xterm", autoColor, true, true}, + {"disabled terminal", "xterm", disableColor, true, false}, + {"forced terminal", "xterm", forceColor, true, true}, + {"automatic dumb", "dumb", autoColor, false, false}, + {"forced dumb", "dumb", forceColor, false, true}, + } { + t.Run(tc.name, func(t *testing.T) { + t.Setenv("TERM", tc.term) + consoleColorMode = tc.mode + isTerm := isTerminal(terminal) + assert.Equal(t, tc.isTerm, isTerm) + assert.Equal(t, tc.wantColor, isColorEnabled(isTerm)) + }) + } } func TestErrorLogger(t *testing.T) { diff --git a/recovery.go b/recovery.go index 2124fe5f..25a566cf 100644 --- a/recovery.go +++ b/recovery.go @@ -17,6 +17,7 @@ import ( "os" "runtime" "strings" + "sync" "syscall" "time" @@ -52,8 +53,16 @@ func RecoveryWithWriter(out io.Writer, recovery ...RecoveryFunc) HandlerFunc { // CustomRecoveryWithWriter returns a middleware for a given writer that recovers from any panics and calls the provided handle func to handle it. func CustomRecoveryWithWriter(out io.Writer, handle RecoveryFunc) HandlerFunc { var logger *log.Logger + var loggerMutex sync.Mutex + isTerm := isTerminal(out) if out != nil { - logger = log.New(out, "\n\n\x1b[31m", log.LstdFlags) + logger = log.New(out, "\n\n", log.LstdFlags) + } + logMessage := func(color, format string, args ...any) { + loggerMutex.Lock() + defer loggerMutex.Unlock() + logger.SetPrefix("\n\n" + color) + logger.Printf(format, args...) } return func(c *Context) { defer func() { @@ -68,14 +77,23 @@ func CustomRecoveryWithWriter(out io.Writer, handle RecoveryFunc) HandlerFunc { errors.Is(err, http.ErrAbortHandler) } if logger != nil { + var color, resetColor string + if isColorEnabled(isTerm) { + color, resetColor = "\x1b[31m", reset + } if isBrokenPipe { - logger.Printf("%s\n%s%s", rec, secureRequestDump(c.Request), reset) + logMessage(color, "%s\n%s%s", rec, secureRequestDump(c.Request), resetColor) } else if IsDebugging() { - logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s", - timeFormat(time.Now()), secureRequestDump(c.Request), rec, stack(stackSkip), reset) + logTime := timeFormat(time.Now()) + requestDump := secureRequestDump(c.Request) + stackTrace := stack(stackSkip) + logMessage(color, "[Recovery] %s panic recovered:\n%s\n%s\n%s%s", + logTime, requestDump, rec, stackTrace, resetColor) } else { - logger.Printf("[Recovery] %s panic recovered:\n%s\n%s%s", - timeFormat(time.Now()), rec, stack(stackSkip), reset) + logTime := timeFormat(time.Now()) + stackTrace := stack(stackSkip) + logMessage(color, "[Recovery] %s panic recovered:\n%s\n%s%s", + logTime, rec, stackTrace, resetColor) } } if isBrokenPipe { diff --git a/recovery_test.go b/recovery_test.go index e5211790..00ed8385 100644 --- a/recovery_test.go +++ b/recovery_test.go @@ -5,17 +5,296 @@ package gin import ( + "bytes" "errors" + "io" "net" "net/http" "os" "strings" + "sync" "syscall" "testing" "github.com/stretchr/testify/assert" ) +func TestRecoveryDisableConsoleColor(t *testing.T) { + previousMode := consoleColorMode + previousWriter := DefaultErrorWriter + t.Cleanup(func() { + consoleColorMode = previousMode + DefaultErrorWriter = previousWriter + }) + + DisableConsoleColor() + buffer := new(strings.Builder) + DefaultErrorWriter = buffer + router := New() + router.Use(Recovery()) + router.GET("/recovery", func(_ *Context) { + panic("recovery color regression") + }) + + w := PerformRequest(router, http.MethodGet, "/recovery") + assert.Equal(t, http.StatusInternalServerError, w.Code) + assert.Contains(t, buffer.String(), "recovery color regression") + assert.NotContains(t, buffer.String(), "\x1b[") +} + +func TestRecoveryColorModes(t *testing.T) { + previousMode := consoleColorMode + previousWriter := DefaultErrorWriter + previousGinMode := Mode() + t.Cleanup(func() { + consoleColorMode = previousMode + DefaultErrorWriter = previousWriter + SetMode(previousGinMode) + }) + SetMode(DebugMode) + + handle := func(c *Context, _ any) { + c.AbortWithStatus(http.StatusTeapot) + } + constructors := []struct { + name string + new func(io.Writer) HandlerFunc + status int + }{ + {"Recovery", func(out io.Writer) HandlerFunc { + DefaultErrorWriter = out + return Recovery() + }, http.StatusInternalServerError}, + {"RecoveryWithWriter", func(out io.Writer) HandlerFunc { + return RecoveryWithWriter(out) + }, http.StatusInternalServerError}, + {"RecoveryWithWriterCustom", func(out io.Writer) HandlerFunc { + return RecoveryWithWriter(out, handle) + }, http.StatusTeapot}, + {"CustomRecovery", func(out io.Writer) HandlerFunc { + DefaultErrorWriter = out + return CustomRecovery(handle) + }, http.StatusTeapot}, + {"CustomRecoveryWithWriter", func(out io.Writer) HandlerFunc { + return CustomRecoveryWithWriter(out, handle) + }, http.StatusTeapot}, + } + modes := []struct { + name string + set func() + term string + wantColor bool + }{ + {"disabled", DisableConsoleColor, "xterm", false}, + {"forced", ForceConsoleColor, "xterm", true}, + {"automatic buffer", func() { consoleColorMode = autoColor }, "xterm", false}, + {"automatic dumb", func() { consoleColorMode = autoColor }, "dumb", false}, + {"forced dumb", ForceConsoleColor, "dumb", true}, + } + panics := []struct { + name string + value any + }{ + {"normal", "color panic"}, + {"broken pipe", &net.OpError{Err: &os.SyscallError{Err: syscall.EPIPE}}}, + } + + for _, constructor := range constructors { + for _, mode := range modes { + for _, panicCase := range panics { + t.Run(constructor.name+"/"+mode.name+"/"+panicCase.name, func(t *testing.T) { + t.Setenv("TERM", mode.term) + mode.set() + buffer := new(strings.Builder) + password := "Bearer secret-token" + router := New() + router.Use(constructor.new(buffer)) + router.GET("/recovery", func(_ *Context) { + panic(panicCase.value) + }) + + w := PerformRequest(router, http.MethodGet, "/recovery", header{Key: "Authorization", Value: password}) + out := buffer.String() + if panicCase.name == "broken pipe" { + assert.Equal(t, http.StatusOK, w.Code) + assert.Contains(t, strings.ToLower(out), "broken pipe") + assert.NotContains(t, out, "panic recovered") + } else { + assert.Equal(t, constructor.status, w.Code) + assert.Contains(t, out, "panic recovered") + assert.Contains(t, out, "color panic") + } + assert.Contains(t, out, "Authorization: *") + assert.NotContains(t, out, password) + if mode.wantColor { + assert.Contains(t, out, "\x1b[31m") + assert.Contains(t, out, reset) + } else { + assert.NotContains(t, out, "\x1b[") + } + }) + } + } + } +} + +func TestRecoveryColorModeChanges(t *testing.T) { + previousMode := consoleColorMode + t.Cleanup(func() { consoleColorMode = previousMode }) + + buffer := new(strings.Builder) + DisableConsoleColor() + router := New() + router.Use(RecoveryWithWriter(buffer)) + router.GET("/recovery", func(_ *Context) { + panic("changing color mode") + }) + + modes := []struct { + name string + set func() + wantColor bool + }{ + {"forced after disabled", ForceConsoleColor, true}, + {"disabled after forced", DisableConsoleColor, false}, + {"automatic after disabled", func() { consoleColorMode = autoColor }, false}, + {"forced after automatic", ForceConsoleColor, true}, + } + for _, mode := range modes { + t.Run(mode.name, func(t *testing.T) { + mode.set() + buffer.Reset() + w := PerformRequest(router, http.MethodGet, "/recovery") + assert.Equal(t, http.StatusInternalServerError, w.Code) + assert.Contains(t, buffer.String(), "changing color mode") + if mode.wantColor { + assert.Contains(t, buffer.String(), "\x1b[31m") + assert.Contains(t, buffer.String(), reset) + } else { + assert.NotContains(t, buffer.String(), "\x1b[") + } + }) + } +} + +func TestRecoveryNilWriterColorModes(t *testing.T) { + previousMode := consoleColorMode + t.Cleanup(func() { consoleColorMode = previousMode }) + + for _, mode := range []struct { + name string + set func() + }{ + {"disabled", DisableConsoleColor}, + {"forced", ForceConsoleColor}, + {"automatic", func() { consoleColorMode = autoColor }}, + } { + t.Run(mode.name, func(t *testing.T) { + mode.set() + for _, custom := range []bool{false, true} { + called := false + handle := func(c *Context, err any) { + called = true + assert.Equal(t, "nil writer panic", err) + c.AbortWithStatus(http.StatusTeapot) + } + router := New() + if custom { + router.Use(CustomRecoveryWithWriter(nil, handle)) + } else { + router.Use(RecoveryWithWriter(nil)) + } + router.GET("/recovery", func(_ *Context) { panic("nil writer panic") }) + w := PerformRequest(router, http.MethodGet, "/recovery") + if custom { + assert.True(t, called) + assert.Equal(t, http.StatusTeapot, w.Code) + } else { + assert.Equal(t, http.StatusInternalServerError, w.Code) + } + } + }) + } +} + +func TestRecoveryConcurrentColorModes(t *testing.T) { + previousMode := consoleColorMode + t.Cleanup(func() { consoleColorMode = previousMode }) + + for _, mode := range []struct { + name string + set func() + wantColor bool + }{ + {"disabled", DisableConsoleColor, false}, + {"forced", ForceConsoleColor, true}, + {"automatic", func() { consoleColorMode = autoColor }, false}, + } { + t.Run(mode.name, func(t *testing.T) { + mode.set() + var buffer bytes.Buffer + router := New() + router.Use(RecoveryWithWriter(&buffer)) + router.GET("/recovery", func(_ *Context) { panic("concurrent panic") }) + + const requests = 20 + statuses := make([]int, requests) + var wg sync.WaitGroup + for i := range requests { + wg.Add(1) + go func() { + defer wg.Done() + statuses[i] = PerformRequest(router, http.MethodGet, "/recovery").Code + }() + } + wg.Wait() + + for _, status := range statuses { + assert.Equal(t, http.StatusInternalServerError, status) + } + out := buffer.String() + assert.Equal(t, requests, strings.Count(out, "panic recovered")) + if mode.wantColor { + assert.Equal(t, requests, strings.Count(out, "\x1b[31m")) + assert.Equal(t, requests, strings.Count(out, reset)) + } else { + assert.NotContains(t, out, "\x1b[") + } + entries := strings.Split(out, "\n\n") + assert.Len(t, entries, requests+1) + for _, entry := range entries[1:] { + assert.Contains(t, entry, "panic recovered") + if mode.wantColor { + assert.True(t, strings.HasPrefix(strings.TrimLeft(entry, "\n"), "\x1b[31m")) + assert.True(t, strings.HasSuffix(strings.TrimSpace(entry), reset)) + } + } + }) + } +} + +func recoveryStackFrameHandler(_ *Context) { + panic("stack frame panic") +} + +func TestRecoveryStackFrames(t *testing.T) { + previousMode := Mode() + t.Cleanup(func() { SetMode(previousMode) }) + for _, mode := range []string{TestMode, DebugMode} { + t.Run(mode, func(t *testing.T) { + SetMode(mode) + var buffer strings.Builder + router := New() + router.Use(RecoveryWithWriter(&buffer)) + router.GET("/recovery", recoveryStackFrameHandler) + + w := PerformRequest(router, http.MethodGet, "/recovery") + assert.Equal(t, http.StatusInternalServerError, w.Code) + assert.Regexp(t, `stack frame panic\n[^\n]*recovery_test\.go:[0-9]+ \(0x[0-9a-f]+\)\n\trecoveryStackFrameHandler:`, buffer.String()) + }) + } +} + func TestPanicClean(t *testing.T) { buffer := new(strings.Builder) router := New()