From f2695e88cce10fec9def30b15f29f3edc153ac7b Mon Sep 17 00:00:00 2001 From: flashmob Date: Thu, 14 Jun 2018 19:57:18 +1000 Subject: [PATCH 1/2] update logrus to ~1.0.5 --- glide.lock | 27 ++++++++++++++++++--------- glide.yaml | 2 +- 2 files changed, 19 insertions(+), 10 deletions(-) diff --git a/glide.lock b/glide.lock index 618aeebd..101e7e99 100644 --- a/glide.lock +++ b/glide.lock @@ -1,33 +1,37 @@ -hash: ab5586e1ee56f15336e425d99f774acd4f6bc0f042ab597248366592d8c0b1bf -updated: 2018-03-11T11:39:28.566276841+11:00 +hash: 2c246661d6b3c3846d9ba39bd1e38bbc9aef72bd1493283b20f7a476f9a03ba7 +updated: 2018-06-11T10:58:16.67015302+10:00 imports: - name: github.com/asaskevich/EventBus version: 68a521d7cbbb7a859c2608b06342f384b3bd5f5a -- name: github.com/gomodule/redigo +- name: github.com/garyburd/redigo version: 8873b2f1995f59d4bcdd2b0dc9858e2cb9bf0c13 subpackages: - internal - redis - name: github.com/go-sql-driver/mysql - version: a0583e0143b1624142adab07e0e97fe106d99561 + version: d523deb1b23d913de5bdada721a6071e71283618 +- name: github.com/gomodule/redigo + version: 8873b2f1995f59d4bcdd2b0dc9858e2cb9bf0c13 + subpackages: + - redis - name: github.com/inconshreveable/mousetrap version: 76626ae9c91c4f2a10f34cad8ce83ea42c93bb75 - name: github.com/rakyll/statik - version: 274df120e9065bdd08eb1120e0375e3dc1ae8465 + version: fd36b3595eb2ec8da4b8153b107f7ea08504899d subpackages: - fs - name: github.com/sirupsen/logrus - version: d682213848ed68c0a260ca37d6dd5ace8423f5ba + version: c155da19408a8799da419ed3eeb0cb5db0ad5dbc - name: github.com/spf13/cobra version: b62566898a99f2db9c68ed0026aa0a052e59678d - name: github.com/spf13/pflag version: 25f8b5b07aece3207895bf19f7ab517eb3b22a40 - name: golang.org/x/crypto - version: c7dcf104e3a7a1417abc0230cb0d5240d764159d + version: 8ac0e0d97ce45cd83d1d7243c060cb8461dda5e9 subpackages: - ssh/terminal - name: golang.org/x/net - version: d0aafc73d5cdc42264b0af071c261abac580695e + version: 1e491301e022f8f977054da4c2d852decd59571f subpackages: - html - html/atom @@ -38,7 +42,7 @@ imports: - unix - windows - name: golang.org/x/text - version: b7ef84aaf62aa3e70962625c80a571ae7c17cb40 + version: 5c1cf69b5978e5a34c5f9ba09a83e56acc4b7877 subpackages: - encoding - encoding/charmap @@ -51,11 +55,16 @@ imports: - encoding/traditionalchinese - encoding/unicode - internal/language + - internal/language/compact - internal/tag - internal/utf8internal - language - runes - transform +- name: google.golang.org/appengine + version: b1f26356af11148e710935ed1ac8a7f5702c7612 + subpackages: + - cloudsql - name: gopkg.in/iconv.v1 version: 16a760eb7e186ae0e3aedda00d4a1daa4d0701d8 testImports: [] diff --git a/glide.yaml b/glide.yaml index 0513e924..af95785e 100644 --- a/glide.yaml +++ b/glide.yaml @@ -1,7 +1,7 @@ package: github.com/flashmob/go-guerrilla import: - package: github.com/sirupsen/logrus - version: ~1.0.4 + version: ~1.0.5 - package: github.com/gomodule/redigo version: ~1.0.0 subpackages: From 296050594a59ac1839b6b54befd4caacd588abcf Mon Sep 17 00:00:00 2001 From: flashmob Date: Sun, 17 Jun 2018 01:47:16 +1000 Subject: [PATCH 2/2] - add general log interfaces, add logrus adapter - logger using the adapter pattern - add adapter for logrus --- guerrilla.go | 6 +- log/interface.go | 364 +++++++++++++++++++++++++++++++++++++++++++++++ log/log.go | 65 +++++---- 3 files changed, 404 insertions(+), 31 deletions(-) create mode 100644 log/interface.go diff --git a/guerrilla.go b/guerrilla.go index 1dd47773..52cc0a27 100644 --- a/guerrilla.go +++ b/guerrilla.go @@ -86,10 +86,8 @@ func New(ac *AppConfig, b backends.Backend, l log.Logger) (Guerrilla, error) { g.setMainlog(l) if ac.LogLevel != "" { - if h, ok := l.(*log.HookedLogger); ok { - if h, err := log.GetLogger(h.GetLogDest(), ac.LogLevel); err == nil { - g.setMainlog(h) - } + if h, err := log.GetLogger(l.GetLogDest(), ac.LogLevel); err == nil { + g.setMainlog(h) } } diff --git a/log/interface.go b/log/interface.go new file mode 100644 index 00000000..f065ea1e --- /dev/null +++ b/log/interface.go @@ -0,0 +1,364 @@ +package log + +import ( + "github.com/sirupsen/logrus" + "net" +) + +type GenericHook interface { + Levels() []Level + Fire(GenericEntry) error + Reopen() error +} + +type Fields map[string]interface{} + +type GenericEntry interface { + String() (string, error) + WithError(err error) GenericEntry + WithField(key string, value interface{}) GenericEntry + WithFields(fields Fields) GenericEntry + Debug(args ...interface{}) + Print(args ...interface{}) + Info(args ...interface{}) + Warn(args ...interface{}) + Warning(args ...interface{}) + Error(args ...interface{}) + Fatal(args ...interface{}) + Panic(args ...interface{}) + Debugf(format string, args ...interface{}) + Infof(format string, args ...interface{}) + Printf(format string, args ...interface{}) + Warnf(format string, args ...interface{}) + Warningf(format string, args ...interface{}) + Errorf(format string, args ...interface{}) + Fatalf(format string, args ...interface{}) + Panicf(format string, args ...interface{}) + Debugln(args ...interface{}) + Infoln(args ...interface{}) + Println(args ...interface{}) + Warnln(args ...interface{}) + Warningln(args ...interface{}) + Errorln(args ...interface{}) + Fatalln(args ...interface{}) + Panicln(args ...interface{}) +} + +type LogrusEntryAdapter struct { + e *logrus.Entry +} + +func (adapter *LogrusEntryAdapter) String() (string, error) { + return adapter.e.String() +} + +func (adapter *LogrusEntryAdapter) WithError(err error) GenericEntry { + entry := new(LogrusEntryAdapter) + entry.e = adapter.e.WithError(err) + return entry +} + +func (adapter *LogrusEntryAdapter) WithField(key string, value interface{}) GenericEntry { + entry := new(LogrusEntryAdapter) + entry.e = adapter.e.WithField(key, value) + return entry +} + +func (adapter *LogrusEntryAdapter) WithFields(fields Fields) GenericEntry { + f := make(logrus.Fields) + for k, v := range fields { + f[k] = v + } + entry := new(LogrusEntryAdapter) + entry.e = adapter.e.WithFields(f) + return entry +} + +func (adapter *LogrusEntryAdapter) Debug(args ...interface{}) { + adapter.e.Debug(args...) +} + +func (adapter *LogrusEntryAdapter) Print(args ...interface{}) { + adapter.e.Print(args...) +} + +func (adapter *LogrusEntryAdapter) Info(args ...interface{}) { + adapter.e.Info(args...) +} + +func (adapter *LogrusEntryAdapter) Warn(args ...interface{}) { + adapter.e.Warn(args...) +} + +func (adapter *LogrusEntryAdapter) Warning(args ...interface{}) { + adapter.e.Warning(args...) +} + +func (adapter *LogrusEntryAdapter) Error(args ...interface{}) { + adapter.e.Error(args...) +} + +func (adapter *LogrusEntryAdapter) Fatal(args ...interface{}) { + adapter.e.Fatal(args...) +} + +func (adapter *LogrusEntryAdapter) Panic(args ...interface{}) { + adapter.e.Panic(args...) +} + +func (adapter *LogrusEntryAdapter) Debugf(format string, args ...interface{}) { + adapter.e.Debugf(format, args...) +} + +func (adapter *LogrusEntryAdapter) Infof(format string, args ...interface{}) { + adapter.e.Infof(format, args...) +} + +func (adapter *LogrusEntryAdapter) Printf(format string, args ...interface{}) { + adapter.e.Printf(format, args) +} + +func (adapter *LogrusEntryAdapter) Warnf(format string, args ...interface{}) { + adapter.e.Warnf(format, args...) +} + +func (adapter *LogrusEntryAdapter) Warningf(format string, args ...interface{}) { + adapter.e.Warningf(format, args...) +} + +func (adapter *LogrusEntryAdapter) Errorf(format string, args ...interface{}) { + adapter.e.Errorf(format, args...) +} + +func (adapter *LogrusEntryAdapter) Fatalf(format string, args ...interface{}) { + adapter.e.Fatalf(format, args...) +} + +func (adapter *LogrusEntryAdapter) Panicf(format string, args ...interface{}) { + adapter.e.Panicf(format, args...) +} + +func (adapter *LogrusEntryAdapter) Debugln(args ...interface{}) { + adapter.e.Debugln(args...) +} + +func (adapter *LogrusEntryAdapter) Infoln(args ...interface{}) { + adapter.e.Infoln(args...) +} + +func (adapter *LogrusEntryAdapter) Println(args ...interface{}) { + adapter.e.Println(args...) +} + +func (adapter *LogrusEntryAdapter) Warnln(args ...interface{}) { + adapter.e.Warnln(args...) +} + +func (adapter *LogrusEntryAdapter) Warningln(args ...interface{}) { + adapter.e.Warningln(args...) +} + +func (adapter *LogrusEntryAdapter) Errorln(args ...interface{}) { + adapter.e.Errorln(args...) +} + +func (adapter *LogrusEntryAdapter) Fatalln(args ...interface{}) { + adapter.e.Fatalln(args...) +} + +func (adapter *LogrusEntryAdapter) Panicln(args ...interface{}) { + adapter.e.Panicln(args...) +} + +type Logger interface { + WithField(key string, value interface{}) GenericEntry + WithFields(fields Fields) GenericEntry + WithError(err error) GenericEntry + + Debugf(format string, args ...interface{}) + Infof(format string, args ...interface{}) + Printf(format string, args ...interface{}) + Warnf(format string, args ...interface{}) + Warningf(format string, args ...interface{}) + Errorf(format string, args ...interface{}) + Fatalf(format string, args ...interface{}) + Panicf(format string, args ...interface{}) + + Debug(args ...interface{}) + Info(args ...interface{}) + Print(args ...interface{}) + Warn(args ...interface{}) + Warning(args ...interface{}) + Error(args ...interface{}) + Fatal(args ...interface{}) + Panic(args ...interface{}) + + Debugln(args ...interface{}) + Infoln(args ...interface{}) + Println(args ...interface{}) + Warnln(args ...interface{}) + Warningln(args ...interface{}) + Errorln(args ...interface{}) + Fatalln(args ...interface{}) + Panicln(args ...interface{}) + + WithConn(conn net.Conn) GenericEntry + Reopen() error + GetLogDest() string + SetLevel(level string) + GetLevel() string + IsDebug() bool + AddHook(h GenericHook) +} + +type LogrusLoggerAdapter struct { + l LogrusLogger +} + +func (adapter *LogrusLoggerAdapter) WithConn(conn net.Conn) GenericEntry { + entry := new(LogrusEntryAdapter) + entry.e = adapter.l.WithConn(conn) + return entry +} + +func (adapter *LogrusLoggerAdapter) Reopen() error { + return adapter.l.Reopen() +} + +func (adapter *LogrusLoggerAdapter) GetLogDest() string { + return adapter.l.GetLogDest() +} + +func (adapter *LogrusLoggerAdapter) SetLevel(level string) { + adapter.l.SetLevel(level) +} + +func (adapter *LogrusLoggerAdapter) GetLevel() string { + return adapter.l.GetLevel() +} + +func (adapter *LogrusLoggerAdapter) IsDebug() bool { + return adapter.l.IsDebug() +} + +func (adapter *LogrusLoggerAdapter) AddHook(h GenericHook) { + adapter.AddHook(h) +} + +func (adapter *LogrusLoggerAdapter) WithField(key string, value interface{}) GenericEntry { + entry := new(LogrusEntryAdapter) + entry.e = adapter.l.WithField(key, value) + return entry +} + +func (adapter *LogrusLoggerAdapter) WithFields(fields Fields) GenericEntry { + f := make(logrus.Fields) + for k, v := range fields { + f[k] = v + } + entry := new(LogrusEntryAdapter) + entry.e = adapter.l.WithFields(f) + return entry +} + +func (adapter *LogrusLoggerAdapter) WithError(err error) GenericEntry { + entry := new(LogrusEntryAdapter) + entry.e = adapter.l.WithError(err) + return entry +} + +func (adapter *LogrusLoggerAdapter) Debugf(format string, args ...interface{}) { + adapter.l.Debugf(format, args...) +} + +func (adapter *LogrusLoggerAdapter) Infof(format string, args ...interface{}) { + adapter.l.Infof(format, args...) +} + +func (adapter *LogrusLoggerAdapter) Printf(format string, args ...interface{}) { + adapter.l.Printf(format, args...) +} + +func (adapter *LogrusLoggerAdapter) Warnf(format string, args ...interface{}) { + adapter.l.Warnf(format, args...) +} + +func (adapter *LogrusLoggerAdapter) Warningf(format string, args ...interface{}) { + adapter.l.Warningf(format, args...) +} + +func (adapter *LogrusLoggerAdapter) Errorf(format string, args ...interface{}) { + adapter.l.Errorf(format, args...) +} + +func (adapter *LogrusLoggerAdapter) Fatalf(format string, args ...interface{}) { + adapter.l.Fatalf(format, args...) +} + +func (adapter *LogrusLoggerAdapter) Panicf(format string, args ...interface{}) { + adapter.l.Panicf(format, args...) +} + +func (adapter *LogrusLoggerAdapter) Debug(args ...interface{}) { + adapter.l.Debug(args...) +} + +func (adapter *LogrusLoggerAdapter) Info(args ...interface{}) { + adapter.l.Info(args...) +} + +func (adapter *LogrusLoggerAdapter) Print(args ...interface{}) { + adapter.l.Print(args...) +} + +func (adapter *LogrusLoggerAdapter) Warn(args ...interface{}) { + adapter.l.Warn(args...) +} + +func (adapter *LogrusLoggerAdapter) Warning(args ...interface{}) { + adapter.l.Warning(args...) +} + +func (adapter *LogrusLoggerAdapter) Error(args ...interface{}) { + adapter.l.Error(args...) +} + +func (adapter *LogrusLoggerAdapter) Fatal(args ...interface{}) { + adapter.l.Fatal(args...) +} + +func (adapter *LogrusLoggerAdapter) Panic(args ...interface{}) { + adapter.l.Panic(args...) +} + +func (adapter *LogrusLoggerAdapter) Debugln(args ...interface{}) { + adapter.l.Debugln(args...) +} + +func (adapter *LogrusLoggerAdapter) Infoln(args ...interface{}) { + adapter.l.Infoln(args...) +} + +func (adapter *LogrusLoggerAdapter) Println(args ...interface{}) { + adapter.l.Println(args...) +} + +func (adapter *LogrusLoggerAdapter) Warnln(args ...interface{}) { + adapter.l.Warnln(args...) +} + +func (adapter *LogrusLoggerAdapter) Warningln(args ...interface{}) { + adapter.l.Warningln(args...) +} + +func (adapter *LogrusLoggerAdapter) Errorln(args ...interface{}) { + adapter.l.Errorln(args...) +} + +func (adapter *LogrusLoggerAdapter) Fatalln(args ...interface{}) { + adapter.l.Fatalln(args...) +} + +func (adapter *LogrusLoggerAdapter) Panicln(args ...interface{}) { + adapter.l.Panicln(args...) +} diff --git a/log/log.go b/log/log.go index b6a2cb22..2b71591d 100644 --- a/log/log.go +++ b/log/log.go @@ -51,7 +51,8 @@ func (level Level) String() string { return "unknown" } -type Logger interface { +// LogrusLogger is our 'extended' logrus +type LogrusLogger interface { log.FieldLogger WithConn(conn net.Conn) *log.Entry Reopen() error @@ -62,7 +63,7 @@ type Logger interface { AddHook(h log.Hook) } -// Implements the Logger interface +// Implements the LogrusLogger interface // It's a logrus logger wrapper that contains an instance of our LoggerHook type HookedLogger struct { @@ -90,6 +91,38 @@ var loggers struct { sync.Mutex } +type LoggerMaker func(dest string, level string) (Logger, error) + +var MakeLogger LoggerMaker + +func init() { + MakeLogger = func(dest string, level string) (Logger, error) { + o := parseOutputOption(dest) + logrus, err := newLogrus(o, level) + if err != nil { + return nil, err + } + l := &HookedLogger{dest: dest} + l.Logger = logrus + + if o != OutputFile { + return &LogrusLoggerAdapter{l}, nil + } + // we'll use the hook to output instead + logrus.Out = ioutil.Discard + // setup the hook + if h, err := NewLogrusHook(dest); err != nil { + // revert back to stderr + logrus.Out = os.Stderr + return &LogrusLoggerAdapter{l}, err + } else { + logrus.Hooks.Add(h) + l.h = h + } + return &LogrusLoggerAdapter{l}, nil + } +} + // GetLogger returns a struct that implements Logger (i.e HookedLogger) with a custom hook. // It may be new or already created, (ie. singleton factory pattern) // The hook has been initialized with dest @@ -113,34 +146,13 @@ func GetLogger(dest string, level string) (Logger, error) { return l, nil } } - o := parseOutputOption(dest) - logrus, err := newLogrus(o, level) + l, err := MakeLogger(dest, level) if err != nil { - return nil, err + return l, err } - l := &HookedLogger{dest: dest} - l.Logger = logrus - // cache it loggers.cache[key] = l - - if o != OutputFile { - return l, nil - } - // we'll use the hook to output instead - logrus.Out = ioutil.Discard - // setup the hook - if h, err := NewLogrusHook(dest); err != nil { - // revert back to stderr - logrus.Out = os.Stderr - return l, err - } else { - logrus.Hooks.Add(h) - l.h = h - } - return l, nil - } func newLogrus(o OutputOption, level string) (*log.Logger, error) { @@ -212,8 +224,7 @@ func (l *HookedLogger) GetLogDest() string { // WithConn extends logrus to be able to log with a net.Conn func (l *HookedLogger) WithConn(conn net.Conn) *log.Entry { - var addr string = "unknown" - + var addr = "unknown" if conn != nil { addr = conn.RemoteAddr().String() }