hook_test.go

package logging_test

import (
	"sync"
	"testing"

	"github.com/stretchr/testify/require"

	"github.com/amarin/logging"
)

type hookRecorder struct {
	mu      sync.Mutex
	entries []logging.HookEntry
}

func (h *hookRecorder) hook(e logging.HookEntry) {
	h.mu.Lock()
	defer h.mu.Unlock()

	h.entries = append(h.entries, e)
}

func TestHook_CalledForWrittenRecordsFromMinLevel(t *testing.T) {
	rec := new(hookRecorder)
	errors := new(hookRecorder)
	s := initJSON(t, logging.WithLevel(logging.LevelDebug),
		logging.WithHook(logging.LevelWarn, rec.hook), logging.WithHook(logging.LevelError, errors.hook))

	l := logging.NewLogger()
	l.Debug("d")
	l.Warn("w")
	logging.NewNamedLogger("db", logging.LevelError).Warn("filtered by logger level")
	logging.NewNamedLogger("db").Error("e")

	require.Len(t, s.records(t), 3)
	require.Len(t, rec.entries, 2)
	require.Equal(t, logging.LevelWarn, rec.entries[0].Level)
	require.Equal(t, "w", rec.entries[0].Message)
	require.Empty(t, rec.entries[0].Logger)
	require.Contains(t, rec.entries[0].Caller, "hook_test.go:")
	require.False(t, rec.entries[0].Time.IsZero())
	require.Equal(t, "db", rec.entries[1].Logger)

	require.Len(t, errors.entries, 1)
	require.Equal(t, "e", errors.entries[0].Message)
}

func TestHook_PanicIsIgnoredAndOthersRun(t *testing.T) {
	rec := new(hookRecorder)
	s := initJSON(t,
		logging.WithHook(logging.LevelInfo, func(logging.HookEntry) { panic("boom") }),
		logging.WithHook(logging.LevelInfo, nil),
		logging.WithHook(logging.LevelInfo, rec.hook))

	require.NotPanics(t, func() { logging.NewLogger().Info("x") })
	require.Len(t, s.records(t), 1)
	require.Len(t, rec.entries, 1)
	require.Empty(t, rec.entries[0].Caller, "callers are not collected at info level")
}

func TestHook_TraceAndMerge(t *testing.T) {
	a, b := new(hookRecorder), new(hookRecorder)
	src := logging.NewConfig()
	src.Level = logging.LevelTrace // WithConfig copies the level too
	src.Apply(logging.WithHook(logging.LevelTrace, b.hook))

	tl := logging.NewTestLogger(logging.WithLevel(logging.LevelTrace),
		logging.WithHook(logging.LevelTrace, a.hook), logging.WithConfig(src))
	tl.Trace("t")

	require.Len(t, a.entries, 1)
	require.Equal(t, logging.LevelTrace, a.entries[0].Level)
	require.Len(t, b.entries, 1, "WithConfig keeps hooks of src")
}

func TestHook_FatalHookRunsBeforeExit(t *testing.T) {
	rec := new(hookRecorder)
	tl := logging.NewTestLogger(logging.WithHook(logging.LevelFatal, rec.hook))
	require.Panics(t, func() { tl.Fatal("bye") }, "test logger panics instead of exit")
	require.Len(t, rec.entries, 1)
	require.Equal(t, logging.LevelFatal, rec.entries[0].Level)
}