Ethan Buchman
8 years ago
committed by
GitHub
GitHub
19 changed files with 722 additions and 71 deletions
Split View
Diff Options
-
+1 -2.gitignore
-
+2 -4Makefile
-
+27 -29common/service.go
-
+1 -1events/events.go
-
+0 -7events/log.go
-
+20 -20glide.lock
-
+12 -3glide.yaml
-
+97 -0log/filter.go
-
+103 -0log/filter_test.go
-
+30 -0log/logger.go
-
+25 -0log/nop_logger.go
-
+18 -0log/nop_logger_test.go
-
+31 -0log/testing_logger.go
-
+15 -0log/tm_json_logger.go
-
+67 -0log/tm_logger.go
-
+41 -0log/tm_logger_test.go
-
+116 -0log/tmfmt_logger.go
-
+110 -0log/tmfmt_logger_test.go
-
+6 -5logger/log.go
+ 1
- 2
.gitignore
View File
| @ -1,3 +1,2 @@ | |||
| *.swp | |||
| *.swo | |||
| vendor | |||
| .glide | |||
+ 2
- 4
Makefile
View File
+ 27
- 29
common/service.go
View File
+ 1
- 1
events/events.go
View File
+ 0
- 7
events/log.go
View File
| @ -1,7 +0,0 @@ | |||
| package events | |||
| import ( | |||
| "github.com/tendermint/tmlibs/logger" | |||
| ) | |||
| var log = logger.New("module", "events") | |||
+ 20
- 20
glide.lock
View File
+ 12
- 3
glide.yaml
View File
+ 97
- 0
log/filter.go
View File
| @ -0,0 +1,97 @@ | |||
| package log | |||
| // 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, | |||
| } | |||
| for _, option := range options { | |||
| option(l) | |||
| } | |||
| return l | |||
| } | |||
| type filter struct { | |||
| next Logger | |||
| allowed level | |||
| errNotAllowed error | |||
| } | |||
| func (l *filter) Info(msg string, keyvals ...interface{}) error { | |||
| levelAllowed := l.allowed&levelInfo != 0 | |||
| if !levelAllowed { | |||
| return l.errNotAllowed | |||
| } | |||
| return l.next.Info(msg, keyvals...) | |||
| } | |||
| func (l *filter) Debug(msg string, keyvals ...interface{}) error { | |||
| levelAllowed := l.allowed&levelDebug != 0 | |||
| if !levelAllowed { | |||
| return l.errNotAllowed | |||
| } | |||
| return l.next.Debug(msg, keyvals...) | |||
| } | |||
| func (l *filter) Error(msg string, keyvals ...interface{}) error { | |||
| levelAllowed := l.allowed&levelError != 0 | |||
| if !levelAllowed { | |||
| return l.errNotAllowed | |||
| } | |||
| return l.next.Error(msg, keyvals...) | |||
| } | |||
| func (l *filter) With(keyvals ...interface{}) Logger { | |||
| return l.next.With(keyvals...) | |||
| } | |||
| // Option sets a parameter for the filter. | |||
| type Option func(*filter) | |||
| // 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 } | |||
| } | |||
| // ErrNotAllowed sets the error to return from Log when it squelches a log | |||
| // event disallowed by the configured Allow[Level] option. By default, | |||
| // ErrNotAllowed is nil; in this case the log event is squelched with no | |||
| // error. | |||
| func ErrNotAllowed(err error) Option { | |||
| return func(l *filter) { l.errNotAllowed = err } | |||
| } | |||
| type level byte | |||
| const ( | |||
| levelDebug level = 1 << iota | |||
| levelInfo | |||
| levelError | |||
| ) | |||
+ 103
- 0
log/filter_test.go
View File
| @ -0,0 +1,103 @@ | |||
| package log_test | |||
| import ( | |||
| "bytes" | |||
| "errors" | |||
| "strings" | |||
| "testing" | |||
| "github.com/tendermint/tmlibs/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 { | |||
| t.Run(tc.name, func(t *testing.T) { | |||
| var buf bytes.Buffer | |||
| logger := log.NewFilter(log.NewTMJSONLogger(&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 TestErrNotAllowed(t *testing.T) { | |||
| myError := errors.New("squelched!") | |||
| opts := []log.Option{ | |||
| log.AllowError(), | |||
| log.ErrNotAllowed(myError), | |||
| } | |||
| logger := log.NewFilter(log.NewNopLogger(), opts...) | |||
| if want, have := myError, logger.Info("foo", "bar", "baz"); want != have { | |||
| t.Errorf("want %#+v, have %#+v", want, have) | |||
| } | |||
| if want, have := error(nil), logger.Error("foo", "bar", "baz"); want != have { | |||
| t.Errorf("want %#+v, have %#+v", want, have) | |||
| } | |||
| } | |||
| func TestLevelContext(t *testing.T) { | |||
| var buf bytes.Buffer | |||
| var logger log.Logger | |||
| logger = log.NewTMJSONLogger(&buf) | |||
| logger = log.NewFilter(logger, log.AllowAll()) | |||
| logger = logger.With("context", "value") | |||
| logger.Info("foo", "bar", "baz") | |||
| if want, have := `{"_msg":"foo","bar":"baz","context":"value","level":"info"}`, strings.TrimSpace(buf.String()); want != have { | |||
| t.Errorf("\nwant '%s'\nhave '%s'", want, have) | |||
| } | |||
| } | |||
+ 30
- 0
log/logger.go
View File
| @ -0,0 +1,30 @@ | |||
| package log | |||
| import ( | |||
| "io" | |||
| kitlog "github.com/go-kit/kit/log" | |||
| ) | |||
| // Logger is what any Tendermint library should take. | |||
| type Logger interface { | |||
| Debug(msg string, keyvals ...interface{}) error | |||
| Info(msg string, keyvals ...interface{}) error | |||
| Error(msg string, keyvals ...interface{}) error | |||
| With(keyvals ...interface{}) Logger | |||
| } | |||
| // NewSyncWriter returns a new writer that is safe for concurrent use by | |||
| // multiple goroutines. Writes to the returned writer are passed on to w. If | |||
| // another write is already in progress, the calling goroutine blocks until | |||
| // the writer is available. | |||
| // | |||
| // If w implements the following interface, so does the returned writer. | |||
| // | |||
| // interface { | |||
| // Fd() uintptr | |||
| // } | |||
| func NewSyncWriter(w io.Writer) io.Writer { | |||
| return kitlog.NewSyncWriter(w) | |||
| } | |||
+ 25
- 0
log/nop_logger.go
View File
| @ -0,0 +1,25 @@ | |||
| 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{}) error { | |||
| return nil | |||
| } | |||
| func (nopLogger) Debug(string, ...interface{}) error { | |||
| return nil | |||
| } | |||
| func (nopLogger) Error(string, ...interface{}) error { | |||
| return nil | |||
| } | |||
| func (l *nopLogger) With(...interface{}) Logger { | |||
| return l | |||
| } | |||
+ 18
- 0
log/nop_logger_test.go
View File
| @ -0,0 +1,18 @@ | |||
| package log_test | |||
| import ( | |||
| "testing" | |||
| "github.com/tendermint/tmlibs/log" | |||
| ) | |||
| func TestNopLogger(t *testing.T) { | |||
| t.Parallel() | |||
| logger := log.NewNopLogger() | |||
| if err := logger.Info("Hello", "abc", 123); err != nil { | |||
| t.Error(err) | |||
| } | |||
| if err := logger.With("def", "ghi").Debug(""); err != nil { | |||
| t.Error(err) | |||
| } | |||
| } | |||
+ 31
- 0
log/testing_logger.go
View File
| @ -0,0 +1,31 @@ | |||
| package log | |||
| import ( | |||
| "os" | |||
| "testing" | |||
| ) | |||
| var ( | |||
| // reuse the same logger across all tests | |||
| _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 { | |||
| if _testingLogger != nil { | |||
| return _testingLogger | |||
| } | |||
| if testing.Verbose() { | |||
| _testingLogger = NewTMLogger(NewSyncWriter(os.Stdout)) | |||
| } else { | |||
| _testingLogger = NewNopLogger() | |||
| } | |||
| return _testingLogger | |||
| } | |||
+ 15
- 0
log/tm_json_logger.go
View File
| @ -0,0 +1,15 @@ | |||
| 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 { | |||
| return &tmLogger{kitlog.NewJSONLogger(w)} | |||
| } | |||
+ 67
- 0
log/tm_logger.go
View File
| @ -0,0 +1,67 @@ | |||
| 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 | |||
| ) | |||
| type tmLogger struct { | |||
| srcLogger kitlog.Logger | |||
| } | |||
| // Interface assertions | |||
| var _ Logger = (*tmLogger)(nil) | |||
| // NewTMTermLogger 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)} | |||
| } | |||
| // Info logs a message at level Info. | |||
| func (l *tmLogger) Info(msg string, keyvals ...interface{}) error { | |||
| lWithLevel := kitlevel.Info(l.srcLogger) | |||
| return kitlog.With(lWithLevel, msgKey, msg).Log(keyvals...) | |||
| } | |||
| // Debug logs a message at level Debug. | |||
| func (l *tmLogger) Debug(msg string, keyvals ...interface{}) error { | |||
| lWithLevel := kitlevel.Debug(l.srcLogger) | |||
| return kitlog.With(lWithLevel, msgKey, msg).Log(keyvals...) | |||
| } | |||
| // Error logs a message at level Error. | |||
| func (l *tmLogger) Error(msg string, keyvals ...interface{}) error { | |||
| lWithLevel := kitlevel.Error(l.srcLogger) | |||
| return kitlog.With(lWithLevel, msgKey, msg).Log(keyvals...) | |||
| } | |||
| // 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...)} | |||
| } | |||
+ 41
- 0
log/tm_logger_test.go
View File
| @ -0,0 +1,41 @@ | |||
| package log_test | |||
| import ( | |||
| "io/ioutil" | |||
| "testing" | |||
| "github.com/tendermint/tmlibs/log" | |||
| ) | |||
| func TestTMLogger(t *testing.T) { | |||
| t.Parallel() | |||
| logger := log.NewTMLogger(ioutil.Discard) | |||
| if err := logger.Info("Hello", "abc", 123); err != nil { | |||
| t.Error(err) | |||
| } | |||
| if err := logger.With("def", "ghi").Debug(""); err != nil { | |||
| t.Error(err) | |||
| } | |||
| } | |||
| 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") } | |||
| ) | |||
+ 116
- 0
log/tmfmt_logger.go
View File
| @ -0,0 +1,116 @@ | |||
| package log | |||
| import ( | |||
| "bytes" | |||
| "fmt" | |||
| "io" | |||
| "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. | |||
| // | |||
| // 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) | |||
| lvl := "none" | |||
| msg := "unknown" | |||
| lvlIndex := -1 | |||
| msgIndex := -1 | |||
| for i := 0; i < len(keyvals)-1; i += 2 { | |||
| // Extract level | |||
| if keyvals[i] == kitlevel.Key() { | |||
| lvlIndex = i | |||
| switch keyvals[i+1].(type) { | |||
| 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])) | |||
| } | |||
| continue | |||
| } | |||
| // and message | |||
| if keyvals[i] == msgKey { | |||
| msgIndex = i | |||
| msg = keyvals[i+1].(string) | |||
| continue | |||
| } | |||
| if lvlIndex > 0 && msgIndex > 0 { // found all we're looking for | |||
| break | |||
| } | |||
| } | |||
| // Form a custom Tendermint line | |||
| // | |||
| // Example: | |||
| // D[05-02|11:06:44.322] Stopping AddrBook (ignoring: already stopped) | |||
| // | |||
| // Description: | |||
| // D - first character of the level, uppercase (ASCII only) | |||
| // [05-02|11:06:44.322] - our time format (see https://golang.org/src/time/format.go) | |||
| // Stopping ... - message | |||
| enc.buf.WriteString(fmt.Sprintf("%c[%s] %-44s", lvl[0]-32, time.Now().UTC().Format("01-02|15:04:05.000"), msg)) | |||
| for i := 0; i < len(keyvals)-1; i += 2 { | |||
| if i == lvlIndex || i == msgIndex { | |||
| continue | |||
| } | |||
| if err := enc.EncodeKeyval(keyvals[i], keyvals[i+1]); 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 | |||
| } | |||
+ 110
- 0
log/tmfmt_logger_test.go
View File
| @ -0,0 +1,110 @@ | |||
| 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/tmlibs/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() | |||
| err := logger.Log("std_map", map[int]int{1: 2}, "my_map", mymap{0: 0}) | |||
| assert.NotNil(t, err) | |||
| 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()) | |||
| } | |||
| 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) | |||
| } | |||
| } | |||
| 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" } | |||