github.com/Jeffail/benthos/v3@v3.65.0/lib/log/modular_test.go (about) 1 package log 2 3 import ( 4 "bytes" 5 "testing" 6 7 "github.com/stretchr/testify/assert" 8 "github.com/stretchr/testify/require" 9 ) 10 11 func TestModules(t *testing.T) { 12 loggerConfig := NewConfig() 13 loggerConfig.AddTimeStamp = false 14 loggerConfig.JSONFormat = false 15 loggerConfig.Prefix = "root" 16 loggerConfig.LogLevel = "WARN" 17 18 var buf bytes.Buffer 19 20 logger := New(&buf, loggerConfig) 21 logger.Warnln("Warning message root module") 22 23 logger2 := logger.NewModule(".foo") 24 logger2.Warnln("Warning message root.foo module") 25 26 logger3 := logger.NewModule(".foo2") 27 logger3.Warnln("Warning message root.foo2 module") 28 29 logger4 := logger2.NewModule(".bar") 30 logger4.Warnln("Warning message root.foo.bar module") 31 32 expected := "WARN | root | Warning message root module\n" + 33 "WARN | root.foo | Warning message root.foo module\n" + 34 "WARN | root.foo2 | Warning message root.foo2 module\n" + 35 "WARN | root.foo.bar | Warning message root.foo.bar module\n" 36 37 assert.Equal(t, expected, buf.String()) 38 } 39 40 func TestStaticFields(t *testing.T) { 41 loggerConfig := NewConfig() 42 loggerConfig.AddTimeStamp = false 43 loggerConfig.JSONFormat = true 44 loggerConfig.Prefix = "root" 45 loggerConfig.LogLevel = "WARN" 46 loggerConfig.StaticFields = map[string]string{ 47 "@service": "benthos_service", 48 "@system": "foo", 49 } 50 51 var buf bytes.Buffer 52 53 logger := New(&buf, loggerConfig) 54 logger.Warnln("Warning message root module") 55 logger.Warnf("Warning message root module\n") 56 57 logger2 := logger.NewModule(".foo") 58 logger2.Warnln("Warning message root.foo module") 59 60 expected := `{"@service":"benthos_service","@system":"foo","component":"root","level":"WARN","message":"Warning message root module"} 61 {"@service":"benthos_service","@system":"foo","component":"root","level":"WARN","message":"Warning message root module"} 62 {"@service":"benthos_service","@system":"foo","component":"root.foo","level":"WARN","message":"Warning message root.foo module"} 63 ` 64 65 assert.Equal(t, expected, buf.String()) 66 } 67 68 func TestStaticFieldsOverride(t *testing.T) { 69 loggerConfig := NewConfig() 70 loggerConfig.AddTimeStamp = false 71 loggerConfig.JSONFormat = true 72 loggerConfig.Prefix = "root" 73 loggerConfig.LogLevel = "WARN" 74 loggerConfig.StaticFields = map[string]string{ 75 "@service": "benthos_service", 76 "@system": "foo", 77 } 78 79 var buf bytes.Buffer 80 81 logger := New(&buf, loggerConfig) 82 logger.Warnf("Warning message root module") 83 84 logger2 := WithFields(logger, map[string]string{"foo": "bar", "@service": "fooserve"}) 85 logger2.Warnln("Warning message foo fields") 86 87 logger.Warnf("Warning message root module\n") 88 89 expected := `{"@service":"benthos_service","@system":"foo","component":"root","level":"WARN","message":"Warning message root module"} 90 {"@service":"fooserve","@system":"foo","component":"root","foo":"bar","level":"WARN","message":"Warning message foo fields"} 91 {"@service":"benthos_service","@system":"foo","component":"root","level":"WARN","message":"Warning message root module"} 92 ` 93 94 assert.Equal(t, expected, buf.String()) 95 } 96 97 func TestStaticFieldsEmpty(t *testing.T) { 98 loggerConfig := NewConfig() 99 loggerConfig.AddTimeStamp = false 100 loggerConfig.JSONFormat = true 101 loggerConfig.Prefix = "root" 102 loggerConfig.LogLevel = "WARN" 103 loggerConfig.StaticFields = map[string]string{} 104 105 var buf bytes.Buffer 106 107 logger := New(&buf, loggerConfig) 108 logger.Warnln("Warning message root module") 109 logger.Warnf("Warning message root module\n") 110 111 logger2 := logger.NewModule(".foo") 112 logger2.Warnln("Warning message root.foo module") 113 114 expected := `{"component":"root","level":"WARN","message":"Warning message root module"} 115 {"component":"root","level":"WARN","message":"Warning message root module"} 116 {"component":"root.foo","level":"WARN","message":"Warning message root.foo module"} 117 ` 118 119 assert.Equal(t, expected, buf.String()) 120 } 121 122 func TestLoggerWith(t *testing.T) { 123 loggerConfig := NewConfig() 124 loggerConfig.AddTimeStamp = false 125 loggerConfig.Format = "logfmt" 126 loggerConfig.LogLevel = "WARN" 127 loggerConfig.StaticFields = map[string]string{ 128 "@service": "benthos_service", 129 "@system": "foo", 130 } 131 132 var buf bytes.Buffer 133 134 logger, err := NewV2(&buf, loggerConfig) 135 require.NoError(t, err) 136 137 logger.Warnf("Warning message root module") 138 139 logger2, err := With(logger, "foo", "bar", "count", 10, "thing", "is a string", "iscool", true) 140 require.NoError(t, err) 141 logger2.Warnln("Warning message foo fields") 142 143 logger.Warnf("Warning message root module\n") 144 145 expected := `@service=benthos_service @system=foo component=benthos level=WARN msg="Warning message root module" 146 @service=benthos_service @system=foo component=benthos count=10 foo=bar iscool=true thing="is a string" level=WARN msg="Warning message foo fields" 147 @service=benthos_service @system=foo component=benthos level=WARN msg="Warning message root module" 148 ` 149 150 assert.Equal(t, expected, buf.String()) 151 } 152 153 func TestLoggerWithOddArgs(t *testing.T) { 154 loggerConfig := NewConfig() 155 loggerConfig.AddTimeStamp = false 156 loggerConfig.Format = "logfmt" 157 loggerConfig.LogLevel = "WARN" 158 loggerConfig.StaticFields = map[string]string{ 159 "@service": "benthos_service", 160 "@system": "foo", 161 } 162 163 var buf bytes.Buffer 164 165 logger, err := NewV2(&buf, loggerConfig) 166 require.NoError(t, err) 167 168 logger, err = With(logger, "foo", "bar", "count", 10, "thing", "is a string", "iscool", true, "woops") 169 require.NoError(t, err) 170 171 logger.Warnln("Warning message foo fields") 172 173 expected := `@service=benthos_service @system=foo component=benthos count=10 foo=bar iscool=true thing="is a string" level=WARN msg="Warning message foo fields" 174 ` 175 176 assert.Equal(t, expected, buf.String()) 177 } 178 179 func TestLoggerWithNonStringKeys(t *testing.T) { 180 loggerConfig := NewConfig() 181 loggerConfig.AddTimeStamp = false 182 loggerConfig.Format = "logfmt" 183 loggerConfig.LogLevel = "WARN" 184 loggerConfig.StaticFields = map[string]string{ 185 "@service": "benthos_service", 186 "@system": "foo", 187 } 188 189 var buf bytes.Buffer 190 191 logger, err := NewV2(&buf, loggerConfig) 192 require.NoError(t, err) 193 194 logger, err = With(logger, "foo", "bar", 10, "count", "thing", "is a string", "iscool", true) 195 require.NoError(t, err) 196 197 logger.Warnln("Warning message foo fields") 198 199 expected := `@service=benthos_service @system=foo component=benthos foo=bar iscool=true thing="is a string" level=WARN msg="Warning message foo fields" 200 ` 201 202 assert.Equal(t, expected, buf.String()) 203 } 204 205 func TestFormattedLogging(t *testing.T) { 206 loggerConfig := NewConfig() 207 loggerConfig.AddTimeStamp = false 208 loggerConfig.JSONFormat = false 209 loggerConfig.Prefix = "test" 210 loggerConfig.LogLevel = "WARN" 211 212 var buf bytes.Buffer 213 214 logger := New(&buf, loggerConfig) 215 logger.Fatalf("fatal test %v\n", 1) 216 logger.Errorf("error test %v\n", 2) 217 logger.Warnf("warn test %v\n", 3) 218 logger.Infof("info test %v\n", 4) 219 logger.Debugf("info test %v\n", 5) 220 logger.Tracef("trace test %v\n", 6) 221 222 expected := "FATAL | test | fatal test 1\nERROR | test | error test 2\nWARN | test | warn test 3\n" 223 224 assert.Equal(t, expected, buf.String()) 225 } 226 227 func TestLineLogging(t *testing.T) { 228 loggerConfig := NewConfig() 229 loggerConfig.AddTimeStamp = false 230 loggerConfig.JSONFormat = false 231 loggerConfig.Prefix = "test" 232 loggerConfig.LogLevel = "WARN" 233 234 var buf bytes.Buffer 235 236 logger := New(&buf, loggerConfig) 237 logger.Fatalln("fatal test") 238 logger.Errorln("error test") 239 logger.Warnln("warn test") 240 logger.Infoln("info test") 241 logger.Debugln("info test") 242 logger.Traceln("trace test") 243 244 expected := "FATAL | test | fatal test\nERROR | test | error test\nWARN | test | warn test\n" 245 246 assert.Equal(t, expected, buf.String()) 247 } 248 249 type logCounter struct { 250 count int 251 } 252 253 func (l *logCounter) Write(p []byte) (n int, err error) { 254 l.count++ 255 return len(p), nil 256 } 257 258 func TestLogLevels(t *testing.T) { 259 for i := 0; i < LogAll; i++ { 260 loggerConfig := NewConfig() 261 loggerConfig.JSONFormat = false 262 loggerConfig.LogLevel = intToLogLevel(i) 263 264 buf := logCounter{} 265 266 logger := New(&buf, loggerConfig) 267 logger.Fatalln("fatal test") 268 logger.Errorln("error test") 269 logger.Warnln("warn test") 270 logger.Infoln("info test") 271 logger.Debugln("info test") 272 logger.Traceln("trace test") 273 274 if i != buf.count { 275 t.Errorf("Wrong log count for [%v], %v != %v", loggerConfig.LogLevel, i, buf.count) 276 } 277 } 278 }