Aleksandr Bezobchuk
3 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
43 changed files with 315 additions and 1362 deletions
Split View
Diff Options
-
+2 -0CHANGELOG_PENDING.md
-
+4 -7abci/cmd/abci-cli/abci-cli.go
-
+1 -2abci/tests/test_app/app.go
-
+2 -3cmd/priv_val_server/main.go
-
+1 -3cmd/tendermint/commands/debug/debug.go
-
+7 -10cmd/tendermint/commands/light.go
-
+2 -13cmd/tendermint/commands/root.go
-
+4 -4cmd/tendermint/commands/root_test.go
-
+8 -8config/config.go
-
+1 -9consensus/common_test.go
-
+1 -0go.mod
-
+5 -0go.sum
-
+0 -89libs/cli/flags/log_level.go
-
+0 -94libs/cli/flags/log_level_test.go
-
+101 -0libs/log/default.go
-
+48 -0libs/log/default_test.go
-
+0 -195libs/log/filter.go
-
+0 -140libs/log/filter_test.go
-
+45 -18libs/log/logger.go
-
+12 -0libs/log/nop.go
-
+0 -17libs/log/nop_logger.go
-
+41 -0libs/log/testing.go
-
+0 -66libs/log/testing_logger.go
-
+0 -24libs/log/tm_json_logger.go
-
+0 -86libs/log/tm_logger.go
-
+0 -112libs/log/tm_logger_test.go
-
+0 -135libs/log/tmfmt_logger.go
-
+0 -126libs/log/tmfmt_logger_test.go
-
+0 -76libs/log/tracing_logger.go
-
+0 -65libs/log/tracing_logger_test.go
-
+14 -13libs/service/service.go
-
+1 -15rpc/jsonrpc/jsonrpc_test.go
-
+1 -3rpc/jsonrpc/server/http_json_handler_test.go
-
+1 -2rpc/jsonrpc/test/main.go
-
+1 -2rpc/test/helpers.go
-
+3 -4store/store_test.go
-
+1 -2test/e2e/app/app.go
-
+3 -10test/e2e/app/main.go
-
+1 -1test/e2e/generator/main.go
-
+1 -1test/e2e/runner/main.go
-
+1 -2test/fuzz/p2p/pex/reactor_receive.go
-
+1 -2test/fuzz/rpc/jsonrpc/server/handler.go
-
+1 -3tools/tm-signer-harness/main.go
+ 2
- 0
CHANGELOG_PENDING.md
View File
+ 4
- 7
abci/cmd/abci-cli/abci-cli.go
View File
+ 1
- 2
abci/tests/test_app/app.go
View File
+ 2
- 3
cmd/priv_val_server/main.go
View File
+ 1
- 3
cmd/tendermint/commands/debug/debug.go
View File
+ 7
- 10
cmd/tendermint/commands/light.go
View File
+ 2
- 13
cmd/tendermint/commands/root.go
View File
+ 4
- 4
cmd/tendermint/commands/root_test.go
View File
+ 8
- 8
config/config.go
View File
+ 1
- 9
consensus/common_test.go
View File
+ 1
- 0
go.mod
View File
+ 5
- 0
go.sum
View File
+ 0
- 89
libs/cli/flags/log_level.go
View File
| @ -1,89 +0,0 @@ | |||
| package flags | |||
| import ( | |||
| "errors" | |||
| "fmt" | |||
| "strings" | |||
| "github.com/tendermint/tendermint/libs/log" | |||
| ) | |||
| const ( | |||
| defaultLogLevelKey = "*" | |||
| ) | |||
| // ParseLogLevel parses complex log level - comma-separated | |||
| // list of module:level pairs with an optional *:level pair (* means | |||
| // all other modules). | |||
| // | |||
| // Example: | |||
| // ParseLogLevel("consensus:debug,mempool:debug,*:error", log.NewTMLogger(os.Stdout), "info") | |||
| func ParseLogLevel(lvl string, logger log.Logger, defaultLogLevelValue string) (log.Logger, error) { | |||
| if lvl == "" { | |||
| return nil, errors.New("empty log level") | |||
| } | |||
| l := lvl | |||
| // prefix simple one word levels (e.g. "info") with "*" | |||
| if !strings.Contains(l, ":") { | |||
| l = defaultLogLevelKey + ":" + l | |||
| } | |||
| options := make([]log.Option, 0) | |||
| isDefaultLogLevelSet := false | |||
| var option log.Option | |||
| var err error | |||
| list := strings.Split(l, ",") | |||
| for _, item := range list { | |||
| moduleAndLevel := strings.Split(item, ":") | |||
| if len(moduleAndLevel) != 2 { | |||
| return nil, fmt.Errorf("expected list in a form of \"module:level\" pairs, given pair %s, list %s", item, list) | |||
| } | |||
| module := moduleAndLevel[0] | |||
| level := moduleAndLevel[1] | |||
| if module == defaultLogLevelKey { | |||
| option, err = log.AllowLevel(level) | |||
| if err != nil { | |||
| return nil, fmt.Errorf("failed to parse default log level (pair %s, list %s): %w", item, l, err) | |||
| } | |||
| options = append(options, option) | |||
| isDefaultLogLevelSet = true | |||
| } else { | |||
| switch level { | |||
| case "debug": | |||
| option = log.AllowDebugWith("module", module) | |||
| case "info": | |||
| option = log.AllowInfoWith("module", module) | |||
| case "error": | |||
| option = log.AllowErrorWith("module", module) | |||
| case "none": | |||
| option = log.AllowNoneWith("module", module) | |||
| default: | |||
| return nil, | |||
| fmt.Errorf("expected either \"info\", \"debug\", \"error\" or \"none\" log level, given %s (pair %s, list %s)", | |||
| level, | |||
| item, | |||
| list) | |||
| } | |||
| options = append(options, option) | |||
| } | |||
| } | |||
| // if "*" is not provided, set default global level | |||
| if !isDefaultLogLevelSet { | |||
| option, err = log.AllowLevel(defaultLogLevelValue) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| options = append(options, option) | |||
| } | |||
| return log.NewFilter(logger, options...), nil | |||
| } | |||
+ 0
- 94
libs/cli/flags/log_level_test.go
View File
| @ -1,94 +0,0 @@ | |||
| package flags_test | |||
| import ( | |||
| "bytes" | |||
| "strings" | |||
| "testing" | |||
| tmflags "github.com/tendermint/tendermint/libs/cli/flags" | |||
| "github.com/tendermint/tendermint/libs/log" | |||
| ) | |||
| const ( | |||
| defaultLogLevelValue = "info" | |||
| ) | |||
| func TestParseLogLevel(t *testing.T) { | |||
| var buf bytes.Buffer | |||
| jsonLogger := log.NewTMJSONLoggerNoTS(&buf) | |||
| correctLogLevels := []struct { | |||
| lvl string | |||
| expectedLogLines []string | |||
| }{ | |||
| {"mempool:error", []string{ | |||
| ``, // if no default is given, assume info | |||
| ``, | |||
| `{"_msg":"Mesmero","level":"error","module":"mempool"}`, | |||
| `{"_msg":"Mind","level":"info","module":"state"}`, // if no default is given, assume info | |||
| ``}}, | |||
| {"mempool:error,*:debug", []string{ | |||
| `{"_msg":"Kingpin","level":"debug","module":"wire"}`, | |||
| ``, | |||
| `{"_msg":"Mesmero","level":"error","module":"mempool"}`, | |||
| `{"_msg":"Mind","level":"info","module":"state"}`, | |||
| `{"_msg":"Gideon","level":"debug"}`}}, | |||
| {"*:debug,wire:none", []string{ | |||
| ``, | |||
| `{"_msg":"Kitty Pryde","level":"info","module":"mempool"}`, | |||
| `{"_msg":"Mesmero","level":"error","module":"mempool"}`, | |||
| `{"_msg":"Mind","level":"info","module":"state"}`, | |||
| `{"_msg":"Gideon","level":"debug"}`}}, | |||
| } | |||
| for _, c := range correctLogLevels { | |||
| logger, err := tmflags.ParseLogLevel(c.lvl, jsonLogger, defaultLogLevelValue) | |||
| if err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| buf.Reset() | |||
| logger.With("module", "mempool").With("module", "wire").Debug("Kingpin") | |||
| if have := strings.TrimSpace(buf.String()); c.expectedLogLines[0] != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'\nlevel '%s'", c.expectedLogLines[0], have, c.lvl) | |||
| } | |||
| buf.Reset() | |||
| logger.With("module", "mempool").Info("Kitty Pryde") | |||
| if have := strings.TrimSpace(buf.String()); c.expectedLogLines[1] != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'\nlevel '%s'", c.expectedLogLines[1], have, c.lvl) | |||
| } | |||
| buf.Reset() | |||
| logger.With("module", "mempool").Error("Mesmero") | |||
| if have := strings.TrimSpace(buf.String()); c.expectedLogLines[2] != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'\nlevel '%s'", c.expectedLogLines[2], have, c.lvl) | |||
| } | |||
| buf.Reset() | |||
| logger.With("module", "state").Info("Mind") | |||
| if have := strings.TrimSpace(buf.String()); c.expectedLogLines[3] != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'\nlevel '%s'", c.expectedLogLines[3], have, c.lvl) | |||
| } | |||
| buf.Reset() | |||
| logger.Debug("Gideon") | |||
| if have := strings.TrimSpace(buf.String()); c.expectedLogLines[4] != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'\nlevel '%s'", c.expectedLogLines[4], have, c.lvl) | |||
| } | |||
| } | |||
| incorrectLogLevel := []string{"some", "mempool:some", "*:some,mempool:error"} | |||
| for _, lvl := range incorrectLogLevel { | |||
| if _, err := tmflags.ParseLogLevel(lvl, jsonLogger, defaultLogLevelValue); err == nil { | |||
| t.Fatalf("Expected %s to produce error", lvl) | |||
| } | |||
| } | |||
| } | |||
+ 101
- 0
libs/log/default.go
View File
| @ -0,0 +1,101 @@ | |||
| package log | |||
| import ( | |||
| "fmt" | |||
| "io" | |||
| "os" | |||
| "strings" | |||
| "github.com/rs/zerolog" | |||
| ) | |||
| var _ Logger = (*defaultLogger)(nil) | |||
| type defaultLogger struct { | |||
| zerolog.Logger | |||
| trace bool | |||
| } | |||
| // NewDefaultLogger returns a default logger that can be used within Tendermint | |||
| // and that fulfills the Logger interface. The underlying logging provider is a | |||
| // zerolog logger that supports typical log levels along with JSON and plain/text | |||
| // log formats. | |||
| // | |||
| // Since zerolog supports typed structured logging and it is difficult to reflect | |||
| // that in a generic interface, all logging methods accept a series of key/value | |||
| // pair tuples, where the key must be a string. | |||
| func NewDefaultLogger(format, level string, trace bool) (Logger, error) { | |||
| var logWriter io.Writer | |||
| switch strings.ToLower(format) { | |||
| case LogFormatPlain, LogFormatText: | |||
| logWriter = zerolog.ConsoleWriter{Out: os.Stderr} | |||
| case LogFormatJSON: | |||
| logWriter = os.Stderr | |||
| default: | |||
| return nil, fmt.Errorf("unsupported log format: %s", format) | |||
| } | |||
| logLevel, err := zerolog.ParseLevel(level) | |||
| if err != nil { | |||
| return nil, fmt.Errorf("failed to parse log level (%s): %w", level, err) | |||
| } | |||
| // make the writer thread-safe | |||
| logWriter = newSyncWriter(logWriter) | |||
| return defaultLogger{ | |||
| Logger: zerolog.New(logWriter).Level(logLevel).With().Timestamp().Logger(), | |||
| trace: trace, | |||
| }, nil | |||
| } | |||
| // MustNewDefaultLogger delegates a call NewDefaultLogger where it panics on | |||
| // error. | |||
| func MustNewDefaultLogger(format, level string, trace bool) Logger { | |||
| logger, err := NewDefaultLogger(format, level, trace) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| return logger | |||
| } | |||
| func (l defaultLogger) Info(msg string, keyVals ...interface{}) { | |||
| l.Logger.Info().Fields(getLogFields(keyVals...)).Msg(msg) | |||
| } | |||
| func (l defaultLogger) Error(msg string, keyVals ...interface{}) { | |||
| e := l.Logger.Error() | |||
| if l.trace { | |||
| e = e.Stack() | |||
| } | |||
| e.Fields(getLogFields(keyVals...)).Msg(msg) | |||
| } | |||
| func (l defaultLogger) Debug(msg string, keyVals ...interface{}) { | |||
| l.Logger.Debug().Fields(getLogFields(keyVals...)).Msg(msg) | |||
| } | |||
| func (l defaultLogger) With(keyVals ...interface{}) Logger { | |||
| return defaultLogger{ | |||
| Logger: l.Logger.With().Fields(getLogFields(keyVals...)).Logger(), | |||
| trace: l.trace, | |||
| } | |||
| } | |||
| func getLogFields(keyVals ...interface{}) map[string]interface{} { | |||
| if len(keyVals)%2 != 0 { | |||
| return nil | |||
| } | |||
| fields := make(map[string]interface{}, len(keyVals)) | |||
| for i := 0; i < len(keyVals); i += 2 { | |||
| fields[fmt.Sprint(keyVals[i])] = keyVals[i+1] | |||
| } | |||
| return fields | |||
| } | |||
+ 48
- 0
libs/log/default_test.go
View File
| @ -0,0 +1,48 @@ | |||
| package log_test | |||
| import ( | |||
| "testing" | |||
| "github.com/stretchr/testify/require" | |||
| "github.com/tendermint/tendermint/libs/log" | |||
| ) | |||
| func TestNewDefaultLogger(t *testing.T) { | |||
| testCases := map[string]struct { | |||
| format string | |||
| level string | |||
| expectErr bool | |||
| }{ | |||
| "invalid format": { | |||
| format: "foo", | |||
| level: log.LogLevelInfo, | |||
| expectErr: true, | |||
| }, | |||
| "invalid level": { | |||
| format: log.LogFormatJSON, | |||
| level: "foo", | |||
| expectErr: true, | |||
| }, | |||
| "valid format and level": { | |||
| format: log.LogFormatJSON, | |||
| level: log.LogLevelInfo, | |||
| expectErr: false, | |||
| }, | |||
| } | |||
| for name, tc := range testCases { | |||
| tc := tc | |||
| t.Run(name, func(t *testing.T) { | |||
| _, err := log.NewDefaultLogger(tc.format, tc.level, false) | |||
| if tc.expectErr { | |||
| require.Error(t, err) | |||
| require.Panics(t, func() { | |||
| _ = log.MustNewDefaultLogger(tc.format, tc.level, false) | |||
| }) | |||
| } else { | |||
| require.NoError(t, err) | |||
| } | |||
| }) | |||
| } | |||
| } | |||
+ 0
- 195
libs/log/filter.go
View File
| @ -1,195 +0,0 @@ | |||
| package log | |||
| import "fmt" | |||
| type level byte | |||
| const ( | |||
| levelDebug level = 1 << iota | |||
| levelInfo | |||
| levelError | |||
| ) | |||
| type filter struct { | |||
| next Logger | |||
| allowed level // XOR'd levels for default case | |||
| initiallyAllowed level // XOR'd levels for initial case | |||
| allowedKeyvals map[keyval]level // When key-value match, use this level | |||
| } | |||
| type keyval struct { | |||
| key interface{} | |||
| value interface{} | |||
| } | |||
| // NewFilter wraps next and implements filtering. See the commentary on the | |||
| // Option functions for a detailed description of how to configure levels. If | |||
| // no options are provided, all leveled log events created with Debug, Info or | |||
| // Error helper methods are squelched. | |||
| func NewFilter(next Logger, options ...Option) Logger { | |||
| l := &filter{ | |||
| next: next, | |||
| allowedKeyvals: make(map[keyval]level), | |||
| } | |||
| for _, option := range options { | |||
| option(l) | |||
| } | |||
| l.initiallyAllowed = l.allowed | |||
| return l | |||
| } | |||
| func (l *filter) Info(msg string, keyvals ...interface{}) { | |||
| levelAllowed := l.allowed&levelInfo != 0 | |||
| if !levelAllowed { | |||
| return | |||
| } | |||
| l.next.Info(msg, keyvals...) | |||
| } | |||
| func (l *filter) Debug(msg string, keyvals ...interface{}) { | |||
| levelAllowed := l.allowed&levelDebug != 0 | |||
| if !levelAllowed { | |||
| return | |||
| } | |||
| l.next.Debug(msg, keyvals...) | |||
| } | |||
| func (l *filter) Error(msg string, keyvals ...interface{}) { | |||
| levelAllowed := l.allowed&levelError != 0 | |||
| if !levelAllowed { | |||
| return | |||
| } | |||
| l.next.Error(msg, keyvals...) | |||
| } | |||
| // With implements Logger by constructing a new filter with a keyvals appended | |||
| // to the logger. | |||
| // | |||
| // If custom level was set for a keyval pair using one of the | |||
| // Allow*With methods, it is used as the logger's level. | |||
| // | |||
| // Examples: | |||
| // logger = log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("module", "crypto")) | |||
| // logger.With("module", "crypto").Info("Hello") # produces "I... Hello module=crypto" | |||
| // | |||
| // logger = log.NewFilter(logger, log.AllowError(), | |||
| // log.AllowInfoWith("module", "crypto"), | |||
| // log.AllowNoneWith("user", "Sam")) | |||
| // logger.With("module", "crypto", "user", "Sam").Info("Hello") # returns nil | |||
| // | |||
| // logger = log.NewFilter(logger, | |||
| // log.AllowError(), | |||
| // log.AllowInfoWith("module", "crypto"), log.AllowNoneWith("user", "Sam")) | |||
| // logger.With("user", "Sam").With("module", "crypto").Info("Hello") # produces "I... Hello module=crypto user=Sam" | |||
| func (l *filter) With(keyvals ...interface{}) Logger { | |||
| keyInAllowedKeyvals := false | |||
| for i := len(keyvals) - 2; i >= 0; i -= 2 { | |||
| for kv, allowed := range l.allowedKeyvals { | |||
| if keyvals[i] == kv.key { | |||
| keyInAllowedKeyvals = true | |||
| // Example: | |||
| // logger = log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("module", "crypto")) | |||
| // logger.With("module", "crypto") | |||
| if keyvals[i+1] == kv.value { | |||
| return &filter{ | |||
| next: l.next.With(keyvals...), | |||
| allowed: allowed, // set the desired level | |||
| allowedKeyvals: l.allowedKeyvals, | |||
| initiallyAllowed: l.initiallyAllowed, | |||
| } | |||
| } | |||
| } | |||
| } | |||
| } | |||
| // Example: | |||
| // logger = log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("module", "crypto")) | |||
| // logger.With("module", "main") | |||
| if keyInAllowedKeyvals { | |||
| return &filter{ | |||
| next: l.next.With(keyvals...), | |||
| allowed: l.initiallyAllowed, // return back to initially allowed | |||
| allowedKeyvals: l.allowedKeyvals, | |||
| initiallyAllowed: l.initiallyAllowed, | |||
| } | |||
| } | |||
| return &filter{ | |||
| next: l.next.With(keyvals...), | |||
| allowed: l.allowed, // simply continue with the current level | |||
| allowedKeyvals: l.allowedKeyvals, | |||
| initiallyAllowed: l.initiallyAllowed, | |||
| } | |||
| } | |||
| //-------------------------------------------------------------------------------- | |||
| // Option sets a parameter for the filter. | |||
| type Option func(*filter) | |||
| // AllowLevel returns an option for the given level or error if no option exist | |||
| // for such level. | |||
| func AllowLevel(lvl string) (Option, error) { | |||
| switch lvl { | |||
| case "debug": | |||
| return AllowDebug(), nil | |||
| case "info": | |||
| return AllowInfo(), nil | |||
| case "error": | |||
| return AllowError(), nil | |||
| case "none": | |||
| return AllowNone(), nil | |||
| default: | |||
| return nil, fmt.Errorf("expected either \"info\", \"debug\", \"error\" or \"none\" level, given %s", lvl) | |||
| } | |||
| } | |||
| // AllowAll is an alias for AllowDebug. | |||
| func AllowAll() Option { | |||
| return AllowDebug() | |||
| } | |||
| // AllowDebug allows error, info and debug level log events to pass. | |||
| func AllowDebug() Option { | |||
| return allowed(levelError | levelInfo | levelDebug) | |||
| } | |||
| // AllowInfo allows error and info level log events to pass. | |||
| func AllowInfo() Option { | |||
| return allowed(levelError | levelInfo) | |||
| } | |||
| // AllowError allows only error level log events to pass. | |||
| func AllowError() Option { | |||
| return allowed(levelError) | |||
| } | |||
| // AllowNone allows no leveled log events to pass. | |||
| func AllowNone() Option { | |||
| return allowed(0) | |||
| } | |||
| func allowed(allowed level) Option { | |||
| return func(l *filter) { l.allowed = allowed } | |||
| } | |||
| // AllowDebugWith allows error, info and debug level log events to pass for a specific key value pair. | |||
| func AllowDebugWith(key interface{}, value interface{}) Option { | |||
| return func(l *filter) { l.allowedKeyvals[keyval{key, value}] = levelError | levelInfo | levelDebug } | |||
| } | |||
| // AllowInfoWith allows error and info level log events to pass for a specific key value pair. | |||
| func AllowInfoWith(key interface{}, value interface{}) Option { | |||
| return func(l *filter) { l.allowedKeyvals[keyval{key, value}] = levelError | levelInfo } | |||
| } | |||
| // AllowErrorWith allows only error level log events to pass for a specific key value pair. | |||
| func AllowErrorWith(key interface{}, value interface{}) Option { | |||
| return func(l *filter) { l.allowedKeyvals[keyval{key, value}] = levelError } | |||
| } | |||
| // AllowNoneWith allows no leveled log events to pass for a specific key value pair. | |||
| func AllowNoneWith(key interface{}, value interface{}) Option { | |||
| return func(l *filter) { l.allowedKeyvals[keyval{key, value}] = 0 } | |||
| } | |||
+ 0
- 140
libs/log/filter_test.go
View File
| @ -1,140 +0,0 @@ | |||
| package log_test | |||
| import ( | |||
| "bytes" | |||
| "strings" | |||
| "testing" | |||
| "github.com/tendermint/tendermint/libs/log" | |||
| ) | |||
| func TestVariousLevels(t *testing.T) { | |||
| testCases := []struct { | |||
| name string | |||
| allowed log.Option | |||
| want string | |||
| }{ | |||
| { | |||
| "AllowAll", | |||
| log.AllowAll(), | |||
| strings.Join([]string{ | |||
| `{"_msg":"here","level":"debug","this is":"debug log"}`, | |||
| `{"_msg":"here","level":"info","this is":"info log"}`, | |||
| `{"_msg":"here","level":"error","this is":"error log"}`, | |||
| }, "\n"), | |||
| }, | |||
| { | |||
| "AllowDebug", | |||
| log.AllowDebug(), | |||
| strings.Join([]string{ | |||
| `{"_msg":"here","level":"debug","this is":"debug log"}`, | |||
| `{"_msg":"here","level":"info","this is":"info log"}`, | |||
| `{"_msg":"here","level":"error","this is":"error log"}`, | |||
| }, "\n"), | |||
| }, | |||
| { | |||
| "AllowInfo", | |||
| log.AllowInfo(), | |||
| strings.Join([]string{ | |||
| `{"_msg":"here","level":"info","this is":"info log"}`, | |||
| `{"_msg":"here","level":"error","this is":"error log"}`, | |||
| }, "\n"), | |||
| }, | |||
| { | |||
| "AllowError", | |||
| log.AllowError(), | |||
| strings.Join([]string{ | |||
| `{"_msg":"here","level":"error","this is":"error log"}`, | |||
| }, "\n"), | |||
| }, | |||
| { | |||
| "AllowNone", | |||
| log.AllowNone(), | |||
| ``, | |||
| }, | |||
| } | |||
| for _, tc := range testCases { | |||
| tc := tc | |||
| t.Run(tc.name, func(t *testing.T) { | |||
| var buf bytes.Buffer | |||
| logger := log.NewFilter(log.NewTMJSONLoggerNoTS(&buf), tc.allowed) | |||
| logger.Debug("here", "this is", "debug log") | |||
| logger.Info("here", "this is", "info log") | |||
| logger.Error("here", "this is", "error log") | |||
| if want, have := tc.want, strings.TrimSpace(buf.String()); want != have { | |||
| t.Errorf("\nwant:\n%s\nhave:\n%s", want, have) | |||
| } | |||
| }) | |||
| } | |||
| } | |||
| func TestLevelContext(t *testing.T) { | |||
| var buf bytes.Buffer | |||
| logger := log.NewTMJSONLoggerNoTS(&buf) | |||
| logger = log.NewFilter(logger, log.AllowError()) | |||
| logger = logger.With("context", "value") | |||
| logger.Error("foo", "bar", "baz") | |||
| want := `{"_msg":"foo","bar":"baz","context":"value","level":"error"}` | |||
| have := strings.TrimSpace(buf.String()) | |||
| if want != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'", want, have) | |||
| } | |||
| buf.Reset() | |||
| logger.Info("foo", "bar", "baz") | |||
| if want, have := ``, strings.TrimSpace(buf.String()); want != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'", want, have) | |||
| } | |||
| } | |||
| func TestVariousAllowWith(t *testing.T) { | |||
| var buf bytes.Buffer | |||
| logger := log.NewTMJSONLoggerNoTS(&buf) | |||
| logger1 := log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("context", "value")) | |||
| logger1.With("context", "value").Info("foo", "bar", "baz") | |||
| want := `{"_msg":"foo","bar":"baz","context":"value","level":"info"}` | |||
| have := strings.TrimSpace(buf.String()) | |||
| if want != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'", want, have) | |||
| } | |||
| buf.Reset() | |||
| logger2 := log.NewFilter( | |||
| logger, | |||
| log.AllowError(), | |||
| log.AllowInfoWith("context", "value"), | |||
| log.AllowNoneWith("user", "Sam"), | |||
| ) | |||
| logger2.With("context", "value", "user", "Sam").Info("foo", "bar", "baz") | |||
| if want, have := ``, strings.TrimSpace(buf.String()); want != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'", want, have) | |||
| } | |||
| buf.Reset() | |||
| logger3 := log.NewFilter( | |||
| logger, | |||
| log.AllowError(), | |||
| log.AllowInfoWith("context", "value"), | |||
| log.AllowNoneWith("user", "Sam"), | |||
| ) | |||
| logger3.With("user", "Sam").With("context", "value").Info("foo", "bar", "baz") | |||
| want = `{"_msg":"foo","bar":"baz","context":"value","level":"info","user":"Sam"}` | |||
| have = strings.TrimSpace(buf.String()) | |||
| if want != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'", want, have) | |||
| } | |||
| } | |||
+ 45
- 18
libs/log/logger.go
View File
+ 12
- 0
libs/log/nop.go
View File
| @ -0,0 +1,12 @@ | |||
| package log | |||
| import ( | |||
| "github.com/rs/zerolog" | |||
| ) | |||
| func NewNopLogger() Logger { | |||
| return defaultLogger{ | |||
| Logger: zerolog.Nop(), | |||
| trace: false, | |||
| } | |||
| } | |||
+ 0
- 17
libs/log/nop_logger.go
View File
| @ -1,17 +0,0 @@ | |||
| package log | |||
| type nopLogger struct{} | |||
| // Interface assertions | |||
| var _ Logger = (*nopLogger)(nil) | |||
| // NewNopLogger returns a logger that doesn't do anything. | |||
| func NewNopLogger() Logger { return &nopLogger{} } | |||
| func (nopLogger) Info(string, ...interface{}) {} | |||
| func (nopLogger) Debug(string, ...interface{}) {} | |||
| func (nopLogger) Error(string, ...interface{}) {} | |||
| func (l *nopLogger) With(...interface{}) Logger { | |||
| return l | |||
| } | |||
+ 41
- 0
libs/log/testing.go
View File
| @ -0,0 +1,41 @@ | |||
| package log | |||
| import ( | |||
| "io" | |||
| "os" | |||
| "sync" | |||
| "testing" | |||
| ) | |||
| var ( | |||
| // reuse the same logger across all tests | |||
| testingLoggerMtx = sync.Mutex{} | |||
| testingLogger Logger | |||
| ) | |||
| // TestingLogger returns a Logger which writes to STDOUT if test(s) are being | |||
| // run with the verbose (-v) flag, NopLogger otherwise. | |||
| // | |||
| // NOTE: | |||
| // - A call to NewTestingLogger() must be made inside a test (not in the init func) | |||
| // because verbose flag only set at the time of testing. | |||
| func TestingLogger() Logger { | |||
| return TestingLoggerWithOutput(os.Stdout) | |||
| } | |||
| func TestingLoggerWithOutput(w io.Writer) Logger { | |||
| testingLoggerMtx.Lock() | |||
| defer testingLoggerMtx.Unlock() | |||
| if testingLogger != nil { | |||
| return testingLogger | |||
| } | |||
| if testing.Verbose() { | |||
| testingLogger = MustNewDefaultLogger(LogFormatText, LogLevelDebug, true) | |||
| } else { | |||
| testingLogger = NewNopLogger() | |||
| } | |||
| return testingLogger | |||
| } | |||
+ 0
- 66
libs/log/testing_logger.go
View File
| @ -1,66 +0,0 @@ | |||
| package log | |||
| import ( | |||
| "io" | |||
| "os" | |||
| "sync" | |||
| "testing" | |||
| "github.com/go-kit/kit/log/term" | |||
| ) | |||
| var ( | |||
| // reuse the same logger across all tests | |||
| _testingLoggerMutex = sync.Mutex{} | |||
| _testingLogger Logger | |||
| ) | |||
| // TestingLogger returns a TMLogger which writes to STDOUT if testing being run | |||
| // with the verbose (-v) flag, NopLogger otherwise. | |||
| // | |||
| // Note that the call to TestingLogger() must be made | |||
| // inside a test (not in the init func) because | |||
| // verbose flag only set at the time of testing. | |||
| func TestingLogger() Logger { | |||
| return TestingLoggerWithOutput(os.Stdout) | |||
| } | |||
| // TestingLoggerWOutput returns a TMLogger which writes to (w io.Writer) if testing being run | |||
| // with the verbose (-v) flag, NopLogger otherwise. | |||
| // | |||
| // Note that the call to TestingLoggerWithOutput(w io.Writer) must be made | |||
| // inside a test (not in the init func) because | |||
| // verbose flag only set at the time of testing. | |||
| func TestingLoggerWithOutput(w io.Writer) Logger { | |||
| _testingLoggerMutex.Lock() | |||
| defer _testingLoggerMutex.Unlock() | |||
| if _testingLogger != nil { | |||
| return _testingLogger | |||
| } | |||
| if testing.Verbose() { | |||
| _testingLogger = NewTMLogger(NewSyncWriter(w)) | |||
| } else { | |||
| _testingLogger = NewNopLogger() | |||
| } | |||
| return _testingLogger | |||
| } | |||
| // TestingLoggerWithColorFn allow you to provide your own color function. See | |||
| // TestingLogger for documentation. | |||
| func TestingLoggerWithColorFn(colorFn func(keyvals ...interface{}) term.FgBgColor) Logger { | |||
| _testingLoggerMutex.Lock() | |||
| defer _testingLoggerMutex.Unlock() | |||
| if _testingLogger != nil { | |||
| return _testingLogger | |||
| } | |||
| if testing.Verbose() { | |||
| _testingLogger = NewTMLoggerWithColorFn(NewSyncWriter(os.Stdout), colorFn) | |||
| } else { | |||
| _testingLogger = NewNopLogger() | |||
| } | |||
| return _testingLogger | |||
| } | |||
+ 0
- 24
libs/log/tm_json_logger.go
View File
| @ -1,24 +0,0 @@ | |||
| package log | |||
| import ( | |||
| "io" | |||
| kitlog "github.com/go-kit/kit/log" | |||
| ) | |||
| // NewTMJSONLogger returns a Logger that encodes keyvals to the Writer as a | |||
| // single JSON object. Each log event produces no more than one call to | |||
| // w.Write. The passed Writer must be safe for concurrent use by multiple | |||
| // goroutines if the returned Logger will be used concurrently. | |||
| func NewTMJSONLogger(w io.Writer) Logger { | |||
| logger := kitlog.NewJSONLogger(w) | |||
| logger = kitlog.With(logger, "ts", kitlog.DefaultTimestampUTC) | |||
| return &tmLogger{logger} | |||
| } | |||
| // NewTMJSONLoggerNoTS is the same as NewTMJSONLogger, but without the | |||
| // timestamp. | |||
| func NewTMJSONLoggerNoTS(w io.Writer) Logger { | |||
| logger := kitlog.NewJSONLogger(w) | |||
| return &tmLogger{logger} | |||
| } | |||
+ 0
- 86
libs/log/tm_logger.go
View File
| @ -1,86 +0,0 @@ | |||
| package log | |||
| import ( | |||
| "fmt" | |||
| "io" | |||
| kitlog "github.com/go-kit/kit/log" | |||
| kitlevel "github.com/go-kit/kit/log/level" | |||
| "github.com/go-kit/kit/log/term" | |||
| ) | |||
| const ( | |||
| msgKey = "_msg" // "_" prefixed to avoid collisions | |||
| moduleKey = "module" | |||
| ) | |||
| type tmLogger struct { | |||
| srcLogger kitlog.Logger | |||
| } | |||
| // Interface assertions | |||
| var _ Logger = (*tmLogger)(nil) | |||
| // NewTMLogger returns a logger that encodes msg and keyvals to the Writer | |||
| // using go-kit's log as an underlying logger and our custom formatter. Note | |||
| // that underlying logger could be swapped with something else. | |||
| func NewTMLogger(w io.Writer) Logger { | |||
| // Color by level value | |||
| colorFn := func(keyvals ...interface{}) term.FgBgColor { | |||
| if keyvals[0] != kitlevel.Key() { | |||
| panic(fmt.Sprintf("expected level key to be first, got %v", keyvals[0])) | |||
| } | |||
| switch keyvals[1].(kitlevel.Value).String() { | |||
| case "debug": | |||
| return term.FgBgColor{Fg: term.DarkGray} | |||
| case "error": | |||
| return term.FgBgColor{Fg: term.Red} | |||
| default: | |||
| return term.FgBgColor{} | |||
| } | |||
| } | |||
| return &tmLogger{term.NewLogger(w, NewTMFmtLogger, colorFn)} | |||
| } | |||
| // NewTMLoggerWithColorFn allows you to provide your own color function. See | |||
| // NewTMLogger for documentation. | |||
| func NewTMLoggerWithColorFn(w io.Writer, colorFn func(keyvals ...interface{}) term.FgBgColor) Logger { | |||
| return &tmLogger{term.NewLogger(w, NewTMFmtLogger, colorFn)} | |||
| } | |||
| // Info logs a message at level Info. | |||
| func (l *tmLogger) Info(msg string, keyvals ...interface{}) { | |||
| lWithLevel := kitlevel.Info(l.srcLogger) | |||
| if err := kitlog.With(lWithLevel, msgKey, msg).Log(keyvals...); err != nil { | |||
| errLogger := kitlevel.Error(l.srcLogger) | |||
| kitlog.With(errLogger, msgKey, msg).Log("err", err) //nolint:errcheck // no need to check error again | |||
| } | |||
| } | |||
| // Debug logs a message at level Debug. | |||
| func (l *tmLogger) Debug(msg string, keyvals ...interface{}) { | |||
| lWithLevel := kitlevel.Debug(l.srcLogger) | |||
| if err := kitlog.With(lWithLevel, msgKey, msg).Log(keyvals...); err != nil { | |||
| errLogger := kitlevel.Error(l.srcLogger) | |||
| kitlog.With(errLogger, msgKey, msg).Log("err", err) //nolint:errcheck // no need to check error again | |||
| } | |||
| } | |||
| // Error logs a message at level Error. | |||
| func (l *tmLogger) Error(msg string, keyvals ...interface{}) { | |||
| lWithLevel := kitlevel.Error(l.srcLogger) | |||
| lWithMsg := kitlog.With(lWithLevel, msgKey, msg) | |||
| if err := lWithMsg.Log(keyvals...); err != nil { | |||
| lWithMsg.Log("err", err) //nolint:errcheck // no need to check error again | |||
| } | |||
| } | |||
| // With returns a new contextual logger with keyvals prepended to those passed | |||
| // to calls to Info, Debug or Error. | |||
| func (l *tmLogger) With(keyvals ...interface{}) Logger { | |||
| return &tmLogger{kitlog.With(l.srcLogger, keyvals...)} | |||
| } | |||
+ 0
- 112
libs/log/tm_logger_test.go
View File
| @ -1,112 +0,0 @@ | |||
| package log_test | |||
| import ( | |||
| "bytes" | |||
| "io/ioutil" | |||
| "strings" | |||
| "testing" | |||
| "github.com/tendermint/tendermint/libs/log" | |||
| ) | |||
| func TestLoggerLogsItsErrors(t *testing.T) { | |||
| var buf bytes.Buffer | |||
| logger := log.NewTMLogger(&buf) | |||
| logger.Info("foo", "baz baz", "bar") | |||
| msg := strings.TrimSpace(buf.String()) | |||
| if !strings.Contains(msg, "foo") { | |||
| t.Errorf("expected logger msg to contain ErrInvalidKey, got %s", msg) | |||
| } | |||
| } | |||
| func TestInfo(t *testing.T) { | |||
| var bufInfo bytes.Buffer | |||
| l := log.NewTMLogger(&bufInfo) | |||
| l.Info("Client initialized with old header (trusted is more recent)", | |||
| "old", 42, | |||
| "trustedHeight", "forty two", | |||
| "trustedHash", []byte("test me")) | |||
| msg := strings.TrimSpace(bufInfo.String()) | |||
| // Remove the timestamp information to allow | |||
| // us to test against the expected message. | |||
| receivedmsg := strings.Split(msg, "] ")[1] | |||
| const expectedmsg = `Client initialized with old header | |||
| (trusted is more recent) old=42 trustedHeight="forty two" | |||
| trustedHash=74657374206D65` | |||
| if strings.EqualFold(receivedmsg, expectedmsg) { | |||
| t.Fatalf("received %s, expected %s", receivedmsg, expectedmsg) | |||
| } | |||
| } | |||
| func TestDebug(t *testing.T) { | |||
| var bufDebug bytes.Buffer | |||
| ld := log.NewTMLogger(&bufDebug) | |||
| ld.Debug("Client initialized with old header (trusted is more recent)", | |||
| "old", 42, | |||
| "trustedHeight", "forty two", | |||
| "trustedHash", []byte("test me")) | |||
| msg := strings.TrimSpace(bufDebug.String()) | |||
| // Remove the timestamp information to allow | |||
| // us to test against the expected message. | |||
| receivedmsg := strings.Split(msg, "] ")[1] | |||
| const expectedmsg = `Client initialized with old header | |||
| (trusted is more recent) old=42 trustedHeight="forty two" | |||
| trustedHash=74657374206D65` | |||
| if strings.EqualFold(receivedmsg, expectedmsg) { | |||
| t.Fatalf("received %s, expected %s", receivedmsg, expectedmsg) | |||
| } | |||
| } | |||
| func TestError(t *testing.T) { | |||
| var bufErr bytes.Buffer | |||
| le := log.NewTMLogger(&bufErr) | |||
| le.Error("Client initialized with old header (trusted is more recent)", | |||
| "old", 42, | |||
| "trustedHeight", "forty two", | |||
| "trustedHash", []byte("test me")) | |||
| msg := strings.TrimSpace(bufErr.String()) | |||
| // Remove the timestamp information to allow | |||
| // us to test against the expected message. | |||
| receivedmsg := strings.Split(msg, "] ")[1] | |||
| const expectedmsg = `Client initialized with old header | |||
| (trusted is more recent) old=42 trustedHeight="forty two" | |||
| trustedHash=74657374206D65` | |||
| if strings.EqualFold(receivedmsg, expectedmsg) { | |||
| t.Fatalf("received %s, expected %s", receivedmsg, expectedmsg) | |||
| } | |||
| } | |||
| func BenchmarkTMLoggerSimple(b *testing.B) { | |||
| benchmarkRunner(b, log.NewTMLogger(ioutil.Discard), baseInfoMessage) | |||
| } | |||
| func BenchmarkTMLoggerContextual(b *testing.B) { | |||
| benchmarkRunner(b, log.NewTMLogger(ioutil.Discard), withInfoMessage) | |||
| } | |||
| func benchmarkRunner(b *testing.B, logger log.Logger, f func(log.Logger)) { | |||
| lc := logger.With("common_key", "common_value") | |||
| b.ReportAllocs() | |||
| b.ResetTimer() | |||
| for i := 0; i < b.N; i++ { | |||
| f(lc) | |||
| } | |||
| } | |||
| var ( | |||
| baseInfoMessage = func(logger log.Logger) { logger.Info("foo_message", "foo_key", "foo_value") } | |||
| withInfoMessage = func(logger log.Logger) { logger.With("a", "b").Info("c", "d", "f") } | |||
| ) | |||
+ 0
- 135
libs/log/tmfmt_logger.go
View File
| @ -1,135 +0,0 @@ | |||
| package log | |||
| import ( | |||
| "bytes" | |||
| "encoding/hex" | |||
| "fmt" | |||
| "io" | |||
| "strings" | |||
| "sync" | |||
| "time" | |||
| kitlog "github.com/go-kit/kit/log" | |||
| kitlevel "github.com/go-kit/kit/log/level" | |||
| "github.com/go-logfmt/logfmt" | |||
| ) | |||
| type tmfmtEncoder struct { | |||
| *logfmt.Encoder | |||
| buf bytes.Buffer | |||
| } | |||
| func (l *tmfmtEncoder) Reset() { | |||
| l.Encoder.Reset() | |||
| l.buf.Reset() | |||
| } | |||
| var tmfmtEncoderPool = sync.Pool{ | |||
| New: func() interface{} { | |||
| var enc tmfmtEncoder | |||
| enc.Encoder = logfmt.NewEncoder(&enc.buf) | |||
| return &enc | |||
| }, | |||
| } | |||
| type tmfmtLogger struct { | |||
| w io.Writer | |||
| } | |||
| // NewTMFmtLogger returns a logger that encodes keyvals to the Writer in | |||
| // Tendermint custom format. Note complex types (structs, maps, slices) | |||
| // formatted as "%+v". | |||
| // | |||
| // Each log event produces no more than one call to w.Write. | |||
| // The passed Writer must be safe for concurrent use by multiple goroutines if | |||
| // the returned Logger will be used concurrently. | |||
| func NewTMFmtLogger(w io.Writer) kitlog.Logger { | |||
| return &tmfmtLogger{w} | |||
| } | |||
| func (l tmfmtLogger) Log(keyvals ...interface{}) error { | |||
| enc := tmfmtEncoderPool.Get().(*tmfmtEncoder) | |||
| enc.Reset() | |||
| defer tmfmtEncoderPool.Put(enc) | |||
| const unknown = "unknown" | |||
| lvl := "none" | |||
| msg := unknown | |||
| module := unknown | |||
| // indexes of keys to skip while encoding later | |||
| excludeIndexes := make([]int, 0) | |||
| for i := 0; i < len(keyvals)-1; i += 2 { | |||
| // Extract level | |||
| switch keyvals[i] { | |||
| case kitlevel.Key(): | |||
| excludeIndexes = append(excludeIndexes, i) | |||
| switch keyvals[i+1].(type) { // nolint:gocritic | |||
| case string: | |||
| lvl = keyvals[i+1].(string) | |||
| case kitlevel.Value: | |||
| lvl = keyvals[i+1].(kitlevel.Value).String() | |||
| default: | |||
| panic(fmt.Sprintf("level value of unknown type %T", keyvals[i+1])) | |||
| } | |||
| // and message | |||
| case msgKey: | |||
| excludeIndexes = append(excludeIndexes, i) | |||
| msg = keyvals[i+1].(string) | |||
| // and module (could be multiple keyvals; if such case last keyvalue wins) | |||
| case moduleKey: | |||
| excludeIndexes = append(excludeIndexes, i) | |||
| module = keyvals[i+1].(string) | |||
| } | |||
| // Print []byte as a hexadecimal string (uppercased) | |||
| if b, ok := keyvals[i+1].([]byte); ok { | |||
| keyvals[i+1] = strings.ToUpper(hex.EncodeToString(b)) | |||
| } | |||
| } | |||
| // Form a custom Tendermint line | |||
| // | |||
| // Example: | |||
| // D[2016-05-02|11:06:44.322] Stopping AddrBook (ignoring: already stopped) | |||
| // | |||
| // Description: | |||
| // D - first character of the level, uppercase (ASCII only) | |||
| // [2016-05-02|11:06:44.322] - our time format (see https://golang.org/src/time/format.go) | |||
| // Stopping ... - message | |||
| fmt.Fprintf(&enc.buf, "%c[%s] %-44s ", lvl[0]-32, time.Now().Format("2006-01-02|15:04:05.000"), msg) | |||
| if module != unknown { | |||
| enc.buf.WriteString("module=" + module + " ") | |||
| } | |||
| KeyvalueLoop: | |||
| for i := 0; i < len(keyvals)-1; i += 2 { | |||
| for _, j := range excludeIndexes { | |||
| if i == j { | |||
| continue KeyvalueLoop | |||
| } | |||
| } | |||
| err := enc.EncodeKeyval(keyvals[i], keyvals[i+1]) | |||
| if err == logfmt.ErrUnsupportedValueType { | |||
| enc.EncodeKeyval(keyvals[i], fmt.Sprintf("%+v", keyvals[i+1])) //nolint:errcheck // no need to check error again | |||
| } else if err != nil { | |||
| return err | |||
| } | |||
| } | |||
| // Add newline to the end of the buffer | |||
| if err := enc.EndRecord(); err != nil { | |||
| return err | |||
| } | |||
| // The Logger interface requires implementations to be safe for concurrent | |||
| // use by multiple goroutines. For this implementation that means making | |||
| // only one call to l.w.Write() for each call to Log. | |||
| if _, err := l.w.Write(enc.buf.Bytes()); err != nil { | |||
| return err | |||
| } | |||
| return nil | |||
| } | |||
+ 0
- 126
libs/log/tmfmt_logger_test.go
View File
| @ -1,126 +0,0 @@ | |||
| package log_test | |||
| import ( | |||
| "bytes" | |||
| "errors" | |||
| "io/ioutil" | |||
| "math" | |||
| "regexp" | |||
| "testing" | |||
| kitlog "github.com/go-kit/kit/log" | |||
| "github.com/stretchr/testify/assert" | |||
| "github.com/tendermint/tendermint/libs/log" | |||
| ) | |||
| func TestTMFmtLogger(t *testing.T) { | |||
| t.Parallel() | |||
| buf := &bytes.Buffer{} | |||
| logger := log.NewTMFmtLogger(buf) | |||
| if err := logger.Log("hello", "world"); err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| assert.Regexp(t, regexp.MustCompile(`N\[.+\] unknown \s+ hello=world\n$`), buf.String()) | |||
| buf.Reset() | |||
| if err := logger.Log("a", 1, "err", errors.New("error")); err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| assert.Regexp(t, regexp.MustCompile(`N\[.+\] unknown \s+ a=1 err=error\n$`), buf.String()) | |||
| buf.Reset() | |||
| if err := logger.Log("std_map", map[int]int{1: 2}, "my_map", mymap{0: 0}); err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| assert.Regexp(t, regexp.MustCompile(`N\[.+\] unknown \s+ std_map=map\[1:2\] my_map=special_behavior\n$`), buf.String()) | |||
| buf.Reset() | |||
| if err := logger.Log("level", "error"); err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| assert.Regexp(t, regexp.MustCompile(`E\[.+\] unknown \s+\n$`), buf.String()) | |||
| buf.Reset() | |||
| if err := logger.Log("_msg", "Hello"); err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| assert.Regexp(t, regexp.MustCompile(`N\[.+\] Hello \s+\n$`), buf.String()) | |||
| buf.Reset() | |||
| if err := logger.Log("module", "main", "module", "crypto", "module", "wire"); err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| assert.Regexp(t, regexp.MustCompile(`N\[.+\] unknown \s+module=wire\s+\n$`), buf.String()) | |||
| buf.Reset() | |||
| if err := logger.Log("hash", []byte("test me")); err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| assert.Regexp(t, regexp.MustCompile(`N\[.+\] unknown \s+ hash=74657374206D65\n$`), buf.String()) | |||
| } | |||
| func BenchmarkTMFmtLoggerSimple(b *testing.B) { | |||
| benchmarkRunnerKitlog(b, log.NewTMFmtLogger(ioutil.Discard), baseMessage) | |||
| } | |||
| func BenchmarkTMFmtLoggerContextual(b *testing.B) { | |||
| benchmarkRunnerKitlog(b, log.NewTMFmtLogger(ioutil.Discard), withMessage) | |||
| } | |||
| func TestTMFmtLoggerConcurrency(t *testing.T) { | |||
| t.Parallel() | |||
| testConcurrency(t, log.NewTMFmtLogger(ioutil.Discard), 10000) | |||
| } | |||
| func benchmarkRunnerKitlog(b *testing.B, logger kitlog.Logger, f func(kitlog.Logger)) { | |||
| lc := kitlog.With(logger, "common_key", "common_value") | |||
| b.ReportAllocs() | |||
| b.ResetTimer() | |||
| for i := 0; i < b.N; i++ { | |||
| f(lc) | |||
| } | |||
| } | |||
| //nolint: errcheck // ignore errors | |||
| var ( | |||
| baseMessage = func(logger kitlog.Logger) { logger.Log("foo_key", "foo_value") } | |||
| withMessage = func(logger kitlog.Logger) { kitlog.With(logger, "a", "b").Log("d", "f") } | |||
| ) | |||
| // These test are designed to be run with the race detector. | |||
| func testConcurrency(t *testing.T, logger kitlog.Logger, total int) { | |||
| n := int(math.Sqrt(float64(total))) | |||
| share := total / n | |||
| errC := make(chan error, n) | |||
| for i := 0; i < n; i++ { | |||
| go func() { | |||
| errC <- spam(logger, share) | |||
| }() | |||
| } | |||
| for i := 0; i < n; i++ { | |||
| err := <-errC | |||
| if err != nil { | |||
| t.Fatalf("concurrent logging error: %v", err) | |||
| } | |||
| } | |||
| } | |||
| func spam(logger kitlog.Logger, count int) error { | |||
| for i := 0; i < count; i++ { | |||
| err := logger.Log("key", i) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| } | |||
| return nil | |||
| } | |||
| type mymap map[int]int | |||
| func (m mymap) String() string { return "special_behavior" } | |||
+ 0
- 76
libs/log/tracing_logger.go
View File
| @ -1,76 +0,0 @@ | |||
| package log | |||
| import ( | |||
| "fmt" | |||
| "github.com/pkg/errors" | |||
| ) | |||
| // NewTracingLogger enables tracing by wrapping all errors (if they | |||
| // implement stackTracer interface) in tracedError. | |||
| // | |||
| // All errors returned by https://github.com/pkg/errors implement stackTracer | |||
| // interface. | |||
| // | |||
| // For debugging purposes only as it doubles the amount of allocations. | |||
| func NewTracingLogger(next Logger) Logger { | |||
| return &tracingLogger{ | |||
| next: next, | |||
| } | |||
| } | |||
| type stackTracer interface { | |||
| error | |||
| StackTrace() errors.StackTrace | |||
| } | |||
| type tracingLogger struct { | |||
| next Logger | |||
| } | |||
| func (l *tracingLogger) Info(msg string, keyvals ...interface{}) { | |||
| l.next.Info(msg, formatErrors(keyvals)...) | |||
| } | |||
| func (l *tracingLogger) Debug(msg string, keyvals ...interface{}) { | |||
| l.next.Debug(msg, formatErrors(keyvals)...) | |||
| } | |||
| func (l *tracingLogger) Error(msg string, keyvals ...interface{}) { | |||
| l.next.Error(msg, formatErrors(keyvals)...) | |||
| } | |||
| func (l *tracingLogger) With(keyvals ...interface{}) Logger { | |||
| return &tracingLogger{next: l.next.With(formatErrors(keyvals)...)} | |||
| } | |||
| func formatErrors(keyvals []interface{}) []interface{} { | |||
| newKeyvals := make([]interface{}, len(keyvals)) | |||
| copy(newKeyvals, keyvals) | |||
| for i := 0; i < len(newKeyvals)-1; i += 2 { | |||
| if err, ok := newKeyvals[i+1].(stackTracer); ok { | |||
| newKeyvals[i+1] = tracedError{err} | |||
| } | |||
| } | |||
| return newKeyvals | |||
| } | |||
| // tracedError wraps a stackTracer and just makes the Error() result | |||
| // always return a full stack trace. | |||
| type tracedError struct { | |||
| wrapped stackTracer | |||
| } | |||
| var _ stackTracer = tracedError{} | |||
| func (t tracedError) StackTrace() errors.StackTrace { | |||
| return t.wrapped.StackTrace() | |||
| } | |||
| func (t tracedError) Cause() error { | |||
| return t.wrapped | |||
| } | |||
| func (t tracedError) Error() string { | |||
| return fmt.Sprintf("%+v", t.wrapped) | |||
| } | |||
+ 0
- 65
libs/log/tracing_logger_test.go
View File
| @ -1,65 +0,0 @@ | |||
| package log_test | |||
| import ( | |||
| "bytes" | |||
| stderr "errors" | |||
| "fmt" | |||
| "strings" | |||
| "testing" | |||
| "github.com/pkg/errors" | |||
| "github.com/tendermint/tendermint/libs/log" | |||
| ) | |||
| func TestTracingLogger(t *testing.T) { | |||
| var buf bytes.Buffer | |||
| logger := log.NewTMJSONLoggerNoTS(&buf) | |||
| logger1 := log.NewTracingLogger(logger) | |||
| err1 := errors.New("courage is grace under pressure") | |||
| err2 := errors.New("it does not matter how slowly you go, so long as you do not stop") | |||
| logger1.With("err1", err1).Info("foo", "err2", err2) | |||
| want := strings.ReplaceAll( | |||
| strings.ReplaceAll( | |||
| `{"_msg":"foo","err1":"`+ | |||
| fmt.Sprintf("%+v", err1)+ | |||
| `","err2":"`+ | |||
| fmt.Sprintf("%+v", err2)+ | |||
| `","level":"info"}`, | |||
| "\t", "", | |||
| ), "\n", "") | |||
| have := strings.ReplaceAll(strings.ReplaceAll(strings.TrimSpace(buf.String()), "\\n", ""), "\\t", "") | |||
| if want != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'", want, have) | |||
| } | |||
| buf.Reset() | |||
| logger.With( | |||
| "err1", stderr.New("opportunities don't happen. You create them"), | |||
| ).Info( | |||
| "foo", "err2", stderr.New("once you choose hope, anything's possible"), | |||
| ) | |||
| want = `{"_msg":"foo",` + | |||
| `"err1":"opportunities don't happen. You create them",` + | |||
| `"err2":"once you choose hope, anything's possible",` + | |||
| `"level":"info"}` | |||
| have = strings.TrimSpace(buf.String()) | |||
| if want != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'", want, have) | |||
| } | |||
| buf.Reset() | |||
| logger.With("user", "Sam").With("context", "value").Info("foo", "bar", "baz") | |||
| want = `{"_msg":"foo","bar":"baz","context":"value","level":"info","user":"Sam"}` | |||
| have = strings.TrimSpace(buf.String()) | |||
| if want != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'", want, have) | |||
| } | |||
| } | |||