10 "github.com/go-kit/kit/log"
11 "github.com/go-kit/kit/log/level"
14 func TestVariousLevels(t *testing.T) {
15 testCases := []struct {
23 strings.Join([]string{
24 `{"level":"debug","this is":"debug log"}`,
25 `{"level":"info","this is":"info log"}`,
26 `{"level":"warn","this is":"warn log"}`,
27 `{"level":"error","this is":"error log"}`,
33 strings.Join([]string{
34 `{"level":"debug","this is":"debug log"}`,
35 `{"level":"info","this is":"info log"}`,
36 `{"level":"warn","this is":"warn log"}`,
37 `{"level":"error","this is":"error log"}`,
43 strings.Join([]string{
44 `{"level":"info","this is":"info log"}`,
45 `{"level":"warn","this is":"warn log"}`,
46 `{"level":"error","this is":"error log"}`,
52 strings.Join([]string{
53 `{"level":"warn","this is":"warn log"}`,
54 `{"level":"error","this is":"error log"}`,
60 strings.Join([]string{
61 `{"level":"error","this is":"error log"}`,
71 for _, tc := range testCases {
72 t.Run(tc.name, func(t *testing.T) {
74 logger := level.NewFilter(log.NewJSONLogger(&buf), tc.allowed)
76 level.Debug(logger).Log("this is", "debug log")
77 level.Info(logger).Log("this is", "info log")
78 level.Warn(logger).Log("this is", "warn log")
79 level.Error(logger).Log("this is", "error log")
81 if want, have := tc.want, strings.TrimSpace(buf.String()); want != have {
82 t.Errorf("\nwant:\n%s\nhave:\n%s", want, have)
88 func TestErrNotAllowed(t *testing.T) {
89 myError := errors.New("squelched!")
90 opts := []level.Option{
92 level.ErrNotAllowed(myError),
94 logger := level.NewFilter(log.NewNopLogger(), opts...)
96 if want, have := myError, level.Info(logger).Log("foo", "bar"); want != have {
97 t.Errorf("want %#+v, have %#+v", want, have)
100 if want, have := error(nil), level.Warn(logger).Log("foo", "bar"); want != have {
101 t.Errorf("want %#+v, have %#+v", want, have)
105 func TestErrNoLevel(t *testing.T) {
106 myError := errors.New("no level specified")
109 opts := []level.Option{
110 level.SquelchNoLevel(true),
111 level.ErrNoLevel(myError),
113 logger := level.NewFilter(log.NewJSONLogger(&buf), opts...)
115 if want, have := myError, logger.Log("foo", "bar"); want != have {
116 t.Errorf("want %v, have %v", want, have)
118 if want, have := ``, strings.TrimSpace(buf.String()); want != have {
119 t.Errorf("\nwant '%s'\nhave '%s'", want, have)
123 func TestAllowNoLevel(t *testing.T) {
125 opts := []level.Option{
126 level.SquelchNoLevel(false),
127 level.ErrNoLevel(errors.New("I should never be returned!")),
129 logger := level.NewFilter(log.NewJSONLogger(&buf), opts...)
131 if want, have := error(nil), logger.Log("foo", "bar"); want != have {
132 t.Errorf("want %v, have %v", want, have)
134 if want, have := `{"foo":"bar"}`, strings.TrimSpace(buf.String()); want != have {
135 t.Errorf("\nwant '%s'\nhave '%s'", want, have)
139 func TestLevelContext(t *testing.T) {
142 // Wrapping the level logger with a context allows users to use
143 // log.DefaultCaller as per normal.
144 var logger log.Logger
145 logger = log.NewLogfmtLogger(&buf)
146 logger = level.NewFilter(logger, level.AllowAll())
147 logger = log.With(logger, "caller", log.DefaultCaller)
149 level.Info(logger).Log("foo", "bar")
150 if want, have := `level=info caller=level_test.go:149 foo=bar`, strings.TrimSpace(buf.String()); want != have {
151 t.Errorf("\nwant '%s'\nhave '%s'", want, have)
155 func TestContextLevel(t *testing.T) {
158 // Wrapping a context with the level logger still works, but requires users
159 // to specify a higher callstack depth value.
160 var logger log.Logger
161 logger = log.NewLogfmtLogger(&buf)
162 logger = log.With(logger, "caller", log.Caller(5))
163 logger = level.NewFilter(logger, level.AllowAll())
165 level.Info(logger).Log("foo", "bar")
166 if want, have := `caller=level_test.go:165 level=info foo=bar`, strings.TrimSpace(buf.String()); want != have {
167 t.Errorf("\nwant '%s'\nhave '%s'", want, have)
171 func TestLevelFormatting(t *testing.T) {
172 testCases := []struct {
174 format func(io.Writer) log.Logger
179 format: log.NewLogfmtLogger,
180 output: `level=info foo=bar`,
184 format: log.NewJSONLogger,
185 output: `{"foo":"bar","level":"info"}`,
189 for _, tc := range testCases {
190 t.Run(tc.name, func(t *testing.T) {
193 logger := tc.format(&buf)
194 level.Info(logger).Log("foo", "bar")
195 if want, have := tc.output, strings.TrimSpace(buf.String()); want != have {
196 t.Errorf("\nwant: '%s'\nhave '%s'", want, have)
202 func TestInjector(t *testing.T) {
208 logger = log.LoggerFunc(func(keyvals ...interface{}) error {
212 logger = level.NewInjector(logger, level.InfoValue())
214 logger.Log("foo", "bar")
215 if got, want := len(output), 4; got != want {
216 t.Errorf("missing level not injected: got len==%d, want len==%d", got, want)
218 if got, want := output[0], level.Key(); got != want {
219 t.Errorf("wrong level key: got %#v, want %#v", got, want)
221 if got, want := output[1], level.InfoValue(); got != want {
222 t.Errorf("wrong level value: got %#v, want %#v", got, want)
225 level.Error(logger).Log("foo", "bar")
226 if got, want := len(output), 4; got != want {
227 t.Errorf("leveled record modified: got len==%d, want len==%d", got, want)
229 if got, want := output[0], level.Key(); got != want {
230 t.Errorf("wrong level key: got %#v, want %#v", got, want)
232 if got, want := output[1], level.ErrorValue(); got != want {
233 t.Errorf("wrong level value: got %#v, want %#v", got, want)