/
logger.go
159 lines (138 loc) · 3.28 KB
/
logger.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
package leafLogrus
import (
"fmt"
"github.com/labstack/gommon/log"
leafLogger "github.com/paulusrobin/leaf-utilities/logger/logger"
"github.com/rifflock/lfshook"
"github.com/sirupsen/logrus"
"os"
)
type (
logger struct {
instance *logrus.Logger
option options
logger standardLogger
}
)
func (l logger) Info(message leafLogger.Message) {
if l.option.level != log.OFF {
logging := l.instance
logging.WithFields(l.logWithField(message)).
Info(message.String())
}
}
func (l logger) Warn(message leafLogger.Message) {
if l.option.level != log.OFF {
logging := l.instance
logging.WithFields(l.logWithField(message)).
Warn(message.String())
}
}
func (l logger) Error(message leafLogger.Message) {
if l.option.level != log.OFF {
logging := l.instance
logging.WithFields(l.logWithField(message)).
Error(message.String())
}
}
func (l logger) Debug(message leafLogger.Message) {
if l.option.level != log.OFF {
logging := l.instance
logging.WithFields(l.logWithField(message)).
Debug(message.String())
}
}
func (l logger) StandardLogger() leafLogger.StandardLogger {
return &l.logger
}
func (l logger) logWithField(message leafLogger.Message) map[string]interface{} {
var messageData = make(map[string]interface{})
for key, message := range message {
if l.option.masking != nil {
message = l.option.masking.Encode(key, message)
}
messageData[key] = message
}
return messageData
}
func DefaultLog() leafLogger.Logger {
logger, _ := New()
return logger
}
func GetLoggerFormatter(formatter string) (Formatter, error) {
if string(JSONFormatter) == formatter {
return JSONFormatter, nil
}
if string(TextFormatter) == formatter {
return TextFormatter, nil
}
return "", fmt.Errorf("invalid log format")
}
func New(opts ...Option) (leafLogger.Logger, error) {
o := defaultOption()
for _, opt := range opts {
opt.Apply(&o)
}
instance := logrus.New()
switch o.level {
case log.INFO:
instance.Level = logrus.InfoLevel
break
case log.DEBUG:
instance.Level = logrus.DebugLevel
break
case log.WARN:
instance.Level = logrus.WarnLevel
break
case log.ERROR:
instance.Level = logrus.ErrorLevel
break
default:
instance.Level = logrus.ErrorLevel
break
}
var formatter logrus.Formatter
if o.formatter == JSONFormatter {
formatter = &logrus.JSONFormatter{}
} else {
formatter = &logrus.TextFormatter{}
}
instance.Formatter = formatter
// - check if log file path does exists
if o.logFilePath != "" {
if _, err := os.Stat(o.logFilePath); os.IsNotExist(err) {
if _, err = os.Create(o.logFilePath); err != nil {
return nil, fmt.Errorf("failed to create log file %s\nerror: %+v", o.logFilePath, err)
}
}
maps := lfshook.PathMap{
logrus.InfoLevel: o.logFilePath,
logrus.DebugLevel: o.logFilePath,
logrus.ErrorLevel: o.logFilePath,
}
instance.Hooks.Add(lfshook.NewHook(maps, formatter))
}
return &logger{
instance: instance,
option: o,
logger: standardLogger{
instance: instance,
level: o.level,
prefix: o.prefix,
},
}, nil
}
func getLevel(lvl log.Lvl) logrus.Level {
switch lvl {
case log.INFO:
return logrus.InfoLevel
case log.DEBUG:
return logrus.DebugLevel
case log.WARN:
return logrus.WarnLevel
case log.ERROR:
return logrus.ErrorLevel
default:
return logrus.ErrorLevel
}
}