logging/fields_test.go at master · amarin/logging · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
package logging_test

import (
	"strings"
	"testing"

	"github.com/stretchr/testify/require"
	"gopkg.in/yaml.v3"

	"github.com/amarin/logging"
)

func TestFields_WrittenIntoEveryRecord(t *testing.T) {
	s := initJSON(t, logging.WithFields(logging.Keys{"service": "billing", "env": "prod"}))

	logging.NewLogger().Info("plain")
	logging.NewLogger().WithKey("order", 42).Info("keyed")
	logging.NewNamedLogger("db").Warn("named")

	recs := s.records(t)
	require.Len(t, recs, 3)

	for _, rec := range recs {
		require.Equal(t, "billing", rec["service"])
		require.Equal(t, "prod", rec["env"])
	}

	require.EqualValues(t, 42, recs[1]["order"])
	// service fields go first, logger fields after them
	line := strings.Split(strings.TrimSpace(s.String()), "\n")[1]
	require.Less(t, strings.Index(line, `"env"`), strings.Index(line, `"service"`), "sorted by name")
	require.Less(t, strings.Index(line, `"service"`), strings.Index(line, `"order"`))
}

func TestFields_SameKeyIsNotMerged(t *testing.T) {
	s := initJSON(t, logging.WithFields(logging.Keys{"env": "prod"}))
	logging.NewLogger().WithKey("env", "local").Info("x")
	require.Equal(t, 2, strings.Count(s.String(), `"env"`))
}

func TestFields_YAML(t *testing.T) {
	cfg := logging.NewConfig()
	require.NoError(t, yaml.Unmarshal([]byte("fields:\n  service: billing\n  retries: 3\n  debug: true\n"), cfg))
	require.NoError(t, cfg.Validate())
	require.Equal(t, logging.Keys{"service": "billing", "retries": 3, "debug": true}, cfg.Fields)
}

func TestFields_Validate(t *testing.T) {
	for name, fields := range map[string]logging.Keys{
		"empty key":     {"": 1},
		"reserved ts":   {"ts": 1},
		"reserved msg":  {"msg": 1},
		"reserved lvl":  {"level": 1},
		"reserved name": {"logger": 1},
		"nested map":    {"a": map[string]any{"b": 1}},
		"list":          {"a": []any{1}},
	} {
		cfg := logging.NewConfig()
		cfg.Fields = fields
		require.ErrorIsf(t, cfg.Validate(), logging.Error, name)
	}

	cfg := logging.NewConfig()
	require.NoError(t, yaml.Unmarshal([]byte("fields:\n  a: {b: 1}\n"), cfg))
	require.Error(t, cfg.Validate())
}

func TestFields_WithConfigMerges(t *testing.T) {
	dst := logging.NewConfig()
	dst.Apply(logging.WithFields(logging.Keys{"a": 1, "b": 2}))

	src := logging.NewConfig()
	src.Fields = logging.Keys{"b": 3, "c": 4}
	dst.Apply(logging.WithConfig(src))
	require.Equal(t, logging.Keys{"a": 1, "b": 3, "c": 4}, dst.Fields)

	var nilFields logging.Config
	nilFields.Apply(logging.WithFields(logging.Keys{"x": 1}), logging.WithConfig(&logging.Config{Fields: logging.Keys{"y": 2}}))
	require.Equal(t, logging.Keys{"x": 1, "y": 2}, nilFields.Fields)
}

func TestFields_TestLogger(t *testing.T) {
	tl := logging.NewTestLogger(logging.WithFields(logging.Keys{"service": "billing"}))
	tl.WithKey("k", 1).Info("x")

	recs := tl.Records()
	require.Len(t, recs, 1)
	require.Equal(t, "billing", recs[0].Fields["service"])
}

func TestEmptyKeysAreDropped(t *testing.T) {
	s := initJSON(t)
	log := logging.NewLogger().WithKey("", "a").WithKeys(logging.Keys{"": "b", "k": "c"})
	log.Info("msg")
	require.NoError(t, logging.Sync())

	require.NotContains(t, s.String(), `"":`)
	require.Contains(t, s.String(), `"k":"c"`)
}

func TestWithConfig_RejectsZeroConfig(t *testing.T) {
	require.Error(t, logging.Init(logging.WithConfig(new(logging.Config))))

	cfg := logging.NewConfig()
	cfg.Level = logging.LevelTrace // an explicit trace level is fine
	require.NoError(t, logging.Init(logging.WithConfig(cfg)))
}