Repository navigation
Expand file tree
/
Copy pathlogger.go
More file actions
121 lines (97 loc) · 2.69 KB
/
Copy pathlogger.go
File metadata and controls
121 lines (97 loc) · 2.69 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package etcd
import (
"github.com/eolinker/eosc/log"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
)
type Build struct {
logger *Logger
builder log.Builder
}
func (b *Build) Enabled(level zapcore.Level) bool {
return b.logger.Enabled(level)
}
func (b *Build) With(fields []zapcore.Field) zapcore.Core {
return &Build{
logger: b.logger,
builder: b.builder.WithFields(toFields(fields)),
}
}
func (b *Build) Check(ent zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry {
return b.logger.Check(ent, ce)
}
func (b *Build) Write(ent zapcore.Entry, fields []zapcore.Field) error {
if b.logger.Enabled(ent.Level) {
b.builder.WithFields(toFields(fields)).Logln(toLevel(ent.Level), ent.Message)
}
return nil
}
func (b *Build) Sync() error {
return nil
}
type Logger struct {
logger *log.Logger
encoder zapcore.Encoder
}
func NewLogger() *Logger {
return &Logger{
logger: log.GetLogger(),
encoder: zapcore.NewConsoleEncoder(zap.NewProductionEncoderConfig()),
}
}
func (l *Logger) Enabled(level zapcore.Level) bool {
return l.logger.IsLevelEnabled(toLevel(level))
}
func (l *Logger) With(fields []zapcore.Field) zapcore.Core {
return &Build{
logger: l,
builder: l.logger.WithFields(toFields(fields)),
}
}
func (l *Logger) Check(ent zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry {
return ce.AddCore(ent, l)
}
func (l *Logger) Write(ent zapcore.Entry, fields []zapcore.Field) error {
level := toLevel(ent.Level)
if l.logger.IsLevelEnabled(level) {
buf, err := l.encoder.EncodeEntry(ent, fields)
if err != nil {
return err
}
l.logger.Logln(level, buf.String())
}
return nil
}
func (l *Logger) Sync() error {
return nil
}
var (
levels = map[zapcore.Level]log.Level{
zapcore.DebugLevel: log.DebugLevel,
// InfoLevel is the default logging priority.
zapcore.InfoLevel: log.InfoLevel,
// WarnLevel logs are more important than Info, but don't need individual
// human review.
zapcore.WarnLevel: log.WarnLevel,
// ErrorLevel logs are high-priority. If an application is running smoothly,
// it shouldn't generate any error-level logs.
zapcore.ErrorLevel: log.ErrorLevel,
// DPanicLevel logs are particularly important errors. In development the
// logger panics after writing the message.
zapcore.DPanicLevel: log.TraceLevel,
// PanicLevel logs a message, then panics.
zapcore.PanicLevel: log.PanicLevel,
// FatalLevel logs a message, then calls os.Exit(1).
zapcore.FatalLevel: log.FatalLevel,
}
)
func toLevel(level zapcore.Level) log.Level {
return levels[level]
}
func toFields(fields []zapcore.Field) log.Fields {
encoder := zapcore.NewMapObjectEncoder()
for _, f := range fields {
f.AddTo(encoder)
}
return encoder.Fields
}