You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
131 lines
3.3 KiB
Go
131 lines
3.3 KiB
Go
package logger
|
|
|
|
import (
|
|
"io"
|
|
"strings"
|
|
"sync"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
const (
|
|
// Field names that defines Dapr log schema.
|
|
logFieldTimeStamp = "time"
|
|
logFieldLevel = "level"
|
|
logFieldScope = "scope"
|
|
logFieldMessage = "msg"
|
|
logFieldInstance = "instance"
|
|
logFieldFile = "file"
|
|
)
|
|
|
|
// LogLevel is App Logger Level type.
|
|
type LogLevel string
|
|
|
|
const (
|
|
// DebugLevel has verbose message.
|
|
DebugLevel LogLevel = "debug"
|
|
// InfoLevel is default log level.
|
|
InfoLevel LogLevel = "info"
|
|
// WarnLevel is for logging messages about possible issues.
|
|
WarnLevel LogLevel = "warn"
|
|
// ErrorLevel is for logging errors.
|
|
ErrorLevel LogLevel = "error"
|
|
// FatalLevel is for logging fatal messages. The system shuts down after logging the message.
|
|
FatalLevel LogLevel = "fatal"
|
|
|
|
// UndefinedLevel is for undefined log level.
|
|
UndefinedLevel LogLevel = "undefined"
|
|
)
|
|
|
|
var (
|
|
globalLoggers = map[string]Logger{}
|
|
globalLoggersLock = sync.RWMutex{}
|
|
)
|
|
|
|
// Logger includes the logging api sets.
|
|
type Logger interface { //nolint: interfacebloat
|
|
// EnableJSONOutput enables JSON formatted output log
|
|
EnableJSONOutput(enabled bool)
|
|
|
|
// SetOutputLevel sets the log output level
|
|
SetOutputLevel(outputLevel LogLevel)
|
|
// SetOutput sets the destination for the logs
|
|
SetOutput(dst io.Writer)
|
|
|
|
// IsOutputLevelEnabled returns true if the logger will output this LogLevel.
|
|
IsOutputLevelEnabled(level LogLevel) bool
|
|
|
|
// WithFields returns a logger with the added structured fields.
|
|
WithFields(fields map[string]any) Logger
|
|
|
|
// Info logs a message at level Info.
|
|
Info(args ...interface{})
|
|
// Infof logs a message at level Info.
|
|
Infof(format string, args ...interface{})
|
|
// Debug logs a message at level Debug.
|
|
Debug(args ...interface{})
|
|
// Debugf logs a message at level Debug.
|
|
Debugf(format string, args ...interface{})
|
|
// Warn logs a message at level Warn.
|
|
Warn(args ...interface{})
|
|
// Warnf logs a message at level Warn.
|
|
Warnf(format string, args ...interface{})
|
|
// Error logs a message at level Error.
|
|
Error(args ...interface{})
|
|
// Errorf logs a message at level Error.
|
|
Errorf(format string, args ...interface{})
|
|
// Fatal logs a message at level Fatal then the process will exit with status set to 1.
|
|
Fatal(args ...interface{})
|
|
// Fatalf logs a message at level Fatal then the process will exit with status set to 1.
|
|
Fatalf(format string, args ...interface{})
|
|
// AddHook add hook
|
|
AddHook(hook logrus.Hook)
|
|
// GetLevel get log level
|
|
GetLevel() logrus.Level
|
|
}
|
|
|
|
// toLogLevel converts to LogLevel.
|
|
func toLogLevel(level string) LogLevel {
|
|
switch strings.ToLower(level) {
|
|
case "debug":
|
|
return DebugLevel
|
|
case "info":
|
|
return InfoLevel
|
|
case "warn":
|
|
return WarnLevel
|
|
case "error":
|
|
return ErrorLevel
|
|
case "fatal":
|
|
return FatalLevel
|
|
}
|
|
|
|
// unsupported log level by Dapr
|
|
return UndefinedLevel
|
|
}
|
|
|
|
// NewLogger creates new Logger instance.
|
|
func NewLogger(name string, options ...Option) Logger {
|
|
globalLoggersLock.Lock()
|
|
defer globalLoggersLock.Unlock()
|
|
|
|
logger, ok := globalLoggers[name]
|
|
if !ok {
|
|
logger = newAppLogger(name, options...)
|
|
globalLoggers[name] = logger
|
|
}
|
|
|
|
return logger
|
|
}
|
|
|
|
func getLoggers() map[string]Logger {
|
|
globalLoggersLock.RLock()
|
|
defer globalLoggersLock.RUnlock()
|
|
|
|
l := map[string]Logger{}
|
|
for k, v := range globalLoggers {
|
|
l[k] = v
|
|
}
|
|
|
|
return l
|
|
}
|