init
This commit is contained in:
arraykeys
+331
@@ -0,0 +1,331 @@
|
||||
package logger
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
DebugLevel uint8 = 1
|
||||
InfoLevel uint8 = 1 << 1
|
||||
WarnLevel uint8 = 1 << 2
|
||||
ErrorLevel uint8 = 1 << 3
|
||||
FatalLevel uint8 = 1 << 4
|
||||
AllLevels uint8 = byte(DebugLevel | InfoLevel | WarnLevel | ErrorLevel | FatalLevel)
|
||||
)
|
||||
|
||||
var (
|
||||
flush = &sync.WaitGroup{}
|
||||
exitchn = make(chan bool, 1)
|
||||
)
|
||||
|
||||
type Fields map[string]string
|
||||
type Writer interface {
|
||||
Write(e Entry)
|
||||
Init() error
|
||||
}
|
||||
|
||||
type Logger struct {
|
||||
writersMap *map[int][]*WrappedWriter
|
||||
mu sync.Mutex
|
||||
modeSafe bool
|
||||
wait sync.WaitGroup
|
||||
fields Fields
|
||||
fieldsString string
|
||||
}
|
||||
|
||||
type WrappedWriter struct {
|
||||
lock *sync.Mutex
|
||||
chn chan Entry
|
||||
writer Writer
|
||||
wait sync.WaitGroup
|
||||
}
|
||||
type Entry struct {
|
||||
Content string
|
||||
Timestamp int64
|
||||
Milliseconds int64
|
||||
TimestampMilliseconds int64
|
||||
Level uint8
|
||||
LevelString string
|
||||
Fields map[string]string
|
||||
FieldsString string
|
||||
}
|
||||
type MiniLogger interface {
|
||||
Debug(v ...interface{}) MiniLogger
|
||||
Info(v ...interface{}) MiniLogger
|
||||
Warn(v ...interface{}) MiniLogger
|
||||
Error(v ...interface{}) MiniLogger
|
||||
Fatal(v ...interface{})
|
||||
Debugf(format string, v ...interface{}) MiniLogger
|
||||
Infof(format string, v ...interface{}) MiniLogger
|
||||
Warnf(format string, v ...interface{}) MiniLogger
|
||||
Errorf(format string, v ...interface{}) MiniLogger
|
||||
Fatalf(format string, v ...interface{})
|
||||
Debugln(v ...interface{}) MiniLogger
|
||||
Infoln(v ...interface{}) MiniLogger
|
||||
Warnln(v ...interface{}) MiniLogger
|
||||
Errorln(v ...interface{}) MiniLogger
|
||||
Fatalln(v ...interface{})
|
||||
AddWriter(w Writer, levels uint8) MiniLogger
|
||||
Safe() MiniLogger
|
||||
Unsafe() MiniLogger
|
||||
With(fields Fields) MiniLogger
|
||||
}
|
||||
|
||||
func getLevelString(level uint8) string {
|
||||
switch level {
|
||||
case DebugLevel:
|
||||
return "DEBUG"
|
||||
case InfoLevel:
|
||||
return "INFO"
|
||||
case WarnLevel:
|
||||
return "WARN"
|
||||
case ErrorLevel:
|
||||
return "ERROR"
|
||||
case FatalLevel:
|
||||
return "FATAL"
|
||||
}
|
||||
return "UNKOWN"
|
||||
}
|
||||
|
||||
// New returns a new logger
|
||||
//modeSafe when false : must call logger.Flush() in main defer
|
||||
//if not do that, may be lost message,but this mode has a highest performance
|
||||
//when true : each message can be processed , but this mode may be has a little lower performance
|
||||
//beacuse of logger must wait for all writers process done with each messsage.
|
||||
//note: if you do logging before call os.Exit(), you had better to set safeMode to true before call os.Exit().
|
||||
//fields same as With()'s args,more about fields to see With().
|
||||
func New(modeSafe bool, fields Fields) MiniLogger {
|
||||
if fields == nil {
|
||||
fields = Fields{}
|
||||
}
|
||||
return &Logger{
|
||||
fields: fields,
|
||||
fieldsString: "",
|
||||
mu: sync.Mutex{},
|
||||
modeSafe: modeSafe,
|
||||
wait: sync.WaitGroup{},
|
||||
writersMap: &map[int][]*WrappedWriter{
|
||||
int(DebugLevel): []*WrappedWriter{},
|
||||
int(InfoLevel): []*WrappedWriter{},
|
||||
int(WarnLevel): []*WrappedWriter{},
|
||||
int(ErrorLevel): []*WrappedWriter{},
|
||||
int(FatalLevel): []*WrappedWriter{},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
//Flush wait for process all left entry
|
||||
func Flush() {
|
||||
exitchn <- true
|
||||
flush.Wait()
|
||||
}
|
||||
|
||||
//With return a new MiniLogger,which it's modeSafe inited same as caller MiniLogger,
|
||||
//and revecived levels same as caller MiniLogger,
|
||||
//and set it's fields.
|
||||
//you can use it as a standard MiniLogger.
|
||||
func (l *Logger) With(fields Fields) MiniLogger {
|
||||
for k, v := range l.fields {
|
||||
fields[k] = v
|
||||
}
|
||||
s, _ := json.Marshal(fields)
|
||||
return &Logger{
|
||||
mu: sync.Mutex{},
|
||||
modeSafe: l.modeSafe,
|
||||
wait: sync.WaitGroup{},
|
||||
writersMap: l.writersMap,
|
||||
fields: fields,
|
||||
fieldsString: string(s),
|
||||
}
|
||||
}
|
||||
|
||||
//Unsafe : if you call Unsafe() , then you must call logger.Flush() in main defer
|
||||
//if not do that, may be lost message,but this mode has a highest performance
|
||||
//note: if you do logging before call os.Exit(), you had better to call Safe() before call os.Exit().
|
||||
//you call call func Safe() or Unsafe() in any where any time to switch safe mode.
|
||||
|
||||
func (l *Logger) Unsafe() MiniLogger {
|
||||
l.modeSafe = false
|
||||
return l
|
||||
}
|
||||
|
||||
//Safe : if you call Safe(), each message can be processed immediately,
|
||||
//but this mode may be has lower performance,beacuse of logger must wait for
|
||||
//all writers process done with each messsage.
|
||||
//note: if you do logging before call os.Exit(), you had better to call Safe() before call os.Exit().
|
||||
//you call func Safe() or Unsafe() in any where any time to switch safe mode.
|
||||
func (l *Logger) Safe() MiniLogger {
|
||||
l.modeSafe = true
|
||||
return l
|
||||
}
|
||||
func (l *Logger) AddWriter(writer Writer, levels byte) MiniLogger {
|
||||
w := &WrappedWriter{
|
||||
lock: &sync.Mutex{},
|
||||
writer: writer,
|
||||
chn: make(chan Entry, 1024),
|
||||
}
|
||||
m := *l.writersMap
|
||||
if DebugLevel&levels == DebugLevel {
|
||||
m[int(DebugLevel)] = append(m[int(DebugLevel)], w)
|
||||
}
|
||||
if InfoLevel&levels == InfoLevel {
|
||||
m[int(InfoLevel)] = append(m[int(InfoLevel)], w)
|
||||
}
|
||||
if WarnLevel&levels == WarnLevel {
|
||||
m[int(WarnLevel)] = append(m[int(WarnLevel)], w)
|
||||
}
|
||||
if ErrorLevel&levels == ErrorLevel {
|
||||
m[int(ErrorLevel)] = append(m[int(ErrorLevel)], w)
|
||||
}
|
||||
if FatalLevel&levels == FatalLevel {
|
||||
m[int(FatalLevel)] = append(m[int(FatalLevel)], w)
|
||||
}
|
||||
flush.Add(1)
|
||||
go func() {
|
||||
defer func() {
|
||||
_ = recover()
|
||||
flush.Done()
|
||||
}()
|
||||
if err := w.writer.Init(); err != nil {
|
||||
fmt.Printf("init writer fail,%s", err)
|
||||
return
|
||||
}
|
||||
for {
|
||||
select {
|
||||
case entry, ok := <-w.chn:
|
||||
if ok {
|
||||
w.writer.Write(entry)
|
||||
if l.modeSafe {
|
||||
l.wait.Done()
|
||||
}
|
||||
if entry.Level == FatalLevel {
|
||||
os.Exit(0)
|
||||
}
|
||||
} else {
|
||||
return
|
||||
}
|
||||
case exit := <-exitchn:
|
||||
if exit {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}()
|
||||
return l
|
||||
}
|
||||
func (l *Logger) callWriter(level byte, t, foramt string, v ...interface{}) {
|
||||
if level == FatalLevel {
|
||||
l.Safe()
|
||||
}
|
||||
c := ""
|
||||
if t == "f" && len(v) == 0 {
|
||||
v = append(v, foramt)
|
||||
foramt = "%s"
|
||||
}
|
||||
switch t {
|
||||
case "ln":
|
||||
c = fmt.Sprintln(v...)
|
||||
case "f":
|
||||
c = fmt.Sprintf(foramt, v...)
|
||||
default:
|
||||
c = fmt.Sprint(v...)
|
||||
}
|
||||
m := *l.writersMap
|
||||
for _, w := range m[int(level)] {
|
||||
now := time.Now().UnixNano()
|
||||
nowUnix := time.Now().Unix()
|
||||
mili := (now / 1000000) - nowUnix*1000
|
||||
w.chn <- Entry{
|
||||
Timestamp: nowUnix,
|
||||
TimestampMilliseconds: now / 10000000,
|
||||
Milliseconds: mili,
|
||||
Content: c,
|
||||
Level: level,
|
||||
LevelString: getLevelString(level),
|
||||
Fields: l.fields,
|
||||
FieldsString: l.fieldsString,
|
||||
}
|
||||
if l.modeSafe {
|
||||
l.wait.Add(1)
|
||||
}
|
||||
}
|
||||
if l.modeSafe {
|
||||
l.wait.Wait()
|
||||
}
|
||||
}
|
||||
|
||||
func (l *Logger) Fatal(v ...interface{}) {
|
||||
l.callWriter(FatalLevel, "", "", v...)
|
||||
}
|
||||
|
||||
func (l *Logger) Error(v ...interface{}) MiniLogger {
|
||||
l.callWriter(ErrorLevel, "", "", v...)
|
||||
return l
|
||||
}
|
||||
|
||||
func (l *Logger) Warn(v ...interface{}) MiniLogger {
|
||||
l.callWriter(WarnLevel, "", "", v...)
|
||||
return l
|
||||
}
|
||||
|
||||
func (l *Logger) Info(v ...interface{}) MiniLogger {
|
||||
l.callWriter(InfoLevel, "", "", v...)
|
||||
return l
|
||||
}
|
||||
|
||||
func (l *Logger) Debug(v ...interface{}) MiniLogger {
|
||||
l.callWriter(DebugLevel, "", "", v...)
|
||||
return l
|
||||
}
|
||||
|
||||
func (l *Logger) Fatalf(format string, v ...interface{}) {
|
||||
l.callWriter(FatalLevel, "f", format, v...)
|
||||
}
|
||||
|
||||
func (l *Logger) Errorf(format string, v ...interface{}) MiniLogger {
|
||||
l.callWriter(ErrorLevel, "f", format, v...)
|
||||
return l
|
||||
}
|
||||
|
||||
func (l *Logger) Warnf(format string, v ...interface{}) MiniLogger {
|
||||
l.callWriter(WarnLevel, "f", format, v...)
|
||||
return l
|
||||
}
|
||||
|
||||
func (l *Logger) Infof(format string, v ...interface{}) MiniLogger {
|
||||
l.callWriter(InfoLevel, "f", format, v...)
|
||||
return l
|
||||
}
|
||||
|
||||
func (l *Logger) Debugf(format string, v ...interface{}) MiniLogger {
|
||||
l.callWriter(DebugLevel, "f", format, v...)
|
||||
return l
|
||||
}
|
||||
|
||||
func (l *Logger) Fatalln(v ...interface{}) {
|
||||
l.callWriter(FatalLevel, "ln", "", v...)
|
||||
}
|
||||
|
||||
func (l *Logger) Errorln(v ...interface{}) MiniLogger {
|
||||
l.callWriter(ErrorLevel, "ln", "", v...)
|
||||
return l
|
||||
}
|
||||
|
||||
func (l *Logger) Warnln(v ...interface{}) MiniLogger {
|
||||
l.callWriter(WarnLevel, "ln", "", v...)
|
||||
return l
|
||||
}
|
||||
|
||||
func (l *Logger) Infoln(v ...interface{}) MiniLogger {
|
||||
l.callWriter(InfoLevel, "ln", "", v...)
|
||||
return l
|
||||
}
|
||||
|
||||
func (l *Logger) Debugln(v ...interface{}) MiniLogger {
|
||||
l.callWriter(DebugLevel, "ln", "", v...)
|
||||
return l
|
||||
}
|
||||
Reference in New Issue
Block a user