Sync from Azure to LF

[ric-plt/resource-status-manager.git] / RSM / logger / logger.go

diff --git a/RSM/logger/logger.go b/RSM/logger/logger.go
new file mode 100644 (file)
index 0000000..05730f7
--- /dev/null
+++ b/RSM/logger/logger.go
@@ -0,0 +1,184 @@
+//
+// Copyright 2019 AT&T Intellectual Property
+// Copyright 2019 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package logger
+
+import (
+       "fmt"
+       "go.uber.org/zap"
+       "go.uber.org/zap/zapcore"
+       "strings"
+       "time"
+)
+
+type Logger struct {
+       Logger     *zap.Logger
+}
+
+// Copied from zap logger
+//
+// A Level is a logging priority. Higher levels are more important.
+type LogLevel int8
+
+const (
+       // DebugLevel logs are typically voluminous, and are usually disabled in
+       // production.
+       DebugLevel LogLevel = iota - 1
+       // InfoLevel is the default logging priority.
+       InfoLevel
+       // WarnLevel logs are more important than Info, but don't need individual
+       // human review.
+       WarnLevel
+       // ErrorLevel logs are high-priority. If an application is running smoothly,
+       // it shouldn't generate any error-level logs.
+       ErrorLevel
+       // DPanicLevel logs are particularly important errors. In development the
+       // logger panics after writing the message.
+       DPanicLevel
+       // PanicLevel logs a message, then panics.
+       PanicLevel
+       // FatalLevel logs a message, then calls os.Exit(1).
+       FatalLevel
+
+       _minLevel = DebugLevel
+       _maxLevel = FatalLevel
+)
+
+var logLevelTokenToLevel = map[string] LogLevel {
+       "debug" : DebugLevel,
+       "info": InfoLevel,
+       "warn": WarnLevel,
+       "error": ErrorLevel,
+       "dpanic": DPanicLevel,
+       "panic": PanicLevel,
+       "fatal": FatalLevel,
+}
+
+func LogLevelTokenToLevel(level string) (LogLevel, bool) {
+       if level, ok := logLevelTokenToLevel[strings.TrimSpace(strings.ToLower(level))];ok {
+               return level, true
+       }
+       return _maxLevel+1, false
+}
+
+func InitLogger(requested LogLevel) (*Logger, error) {
+       var logger *zap.Logger
+       var err error
+       switch requested {
+       case DebugLevel:
+               logger, err = initLoggerByLevel(zapcore.DebugLevel)
+       case InfoLevel:
+               logger, err = initLoggerByLevel(zapcore.InfoLevel)
+       case WarnLevel:
+               logger, err = initLoggerByLevel(zapcore.WarnLevel)
+       case ErrorLevel:
+               logger, err = initLoggerByLevel(zapcore.ErrorLevel)
+       case DPanicLevel:
+               logger, err = initLoggerByLevel(zapcore.DPanicLevel)
+       case PanicLevel:
+               logger, err = initLoggerByLevel(zapcore.PanicLevel)
+       case FatalLevel:
+               logger, err = initLoggerByLevel(zapcore.FatalLevel)
+       default:
+               err = fmt.Errorf("Invalid logging Level :%d",requested)
+       }
+       if err != nil {
+               return nil, err
+       }
+       return &Logger{Logger:logger}, nil
+
+}
+func(l *Logger)Sync() error {
+       l.Debugf("#logger.Sync - Going to flush buffered log")
+       return l.Logger.Sync()
+}
+
+func (l *Logger)Infof(formatMsg string, a ...interface{})  {
+       if l.InfoEnabled() {
+               msg := fmt.Sprintf(formatMsg, a...)
+               l.Logger.Info(msg, zap.Any("mdc", l.getTimeStampMdc()))
+       }
+}
+
+func (l *Logger)Debugf(formatMsg string, a ...interface{})  {
+       if l.DebugEnabled(){
+               msg := fmt.Sprintf(formatMsg, a...)
+               l.Logger.Debug(msg, zap.Any("mdc", l.getTimeStampMdc()))
+       }
+}
+
+func (l *Logger)Errorf(formatMsg string, a ...interface{})  {
+       msg := fmt.Sprintf(formatMsg, a...)
+       l.Logger.Error(msg, zap.Any("mdc", l.getTimeStampMdc()))
+}
+
+func (l *Logger)Warnf(formatMsg string, a ...interface{})  {
+       msg := fmt.Sprintf(formatMsg, a...)
+       l.Logger.Warn(msg, zap.Any("mdc", l.getTimeStampMdc()))
+}
+
+func (l *Logger) getTimeStampMdc() map[string]string {
+       timeStr := time.Now().Format("2006-01-02 15:04:05.000")
+       mdc := map[string]string{"time": timeStr}
+       return mdc
+}
+
+func (l *Logger)InfoEnabled()bool{
+       return l.Logger.Core().Enabled(zap.InfoLevel)
+}
+
+func (l *Logger)DebugEnabled()bool{
+       return l.Logger.Core().Enabled(zap.DebugLevel)
+}
+
+func (l *Logger)DPanicf(formatMsg string, a ...interface{})  {
+       msg := fmt.Sprintf(formatMsg, a...)
+       l.Logger.DPanic(msg, zap.Any("mdc", l.getTimeStampMdc()))
+}
+
+func initLoggerByLevel(l zapcore.Level) (*zap.Logger, error) {
+       cfg := zap.Config{
+               Encoding:         "json",
+               Level:            zap.NewAtomicLevelAt(l),
+               OutputPaths:      []string{"stdout"},
+               ErrorOutputPaths: []string{"stderr"},
+               EncoderConfig: zapcore.EncoderConfig{
+                       MessageKey: "msg",
+
+                       LevelKey:    "crit",
+                       EncodeLevel: zapcore.CapitalLevelEncoder,
+
+                       TimeKey:    "ts",
+                       EncodeTime: epochMillisIntegerTimeEncoder,
+
+                       CallerKey:    "id",
+                       EncodeCaller: rsmCallerEncoder,
+               },
+       }
+       return cfg.Build()
+}
+
+func rsmCallerEncoder(caller zapcore.EntryCaller, enc zapcore.PrimitiveArrayEncoder) {
+       enc.AppendString("RSM")
+}
+
+func epochMillisIntegerTimeEncoder(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
+       nanos := t.UnixNano()
+       millis := int64(nanos) / int64(time.Millisecond)
+       enc.AppendInt64(millis)
+}
+