blob: 5b3232d7b63751bd4242675bd00eea1e52b46f05 [file] [log] [blame]
//
// 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: e2ManagerCallerEncoder,
},
}
return cfg.Build()
}
func e2ManagerCallerEncoder(caller zapcore.EntryCaller, enc zapcore.PrimitiveArrayEncoder) {
enc.AppendString("E2Manager")
}
func epochMillisIntegerTimeEncoder(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
nanos := t.UnixNano()
millis := int64(nanos) / int64(time.Millisecond)
enc.AppendInt64(millis)
}