package logrus_test

import (

"bytes"

"context"

"encoding/json"

"errors"

"fmt"

"io"

"runtime"

"sync"

"testing"

"time"

"github.com/sirupsen/logrus"

"github.com/sirupsen/logrus/hooks/test"

"github.com/stretchr/testify/assert"

"github.com/stretchr/testify/require"

)

type noopHook struct{}

func (noopHook) Levels() []logrus.Level { return logrus.AllLevels }

func (noopHook) Fire(*logrus.Entry) error { return nil }

type nopBufferPool struct{}

func (nopBufferPool) Get() *bytes.Buffer { return new(bytes.Buffer) }

func (nopBufferPool) Put(*bytes.Buffer) {}

type nopFormatter struct{}

func (nopFormatter) Format(*logrus.Entry) ([]byte, error) { return nil, nil }

type funcError func()

func (funcError) Error() string { return "boom" }

type contextKeyType string

func TestEntryWithError(t *testing.T) {

expErr := fmt.Errorf("kaboom at layer %d", 4711)

logger, hook := test.NewNullLogger()

logger.WithError(expErr).Error("default key")

tmpKey := logrus.ErrorKey

logrus.ErrorKey = "err" //nolint:reassign // ignore "reassigning variable ErrorKey in other package logrus (reassign)"

t.Cleanup(func() {

logrus.ErrorKey = tmpKey //nolint:reassign // ignore "reassigning variable ErrorKey in other package logrus (reassign)"

})

logger.WithError(expErr).Error("custom key")

require.Len(t, hook.Entries, 2)

assert.Equal(t, expErr, hook.Entries[0].Data["error"])

assert.Equal(t, expErr, hook.Entries[1].Data["err"])

}

// TestEntryErrorFieldValues verifies that error fields are accepted, rejected,

// and formatted consistently across WithError, WithField, and WithFields.

//

// relates to https://github.com/sirupsen/logrus/pull/1577#discussion_r3799339160

func TestEntryErrorFieldValues(t *testing.T) {

errFunc := funcError(func() {})

fn := func() {}

values := []struct {

name string

value any

valid bool

}{

{name: "error", value: errors.New("boom"), valid: true},

{name: "function error", value: errFunc, valid: true},

{name: "function error pointer", value: &errFunc, valid: true},

{name: "string", value: "boom", valid: true},

{name: "function", value: fn, valid: false},

{name: "function pointer", value: &fn, valid: false},

}

tests := []struct {

doc string

apply func(*logrus.Logger, any) *logrus.Entry

}{

{

doc: "WithError",

apply: func(logger *logrus.Logger, value any) *logrus.Entry {

return logger.WithError(value.(error))

},

},

{

doc: "WithField",

apply: func(logger *logrus.Logger, value any) *logrus.Entry {

return logger.WithField(logrus.ErrorKey, value)

},

},

{

doc: "WithFields",

apply: func(logger *logrus.Logger, value any) *logrus.Entry {

return logger.WithFields(logrus.Fields{logrus.ErrorKey: value})

},

},

}

for _, tc := range tests {

for _, val := range values {

t.Run(tc.doc+"("+val.name+")", func(t *testing.T) {

if _, ok := val.value.(error); tc.doc == "WithError" && !ok {

skip(t, "WithError only accepts error values")

return

}

var buf bytes.Buffer

logger := logrus.New()

logger.SetOutput(&buf)

logger.SetFormatter(&logrus.JSONFormatter{})

tc.apply(logger, val.value).Error("test")

var data map[string]any

require.NoError(t, json.Unmarshal(buf.Bytes(), &data))

if val.valid {

assert.Equal(t, "boom", data[logrus.ErrorKey])

assert.NotContains(t, data, logrus.FieldKeyLogrusError)

} else {

assert.NotContains(t, data, logrus.ErrorKey)

assert.Contains(t, data, logrus.FieldKeyLogrusError)

}

})

}

}

}

func TestEntryWithContext(t *testing.T) {

assert := assert.New(t)

var contextKey contextKeyType = "foo"

ctx := context.WithValue(context.Background(), contextKey, "bar")

assert.Equal(ctx, logrus.WithContext(ctx).Context)

logger := logrus.New()

logger.SetOutput(io.Discard)

entry := logrus.NewEntry(logger)

assert.Equal(ctx, entry.WithContext(ctx).Context)

}

func TestEntryWithContextPreservesData(t *testing.T) {

logger, hook := test.NewNullLogger()

// Initialize a parent Entry object with a key/value field.

parentEntry := logger.WithField("parentKey", "parentValue")

// Create two child Entry objects from the parent in different contexts.

var contextKey1 contextKeyType = "foo"

ctx1 := context.WithValue(context.Background(), contextKey1, "bar")

childEntry1 := parentEntry.WithContext(ctx1)

assert.Equal(t, ctx1, childEntry1.Context)

var contextKey2 contextKeyType = "bar"

ctx2 := context.WithValue(context.Background(), contextKey2, "baz")

childEntry2 := parentEntry.WithContext(ctx2)

assert.Equal(t, ctx2, childEntry2.Context)

assert.NotEqual(t, ctx1, ctx2)

childEntry1.Info("child 1")

childEntry2.Info("child 2")

parentEntry.Info("parent")

require.Len(t, hook.Entries, 3)

// Ensure that data set in the parent Entry are preserved in both children

// and when the parent is reused.

assert.Equal(t, "parentValue", hook.Entries[0].Data["parentKey"])

assert.Equal(t, "parentValue", hook.Entries[1].Data["parentKey"])

assert.Equal(t, "parentValue", hook.Entries[2].Data["parentKey"])

}

func TestEntryWithTimePreservesData(t *testing.T) {

logger, hook := test.NewNullLogger()

// Initialize a parent Entry object with a key/value field.

parentEntry := logger.WithField("parentKey", "parentValue")

// Create two child Entry objects from the parent with two different times.

childEntry1 := parentEntry.WithTime(time.Now().AddDate(0, 0, 1))

childEntry2 := parentEntry.WithTime(time.Now().AddDate(0, 0, 2))

childEntry1.Info("child 1")

childEntry2.Info("child 2")

parentEntry.Info("parent")

require.Len(t, hook.Entries, 3)

// Ensure that data set in the parent Entry are preserved in both children

// and when the parent is reused.

assert.Equal(t, "parentValue", hook.Entries[0].Data["parentKey"])

assert.Equal(t, "parentValue", hook.Entries[1].Data["parentKey"])

assert.Equal(t, "parentValue", hook.Entries[2].Data["parentKey"])

}

// TestEntryLogPanicLevelDoesNotPanic verifies that generic Log methods treat

// PanicLevel as severity only and do not trigger panic behavior.

//

// Regression and related history:

// - https://github.com/sirupsen/logrus/pull/65

// - https://github.com/sirupsen/logrus/pull/1283

func TestEntryLogPanicLevelDoesNotPanic(t *testing.T) {

tests := []struct {

doc string

log func(*logrus.Entry)

want string

}{

{

doc: "Log",

log: func(e *logrus.Entry) { e.Log(logrus.PanicLevel, "kaboom") },

want: "kaboom",

},

{

doc: "Logf",

log: func(e *logrus.Entry) { e.Logf(logrus.PanicLevel, "kaboom %d", 42) },

want: "kaboom 42",

},

{

doc: "Logln",

log: func(e *logrus.Entry) { e.Logln(logrus.PanicLevel, "kaboom", 42) },

want: "kaboom 42",

},

}

for _, tc := range tests {

t.Run(tc.doc, func(t *testing.T) {

logger, hook := test.NewNullLogger()

require.NotPanics(t, func() {

tc.log(logrus.NewEntry(logger))

})

got := hook.LastEntry()

require.NotNil(t, got)

assert.Equal(t, logrus.PanicLevel, got.Level)

assert.Equal(t, tc.want, got.Message)

})

}

}

func TestEntryPanicln(t *testing.T) {

errBoom := fmt.Errorf("boom time")

defer func() {

p := recover()

assert.NotNil(t, p)

switch pVal := p.(type) {

case *logrus.Entry:

assert.Equal(t, "kaboom", pVal.Message)

assert.Equal(t, errBoom, pVal.Data["err"])

default:

t.Fatalf("want type *Entry, got %T: %#v", pVal, pVal)

}

}()

logger := logrus.New()

logger.SetOutput(io.Discard)

entry := logrus.NewEntry(logger)

entry.WithField("err", errBoom).Panicln("kaboom")

}

func TestEntryPanicf(t *testing.T) {

errBoom := fmt.Errorf("boom again")

defer func() {

p := recover()

assert.NotNil(t, p)

switch pVal := p.(type) {

case *logrus.Entry:

assert.Equal(t, "kaboom true", pVal.Message)

assert.Equal(t, errBoom, pVal.Data["err"])

default:

t.Fatalf("want type *Entry, got %T: %#v", pVal, pVal)

}

}()

logger := logrus.New()

logger.SetOutput(io.Discard)

entry := logrus.NewEntry(logger)

entry.WithField("err", errBoom).Panicf("kaboom %v", true)

}

func TestEntryPanic(t *testing.T) {

errBoom := fmt.Errorf("boom again")

defer func() {

p := recover()

assert.NotNil(t, p)

switch pVal := p.(type) {

case *logrus.Entry:

assert.Equal(t, "kaboom", pVal.Message)

assert.Equal(t, errBoom, pVal.Data["err"])

default:

t.Fatalf("want type *Entry, got %T: %#v", pVal, pVal)

}

}()

logger := logrus.New()

logger.SetOutput(io.Discard)

entry := logrus.NewEntry(logger)

entry.WithField("err", errBoom).Panic("kaboom")

}

const (

badMessage = "this is going to panic"

panicMessage = "this is broken"

)

type panickyHook struct{}

func (p *panickyHook) Levels() []logrus.Level {

return []logrus.Level{logrus.InfoLevel}

}

func (p *panickyHook) Fire(entry *logrus.Entry) error {

if entry.Message == badMessage {

panic(panicMessage)

}

return nil

}

func TestEntryHooksPanic(t *testing.T) {

logger := logrus.New()

logger.SetOutput(io.Discard)

logger.SetLevel(logrus.InfoLevel)

logger.AddHook(&panickyHook{})

defer func() {

p := recover()

assert.NotNil(t, p)

assert.Equal(t, panicMessage, p)

entry := logrus.NewEntry(logger)

entry.Info("another message")

}()

entry := logrus.NewEntry(logger)

entry.Info(badMessage)

}

// TestEntryDerivationPreservesCaller verifies that derived entries retain

// explicitly set caller information.

func TestEntryDerivationPreservesCaller(t *testing.T) {

entry := logrus.NewEntry(logrus.New())

entry.Caller = &runtime.Frame{

Function: "example.function",

File: "example.go",

Line: 42,

}

tests := []struct {

doc string

derive func(*logrus.Entry) *logrus.Entry

}{

{

doc: "Dup",

derive: func(entry *logrus.Entry) *logrus.Entry { return entry.Dup() },

},

{

doc: "WithContext",

derive: func(entry *logrus.Entry) *logrus.Entry { return entry.WithContext(context.Background()) },

},

{

doc: "WithError",

derive: func(entry *logrus.Entry) *logrus.Entry { return entry.WithError(errors.New("boom")) },

},

{

doc: "WithField",

derive: func(entry *logrus.Entry) *logrus.Entry { return entry.WithField("foo", "bar") },

},

{

doc: "WithFields",

derive: func(entry *logrus.Entry) *logrus.Entry { return entry.WithFields(logrus.Fields{"foo": "bar"}) },

},

{

doc: "WithTime",

derive: func(entry *logrus.Entry) *logrus.Entry { return entry.WithTime(time.Now()) },

},

}

for _, tc := range tests {

t.Run(tc.doc, func(t *testing.T) {

got := tc.derive(entry)

require.NotNil(t, got.Caller)

assert.Equal(t, "example.function", got.Caller.Function)

assert.Equal(t, "example.go", got.Caller.File)

assert.Equal(t, 42, got.Caller.Line)

})

}

}

func TestEntryWithIncorrectField(t *testing.T) {

var buf bytes.Buffer

logger := logrus.New()

logger.SetFormatter(&logrus.JSONFormatter{})

logger.SetOutput(&buf)

fn := func() {}

eWithFunc := logger.WithFields(logrus.Fields{"func": fn})

eWithFuncPtr := logger.WithFields(logrus.Fields{"funcPtr": &fn})

assert.Equal(t, `skipping unsupported field "func"`, getErr(t, &buf, eWithFunc))

assert.Equal(t, `skipping unsupported field "funcPtr"`, getErr(t, &buf, eWithFuncPtr))

eWithFunc = eWithFunc.WithField("not_a_func", "it is a string")

eWithFuncPtr = eWithFuncPtr.WithField("not_a_func", "it is a string")

assert.Equal(t, `skipping unsupported field "func"`, getErr(t, &buf, eWithFunc))

assert.Equal(t, `skipping unsupported field "funcPtr"`, getErr(t, &buf, eWithFuncPtr))

eWithFunc = eWithFunc.WithTime(time.Now())

eWithFuncPtr = eWithFuncPtr.WithTime(time.Now())

assert.Equal(t, `skipping unsupported field "func"`, getErr(t, &buf, eWithFunc))

assert.Equal(t, `skipping unsupported field "funcPtr"`, getErr(t, &buf, eWithFuncPtr))

}

func getErr(t *testing.T, buf *bytes.Buffer, entry *logrus.Entry) string {

t.Helper()

buf.Reset()

entry.Info("test")

var data map[string]any

require.NoError(t, json.Unmarshal(buf.Bytes(), &data))

got, _ := data[logrus.FieldKeyLogrusError].(string)

return got

}

func TestEntryLogfLevel(t *testing.T) {

var buffer bytes.Buffer

logger := logrus.New()

logger.SetOutput(&buffer)

logger.SetLevel(logrus.InfoLevel)

entry := logrus.NewEntry(logger)

entry.Logf(logrus.DebugLevel, "%s", "debug")

assert.NotContains(t, buffer.String(), "debug")

entry.Logf(logrus.WarnLevel, "%s", "warn")

assert.Contains(t, buffer.String(), "warn")

}

func TestEntryLoggerMutationRace(t *testing.T) {

tests := []struct {

doc string

mutate func(*logrus.Logger)

}{

{doc: "AddHook", mutate: func(l *logrus.Logger) { l.AddHook(noopHook{}) }},

{doc: "SetBufferPool", mutate: func(l *logrus.Logger) { l.SetBufferPool(nopBufferPool{}) }},

{doc: "SetFormatter", mutate: func(l *logrus.Logger) { l.SetFormatter(&logrus.TextFormatter{}) }},

{doc: "SetLevel", mutate: func(l *logrus.Logger) { l.SetLevel(logrus.InfoLevel) }},

{doc: "SetOutput", mutate: func(l *logrus.Logger) { l.SetOutput(io.Discard) }},

{doc: "SetReportCaller", mutate: func(l *logrus.Logger) { l.SetReportCaller(true) }},

{doc: "ReplaceHooks_withHookPresent", mutate: func(l *logrus.Logger) {

// Replace with a fresh map each time to maximize mutation.

h := make(logrus.LevelHooks)

for _, lvl := range logrus.AllLevels {

h[lvl] = []logrus.Hook{noopHook{}}

}

l.ReplaceHooks(h)

}},

}

for _, tc := range tests {

t.Run(tc.doc, func(t *testing.T) {

runEntryLoggerRace(t, tc.mutate)

})

}

}

func runEntryLoggerRace(t *testing.T, mutate func(logger *logrus.Logger)) {

t.Helper()

logger := logrus.New()

logger.SetOutput(io.Discard)

entry := logrus.NewEntry(logger)

const n = 100

var wg sync.WaitGroup

wg.Add(4)

go func() {

defer wg.Done()

for range n {

_, _ = entry.Bytes()

}

}()

go func() {

defer wg.Done()

for range n {

entry.Info("should not race")

}

}()

go func() {

defer wg.Done()

for range n {

mutate(logger)

}

}()

go func() {

defer wg.Done()

for range n {

entry.Info("should not race")

}

}()

wg.Wait()

}

// reentrantValue is a type whose MarshalJSON method triggers another log call,

// which would deadlock if the logger mutex is held during formatting.

type reentrantValue struct {

logger *logrus.Logger

}

func (r reentrantValue) MarshalJSON() ([]byte, error) {

r.logger.Info("reentrant log from MarshalJSON")

return []byte(`"reentrant"`), nil

}

// TestEntryReentrantLoggingDeadlock verifies that logging from within a field's

// MarshalJSON (or similar serialization callback) does not deadlock.

// This is a regression test for https://github.com/sirupsen/logrus/issues/1448.

func TestEntryReentrantLoggingDeadlock(t *testing.T) {

var buf bytes.Buffer

logger := logrus.New()

logger.SetOutput(&buf)

logger.SetFormatter(&logrus.JSONFormatter{})

done := make(chan struct{})

go func() {

defer close(done)

logger.WithFields(logrus.Fields{

"key": reentrantValue{logger: logger},

}).Info("outer log message")

}()

select {

case <-done:

// Success: the log call completed without deadlocking.

output := buf.String()

assert.Contains(t, output, "outer log message")

assert.Contains(t, output, "reentrant log from MarshalJSON")

assert.Contains(t, output, `"key":"reentrant"`)

case <-time.After(5 * time.Second):

t.Fatal("deadlock detected: reentrant logging from MarshalJSON blocked for 5 seconds")

}

}

// TestEntryWithFieldsThenBranch verifies that an Entry with fields can be

// logged, used as the parent of a derived Entry, and reused without inheriting

// fields added to the derived Entry.

func TestEntryWithFieldsThenBranch(t *testing.T) {

logger, hook := test.NewNullLogger()

entry := logger.

WithField("a", 1).

WithField("b", 2)

entry.Info("parent")

require.Len(t, hook.Entries, 1)

assert.Equal(t, logrus.Fields{

"a": 1,

"b": 2,

}, hook.Entries[0].Data)

child := entry.WithField("c", 3)

child.Info("child")

require.Len(t, hook.Entries, 2)

assert.Equal(t, logrus.Fields{

"a": 1,

"b": 2,

"c": 3,

}, hook.Entries[1].Data)

entry.Info("parent again")

require.Len(t, hook.Entries, 3)

assert.Equal(t, logrus.Fields{

"a": 1,

"b": 2,

}, hook.Entries[2].Data)

}

// TestEntryDataIsMutable verifies that Entry.Data exposes materialized fields,

// can be modified directly, and remains isolated between derived entries.

func TestEntryDataIsMutable(t *testing.T) {

logger, hook := test.NewNullLogger()

// Fields added to an entry are exposed immediately through Data.

parent := logger.WithFields(logrus.Fields{

"foo": "bar",

"one": 1,

})

assert.Equal(t, "bar", parent.Data["foo"])

assert.Equal(t, 1, parent.Data["one"])

// Derived entries inherit the parent's fields without sharing its Data map.

child := parent.WithFields(logrus.Fields{

"two": 2,

})

assert.Equal(t, "bar", child.Data["foo"])

assert.Equal(t, 1, child.Data["one"])

assert.Equal(t, 2, child.Data["two"])

// Data is public and mutable. Changes to the child must not affect its

// parent, and newly added fields must be preserved.

child.Data["foo"] = "changed"

child.Data["three"] = 3

assert.Equal(t, "bar", parent.Data["foo"])

assert.Equal(t, 1, parent.Data["one"])

assert.NotContains(t, parent.Data, "three")

// Logging must use the currently exposed Data and must not overwrite direct

// mutations by re-materializing fields from internal state.

parent.Info("parent")

child.Info("child")

require.Len(t, hook.Entries, 2)

assert.Equal(t, logrus.Fields{

"foo": "bar",

"one": 1,

}, hook.Entries[0].Data)

assert.Equal(t, logrus.Fields{

"foo": "changed",

"one": 1,

"two": 2,

"three": 3,

}, hook.Entries[1].Data)

}