blob: 8cb1174af21cf60f87f5931ec403cbb6e3a7b971 [file] [log] [blame]
/*
* Copyright 2022-present Open Networking Foundation
* 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 log
import (
"context"
"github.com/opencord/voltha-lib-go/v7/pkg/log"
)
const skipLevel = 2
// Fields - struct to update log params
type Fields log.Fields
// CLogger - CLogger wrapper
type CLogger struct {
clogger log.CLogger
}
type LevelLog int8
// constants defining the Log Level
const (
// DebugLevel logs a message at debug level
DebugLevel = iota
// InfoLevel logs a message at info level
InfoLevel
// WarnLevel logs a message at warning level
WarnLevel
// ErrorLevel logs a message at error level
ErrorLevel
// FatalLevel logs a message, then calls os.Exit(1).
FatalLevel
)
// AddPackageWithDefaultParam registers a package to the log map with default params
func AddPackageWithDefaultParam() (CLogger, error) {
var cLogger CLogger
_, err := log.RegisterPackage(log.JSON, log.ErrorLevel, log.Fields{})
if err == nil {
cLogger.clogger, _ = log.UpdateCallerSkipLevel(skipLevel)
}
return cLogger, err
}
// AddPackage registers a package to the log map
func AddPackage(level int) (*CLogger, error) {
var cLogger *CLogger
logger, err := log.RegisterPackage(log.JSON, log.LogLevel(level), log.Fields{})
if err == nil {
cLogger = &CLogger{
clogger: logger,
}
}
return cLogger, err
}
// StringToLogLevel - converts the log level from string to defined uint8
func StringToLogLevel(l string) (LevelLog, error) {
ll, err := log.StringToLogLevel(l)
if err != nil {
return 0, err
}
return LevelLog(ll), nil
}
// With initializes logger with the key-value pairs
func (cl CLogger) With(ctx context.Context, keysAndValues Fields, msg string) {
cl.clogger.With(log.Fields(keysAndValues)).Fatal(ctx, msg)
}
// SetAllLogLevel sets the log level of all registered packages to level
func SetAllLogLevel(level int) {
log.SetAllLogLevel(log.LogLevel(level))
}
// SetDefaultLogLevel sets the log level used for packages that don't have specific loggers
func SetDefaultLogLevel(level int) {
log.SetDefaultLogLevel(log.LogLevel(level))
}
// UpdateAllLoggers create new loggers for all registered pacakges with the defaultFields.
func UpdateAllLoggers(defaultFields Fields) error {
_ = log.UpdateAllLoggers(log.Fields(defaultFields))
return log.UpdateAllCallerSkipLevel(skipLevel)
}
// SetDefaultLogger needs to be invoked before the logger API can be invoked. This function
// initialize the default logger (zap's sugaredlogger)
func SetDefaultLogger(ctx context.Context, level int, defaultFields Fields) error {
_, err := log.SetDefaultLogger(log.JSON, log.LogLevel(level), log.Fields(defaultFields))
return err
}
// CleanUp flushed any buffered log entries. Applications should take care to call
// CleanUp before exiting.
func CleanUp() error {
return log.CleanUp()
}
// Fatal logs a message at level Fatal on the standard logger.
func (cl CLogger) Fatal(ctx context.Context, args string) {
cl.clogger.Fatal(ctx, args)
}
// Fatalw logs a message with some additional context. The variadic key-value
// pairs are treated as they are in With.
func (cl CLogger) Fatalw(ctx context.Context, msg string, keysAndValues Fields) {
cl.clogger.Fatalw(ctx, msg, log.Fields(keysAndValues))
}
// Error logs a message at level Error on the standard logger.
func (cl CLogger) Error(ctx context.Context, args string) {
cl.clogger.Error(ctx, args)
}
// Errorw logs a message with some additional context. The variadic key-value
// pairs are treated as they are in With.
func (cl CLogger) Errorw(ctx context.Context, msg string, keysAndValues Fields) {
cl.clogger.Errorw(ctx, msg, log.Fields(keysAndValues))
}
// Warn logs a message at level Warn on the standard logger.
func (cl CLogger) Warn(ctx context.Context, args string) {
cl.clogger.Warn(ctx, args)
}
// Warnw logs a message with some additional context. The variadic key-value
// pairs are treated as they are in With.
func (cl CLogger) Warnw(ctx context.Context, msg string, keysAndValues Fields) {
cl.clogger.Warnw(ctx, msg, log.Fields(keysAndValues))
}
// Info logs a message at level Info on the standard logger.
func (cl CLogger) Info(ctx context.Context, args string) {
cl.clogger.Info(ctx, args)
}
// Infow logs a message with some additional context. The variadic key-value
// pairs are treated as they are in With.
func (cl CLogger) Infow(ctx context.Context, msg string, keysAndValues Fields) {
cl.clogger.Infow(ctx, msg, log.Fields(keysAndValues))
}
// Debug logs a message at level Debug on the standard logger.
func (cl CLogger) Debug(ctx context.Context, args string) {
cl.clogger.Debug(ctx, args)
}
// Debugw logs a message with some additional context. The variadic key-value
// pairs are treated as they are in With.
func (cl CLogger) Debugw(ctx context.Context, msg string, keysAndValues Fields) {
cl.clogger.Debugw(ctx, msg, log.Fields(keysAndValues))
}