/
logger_simple.go
162 lines (140 loc) · 3.83 KB
/
logger_simple.go
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
package logging
import (
"fmt"
"io"
"log"
"strings"
"github.com/pkg/errors"
)
type loggerSimple struct {
errorLogger *log.Logger
warnLogger *log.Logger
infoLogger *log.Logger
debugLogger *log.Logger
out io.Writer
}
func init() {
RegisterBackend("simple", NewSimpleLogger)
RegisterBackend("null", NewSimpleLoggerNull)
}
// NewSimpleLogger creates a simple Logger based on the golang log package
func NewSimpleLogger(options Options) Logger {
out := options.GetOutput()
var errorLogger *log.Logger
var warnLogger *log.Logger
var infoLogger *log.Logger
var debugLogger *log.Logger
if options.Level >= Error {
errorLogger = log.New(out, "ERROR: ", log.LstdFlags)
}
if options.Level >= Warn {
warnLogger = log.New(out, "WARN: ", log.LstdFlags)
}
if options.Level >= Info {
infoLogger = log.New(out, "INFO: ", log.LstdFlags)
}
if options.Level >= Debug {
debugLogger = log.New(out, "DEBUG: ", log.LstdFlags)
}
return &loggerSimple{
errorLogger: errorLogger,
warnLogger: warnLogger,
infoLogger: infoLogger,
debugLogger: debugLogger,
out: out,
}
}
// NewSimpleLoggerNull create a simple Logger discarding all log entries (i.e.
// /dev/null). Useful for testing where you do not want to polute testing
// output with log messages.
func NewSimpleLoggerNull(options Options) Logger {
return &loggerSimple{}
}
func (l *loggerSimple) ErrorErr(err error) {
if l.errorLogger != nil {
switch richErr := err.(type) {
case fmt.Formatter:
l.errorLogger.Printf("%+v", richErr)
case SimpleStackTracer:
l.errorLogger.Print(richErr.ErrorStack())
default:
wrapped := errors.Wrap(err, err.Error())
l.errorLogger.Printf("%+v", wrapped)
}
}
}
func (l *loggerSimple) Errorf(format string, args ...interface{}) {
if l.errorLogger != nil {
l.errorLogger.Printf(format, args...)
}
}
func (l *loggerSimple) Error(args ...interface{}) {
if l.errorLogger != nil {
l.errorLogger.Print(args...)
}
}
func (l *loggerSimple) Warnf(format string, args ...interface{}) {
if l.warnLogger != nil {
l.warnLogger.Printf(format, args...)
}
}
func (l *loggerSimple) Warn(args ...interface{}) {
if l.warnLogger != nil {
l.warnLogger.Print(args...)
}
}
func (l *loggerSimple) Infof(format string, args ...interface{}) {
if l.infoLogger != nil {
l.infoLogger.Printf(format, args...)
}
}
func (l *loggerSimple) Info(args ...interface{}) {
if l.infoLogger != nil {
l.infoLogger.Print(args...)
}
}
func (l *loggerSimple) Debugf(format string, args ...interface{}) {
if l.debugLogger != nil {
l.debugLogger.Printf(format, args...)
}
}
func (l *loggerSimple) Debug(args ...interface{}) {
if l.debugLogger != nil {
l.debugLogger.Print(args...)
}
}
func (l *loggerSimple) WithContext(fields map[string]interface{}) Logger {
elements := make([]string, 0)
for k, v := range fields {
elements = append(elements, fmt.Sprintf("%s=%v", k, v))
}
return l.subLogger(strings.Join(elements, " "))
}
func (l *loggerSimple) WithField(name, value string) Logger {
return l.subLogger(fmt.Sprintf("%s=%s", name, value))
}
func (l *loggerSimple) subLogger(additionalPrefix string) Logger {
var errorLogger *log.Logger
var warnLogger *log.Logger
var infoLogger *log.Logger
var debugLogger *log.Logger
if l.errorLogger != nil {
errorLogger = log.New(l.out, l.errorLogger.Prefix()+additionalPrefix+" ", log.LstdFlags)
}
if l.warnLogger != nil {
warnLogger = log.New(l.out, l.warnLogger.Prefix()+additionalPrefix+" ", log.LstdFlags)
}
if l.infoLogger != nil {
infoLogger = log.New(l.out, l.infoLogger.Prefix()+additionalPrefix+" ", log.LstdFlags)
}
if l.debugLogger != nil {
debugLogger = log.New(l.out, l.debugLogger.Prefix()+additionalPrefix+" ", log.LstdFlags)
}
return &loggerSimple{
errorLogger: errorLogger,
warnLogger: warnLogger,
infoLogger: infoLogger,
debugLogger: debugLogger,
out: l.out,
}
}