fix(recovery): honor console color configuration

This commit is contained in:
Ruben Pari 2026-10-29 16:41:07 +01:00
parent 0f09c3a9b4
commit a5b6466e9e
4 changed files with 367 additions and 15 deletions

View File

@ -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{}

View File

@ -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) {

View File

@ -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 {

View File

@ -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()