154 lines
3.3 KiB
Go
154 lines
3.3 KiB
Go
package gologger
|
|
|
|
import (
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
NoLog = iota
|
|
Error
|
|
Warn
|
|
Info
|
|
Debug
|
|
Trace
|
|
)
|
|
|
|
var logLevelMap map[string]int = map[string]int{
|
|
"off": NoLog,
|
|
"error": Error,
|
|
"warn": Warn,
|
|
"info": Info,
|
|
"debug": Debug,
|
|
"trace": Trace,
|
|
}
|
|
var loggerMap map[string]*Logger = map[string]*Logger{}
|
|
var appenderFactoryMap map[string]func(LogAppenderConfig) *LoggerAppender = map[string]func(LogAppenderConfig) *LoggerAppender{}
|
|
var appenders map[string]*LoggerAppender = map[string]*LoggerAppender{}
|
|
var loggerConfig LoggersConfig
|
|
|
|
type LogAppenderConfig struct {
|
|
Type string `json:"type"`
|
|
Options map[string]interface{} `json:"options"`
|
|
}
|
|
type LogConfig struct {
|
|
Level string `json:"level"`
|
|
Appenders []string `json:"appenders"`
|
|
}
|
|
|
|
type LoggersConfig struct {
|
|
Appenders map[string]LogAppenderConfig `json:"appenders"`
|
|
Categories map[string]LogConfig `json:"categories"`
|
|
}
|
|
type Logger struct {
|
|
category string
|
|
level int
|
|
appenders []*LoggerAppender
|
|
}
|
|
|
|
type LogEvent struct {
|
|
Category string
|
|
Ts time.Time
|
|
Level int
|
|
Data []interface{}
|
|
}
|
|
|
|
type LoggerAppender interface {
|
|
GetName() string
|
|
Append(logEvent LogEvent)
|
|
Close()
|
|
}
|
|
|
|
var consoleAppender LoggerAppender = &ConsoleAppender{}
|
|
var defaultLogger = &Logger{
|
|
|
|
level: Error,
|
|
appenders: []*LoggerAppender{&consoleAppender},
|
|
}
|
|
|
|
func (l *Logger) log(Level int, msg []interface{}) {
|
|
|
|
if Level <= l.level {
|
|
now := time.Now()
|
|
logEvent := LogEvent{l.category, now, Level, msg}
|
|
for _, appender := range l.appenders {
|
|
(*appender).Append(logEvent)
|
|
}
|
|
// l.Appender.Append(logEvent)
|
|
// fmt.Println(now.Format("2006-01-02 15:04:05"), " ", l.Name, ": ", msg)
|
|
}
|
|
}
|
|
|
|
func (l *Logger) Error(msg ...interface{}) {
|
|
l.log(Error, msg)
|
|
}
|
|
|
|
func (l *Logger) Warn(msg ...interface{}) {
|
|
l.log(Warn, msg)
|
|
}
|
|
|
|
func (l *Logger) Info(msg ...interface{}) {
|
|
l.log(Info, msg)
|
|
}
|
|
|
|
func (l *Logger) Debug(msg ...interface{}) {
|
|
l.log(Debug, msg)
|
|
}
|
|
|
|
func (l *Logger) Trace(msg ...interface{}) {
|
|
l.log(Trace, msg)
|
|
}
|
|
func GetLogger(name string) *Logger {
|
|
if logger, ok := loggerMap[name]; ok {
|
|
return logger
|
|
} else {
|
|
logConfig, ok := loggerConfig.Categories[name]
|
|
if ok {
|
|
return makeLogger(name, logConfig)
|
|
}
|
|
if name == "default" {
|
|
return defaultLogger
|
|
}
|
|
l := *GetLogger("default")
|
|
l.category = name
|
|
loggerMap[name] = &l
|
|
return &l
|
|
}
|
|
}
|
|
|
|
func makeLogger(name string, config LogConfig) *Logger {
|
|
logger := &Logger{category: name}
|
|
levelstr := strings.ToLower(config.Level)
|
|
logger.level = logLevelMap[levelstr]
|
|
|
|
if config.Appenders == nil || len(config.Appenders) == 0 {
|
|
logger.appenders = []*LoggerAppender{&consoleAppender}
|
|
} else {
|
|
logger.appenders = make([]*LoggerAppender, len(config.Appenders))
|
|
for i, appenderName := range config.Appenders {
|
|
logger.appenders[i] = appenders[appenderName]
|
|
}
|
|
}
|
|
loggerMap[name] = logger
|
|
return logger
|
|
}
|
|
func Configure(config LoggersConfig) {
|
|
loggerConfig = config
|
|
for name, appenderConfig := range loggerConfig.Appenders {
|
|
appenderFactory, ok := appenderFactoryMap[appenderConfig.Type]
|
|
if ok {
|
|
appenders[name] = appenderFactory(appenderConfig)
|
|
} else {
|
|
appenders[name] = &consoleAppender
|
|
}
|
|
}
|
|
for name, _ := range loggerConfig.Categories {
|
|
GetLogger(name)
|
|
}
|
|
}
|
|
|
|
func RegistAppender(typeName string, appenderCreatCb func(LogAppenderConfig) *LoggerAppender) {
|
|
|
|
appenderFactoryMap[typeName] = appenderCreatCb
|
|
}
|