github.com/TIBCOSoftware/flogo-lib@v0.5.9/logger/zaplogger.go (about)

     1  package logger
     2  
     3  import (
     4  	"fmt"
     5  	"strings"
     6  
     7  	"go.uber.org/zap"
     8  	"go.uber.org/zap/zapcore"
     9  )
    10  
    11  var rootLogger Logger
    12  
    13  func initRootLogger() {
    14  	zl, lvl, _ := newZapLogger()
    15  	rootLogger = &zapLoggerImpl{loggerLevel: lvl, mainLogger: zl.Sugar()}
    16  }
    17  
    18  type ZapLoggerFactory struct {
    19  }
    20  
    21  func (*ZapLoggerFactory) GetLogger(name string) Logger {
    22  	mutex.RLock()
    23  	l := loggerMap[name]
    24  	mutex.RUnlock()
    25  	
    26  	if l == nil {
    27  		var err error
    28  		l, err = newZapChildLogger(rootLogger, name)
    29  		if err != nil {
    30  			return rootLogger
    31  		}
    32  
    33  		mutex.Lock()
    34  		loggerMap[name] = l
    35  		mutex.Unlock()
    36  	}
    37  	return l
    38  }
    39  
    40  type zapLoggerImpl struct {
    41  	loggerLevel *zap.AtomicLevel
    42  	mainLogger  *zap.SugaredLogger
    43  }
    44  
    45  func (l *zapLoggerImpl) SetLogLevel(level Level) {
    46  	zapLevel := toZapLogLevel(level)
    47  	l.loggerLevel.SetLevel(zapLevel)
    48  }
    49  
    50  func (l *zapLoggerImpl) GetLogLevel() Level {
    51  	zapLevel := l.loggerLevel.Level()
    52  	return fromZapLogLevel(zapLevel)
    53  }
    54  
    55  func (l *zapLoggerImpl) DebugEnabled() bool {
    56  	return l.loggerLevel.Enabled(zapcore.DebugLevel)
    57  }
    58  
    59  func (l *zapLoggerImpl) Debug(args ...interface{}) {
    60  	l.mainLogger.Debug(args...)
    61  }
    62  
    63  func (l *zapLoggerImpl) Info(args ...interface{}) {
    64  	l.mainLogger.Info(args...)
    65  }
    66  
    67  func (l *zapLoggerImpl) Warn(args ...interface{}) {
    68  	l.mainLogger.Warn(args...)
    69  }
    70  
    71  func (l *zapLoggerImpl) Error(args ...interface{}) {
    72  	l.mainLogger.Error(args...)
    73  }
    74  
    75  func (l *zapLoggerImpl) Debugf(template string, args ...interface{}) {
    76  	l.mainLogger.Debugf(template, args...)
    77  }
    78  
    79  func (l *zapLoggerImpl) Infof(template string, args ...interface{}) {
    80  	l.mainLogger.Infof(template, args...)
    81  }
    82  
    83  func (l *zapLoggerImpl) Warnf(template string, args ...interface{}) {
    84  	l.mainLogger.Warnf(template, args...)
    85  }
    86  
    87  func (l *zapLoggerImpl) Errorf(template string, args ...interface{}) {
    88  	l.mainLogger.Errorf(template, args...)
    89  }
    90  
    91  func toZapLogLevel(level Level) zapcore.Level {
    92  	switch level {
    93  	case DebugLevel:
    94  		return zapcore.DebugLevel
    95  	case InfoLevel:
    96  		return zapcore.InfoLevel
    97  	case WarnLevel:
    98  		return zapcore.WarnLevel
    99  	case ErrorLevel:
   100  		return zapcore.ErrorLevel
   101  	}
   102  
   103  	return zapcore.InfoLevel
   104  }
   105  
   106  func fromZapLogLevel(level zapcore.Level) Level {
   107  	switch level {
   108  	case zapcore.DebugLevel:
   109  		return DebugLevel
   110  	case zapcore.InfoLevel:
   111  		return InfoLevel
   112  	case zapcore.WarnLevel:
   113  		return WarnLevel
   114  	case zapcore.ErrorLevel:
   115  		return ErrorLevel
   116  	}
   117  
   118  	return InfoLevel
   119  }
   120  
   121  func newZapLogger() (*zap.Logger, *zap.AtomicLevel, error) {
   122  	cfg := zap.NewProductionConfig()
   123  	cfg.DisableCaller = true
   124  
   125  	eCfg := cfg.EncoderConfig
   126  	eCfg.TimeKey = "timestamp"
   127  	eCfg.EncodeTime = zapcore.ISO8601TimeEncoder
   128  
   129  	if !strings.EqualFold(logFormat, "JSON") {
   130  		eCfg.EncodeLevel = zapcore.CapitalLevelEncoder
   131  		cfg.Encoding = "console"
   132  		eCfg.EncodeName = nameEncoder
   133  	}
   134  
   135  	cfg.EncoderConfig = eCfg
   136  
   137  	lvl := cfg.Level
   138  	zl, err := cfg.Build(zap.AddCallerSkip(1))
   139  
   140  	return zl, &lvl, err
   141  }
   142  
   143  func nameEncoder(loggerName string, enc zapcore.PrimitiveArrayEncoder) {
   144  	enc.AppendString("[" + loggerName + "] -")
   145  }
   146  
   147  func newZapChildLogger(l Logger, name string) (Logger, error) {
   148  
   149  	impl, ok := l.(*zapLoggerImpl)
   150  
   151  	if ok {
   152  		zapLogger := impl.mainLogger
   153  		newZl := zapLogger.Named(name)
   154  
   155  		return &zapLoggerImpl{loggerLevel: impl.loggerLevel, mainLogger: newZl}, nil
   156  	} else {
   157  		return nil, fmt.Errorf("unable to create child logger")
   158  	}
   159  }
   160  
   161  func zapSync(l Logger) {
   162  	impl, ok := l.(*zapLoggerImpl)
   163  
   164  	if ok {
   165  		impl.mainLogger.Sync()
   166  	}
   167  }