reformat error funcs, improved logger

logger/context.go

@@ -15,7 +15,7 @@ var (
 type log struct{}
 
 func init() {
-	defaultLogger = &logger{FieldLogger: logrus.New()}
+	defaultLogger = &logger{fl: logrus.New()}
 }
 
 func SetDefault(logger Logger) {

logger/logger.go

@@ -2,16 +2,21 @@ package logger
 
 import (
 	"fmt"
+	"io"
 
 	"github.com/sirupsen/logrus"
 )
 
 var (
-	StandardLogger Logger = &logger{FieldLogger: logrus.StandardLogger()}
+	standardLogger Logger = &logger{fl: logrus.StandardLogger()}
 )
 
+func StandardLogger() Logger {
+	return standardLogger
+}
+
 func New() Logger {
-	return &logger{FieldLogger: logrus.New()}
+	return &logger{fl: logrus.New()}
 }
 
 type Logger interface {
@@ -19,6 +24,8 @@ type Logger interface {
 	WithFields(kv ...interface{}) Logger
 	WithError(err error) Logger
 
+	WriterLevel(level logrus.Level) *io.PipeWriter
+
 	Debugf(format string, args ...interface{})
 	Infof(format string, args ...interface{})
 	Printf(format string, args ...interface{})
@@ -48,20 +55,127 @@ type Logger interface {
 }
 
 type logger struct {
-	logrus.FieldLogger
+	fl logrus.FieldLogger
+}
+
+func (l *logger) Debugf(format string, args ...interface{}) {
+	l.fl.Debugf(format, args...)
+}
+
+func (l *logger) Infof(format string, args ...interface{}) {
+	l.fl.Infof(format, args...)
+}
+
+func (l *logger) Printf(format string, args ...interface{}) {
+	l.fl.Printf(format, args...)
+}
+
+func (l *logger) Warnf(format string, args ...interface{}) {
+	l.fl.Warnf(format, args...)
+}
+
+func (l *logger) Warningf(format string, args ...interface{}) {
+	l.fl.Warningf(format, args...)
+}
+
+func (l *logger) Errorf(format string, args ...interface{}) {
+	l.fl.Errorf(format, args...)
+}
+
+func (l *logger) Fatalf(format string, args ...interface{}) {
+	l.fl.Fatalf(format, args...)
+}
+
+func (l *logger) Panicf(format string, args ...interface{}) {
+	l.fl.Panicf(format, args...)
+}
+
+func (l *logger) Debug(args ...interface{}) {
+	l.fl.Debug(args...)
+}
+
+func (l *logger) Info(args ...interface{}) {
+	l.fl.Info(args...)
+}
+
+func (l *logger) Print(args ...interface{}) {
+	l.fl.Print(args...)
+}
+
+func (l *logger) Warn(args ...interface{}) {
+	l.fl.Warn(args...)
+}
+
+func (l *logger) Warning(args ...interface{}) {
+	l.fl.Warning(args...)
+}
+
+func (l *logger) Error(args ...interface{}) {
+	l.fl.Error(args...)
+}
+
+func (l *logger) Fatal(args ...interface{}) {
+	l.fl.Fatal(args...)
+}
+
+func (l *logger) Panic(args ...interface{}) {
+	l.fl.Panic(args...)
+}
+
+func (l *logger) Debugln(args ...interface{}) {
+	l.fl.Debugln(args...)
+}
+
+func (l *logger) Infoln(args ...interface{}) {
+	l.fl.Infoln(args...)
+}
+
+func (l *logger) Println(args ...interface{}) {
+	l.fl.Println(args...)
+}
+
+func (l *logger) Warnln(args ...interface{}) {
+	l.fl.Warnln(args...)
+}
+
+func (l *logger) Warningln(args ...interface{}) {
+	l.fl.Warningln(args...)
+}
+
+func (l *logger) Errorln(args ...interface{}) {
+	l.fl.Errorln(args...)
+}
+
+func (l *logger) Fatalln(args ...interface{}) {
+	l.fl.Fatalln(args...)
+}
+
+func (l *logger) Panicln(args ...interface{}) {
+	l.fl.Panicln(args...)
+}
+
+func (l *logger) WriterLevel(level logrus.Level) *io.PipeWriter {
+	switch t := l.fl.(type) {
+	case *logrus.Logger:
+		return t.WriterLevel(level)
+	case *logrus.Entry:
+		return t.WriterLevel(level)
+	}
+	panic(fmt.Sprintf("unsupporter logger type %T", l.fl))
 }
 
 func (l *logger) WithField(key string, value interface{}) Logger {
-	return &logger{FieldLogger: l.FieldLogger.WithField(key, value)}
+	return &logger{fl: l.fl.WithField(key, value)}
 }
 
 func (l *logger) WithFields(kv ...interface{}) Logger {
+	log := &logger{fl: l.fl}
 	for i := 0; i < len(kv); i += 2 {
-		l.FieldLogger = l.FieldLogger.WithField(fmt.Sprintf("%v", kv[i]), kv[i+1])
+		log = &logger{fl: log.fl.WithField(fmt.Sprintf("%v", kv[i]), kv[i+1])}
 	}
-	return l
+	return log
 }
 
 func (l *logger) WithError(err error) Logger {
-	return &logger{FieldLogger: l.FieldLogger.WithError(err)}
+	return &logger{fl: l.fl.WithError(err)}
 }