|
66
|
1 package logrus
|
|
|
2
|
|
|
3 import (
|
|
|
4 "context"
|
|
|
5 "io"
|
|
|
6 "os"
|
|
|
7 "sync"
|
|
|
8 "sync/atomic"
|
|
|
9 "time"
|
|
|
10 )
|
|
|
11
|
|
|
12 // LogFunction For big messages, it can be more efficient to pass a function
|
|
|
13 // and only call it if the log level is actually enables rather than
|
|
|
14 // generating the log message and then checking if the level is enabled
|
|
|
15 type LogFunction func() []interface{}
|
|
|
16
|
|
|
17 type Logger struct {
|
|
|
18 // The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
|
|
|
19 // file, or leave it default which is `os.Stderr`. You can also set this to
|
|
|
20 // something more adventurous, such as logging to Kafka.
|
|
|
21 Out io.Writer
|
|
|
22 // Hooks for the logger instance. These allow firing events based on logging
|
|
|
23 // levels and log entries. For example, to send errors to an error tracking
|
|
|
24 // service, log to StatsD or dump the core on fatal errors.
|
|
|
25 Hooks LevelHooks
|
|
|
26 // All log entries pass through the formatter before logged to Out. The
|
|
|
27 // included formatters are `TextFormatter` and `JSONFormatter` for which
|
|
|
28 // TextFormatter is the default. In development (when a TTY is attached) it
|
|
|
29 // logs with colors, but to a file it wouldn't. You can easily implement your
|
|
|
30 // own that implements the `Formatter` interface, see the `README` or included
|
|
|
31 // formatters for examples.
|
|
|
32 Formatter Formatter
|
|
|
33
|
|
|
34 // Flag for whether to log caller info (off by default)
|
|
|
35 ReportCaller bool
|
|
|
36
|
|
|
37 // The logging level the logger should log at. This is typically (and defaults
|
|
|
38 // to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
|
|
|
39 // logged.
|
|
|
40 Level Level
|
|
|
41 // Used to sync writing to the log. Locking is enabled by Default
|
|
|
42 mu MutexWrap
|
|
|
43 // Reusable empty entry
|
|
|
44 entryPool sync.Pool
|
|
|
45 // Function to exit the application, defaults to `os.Exit()`
|
|
|
46 ExitFunc exitFunc
|
|
|
47 // The buffer pool used to format the log. If it is nil, the default global
|
|
|
48 // buffer pool will be used.
|
|
|
49 BufferPool BufferPool
|
|
|
50 }
|
|
|
51
|
|
|
52 type exitFunc func(int)
|
|
|
53
|
|
|
54 type MutexWrap struct {
|
|
|
55 lock sync.Mutex
|
|
|
56 disabled bool
|
|
|
57 }
|
|
|
58
|
|
|
59 func (mw *MutexWrap) Lock() {
|
|
|
60 if !mw.disabled {
|
|
|
61 mw.lock.Lock()
|
|
|
62 }
|
|
|
63 }
|
|
|
64
|
|
|
65 func (mw *MutexWrap) Unlock() {
|
|
|
66 if !mw.disabled {
|
|
|
67 mw.lock.Unlock()
|
|
|
68 }
|
|
|
69 }
|
|
|
70
|
|
|
71 func (mw *MutexWrap) Disable() {
|
|
|
72 mw.disabled = true
|
|
|
73 }
|
|
|
74
|
|
|
75 // Creates a new logger. Configuration should be set by changing `Formatter`,
|
|
|
76 // `Out` and `Hooks` directly on the default logger instance. You can also just
|
|
|
77 // instantiate your own:
|
|
|
78 //
|
|
|
79 // var log = &logrus.Logger{
|
|
|
80 // Out: os.Stderr,
|
|
|
81 // Formatter: new(logrus.TextFormatter),
|
|
|
82 // Hooks: make(logrus.LevelHooks),
|
|
|
83 // Level: logrus.DebugLevel,
|
|
|
84 // }
|
|
|
85 //
|
|
|
86 // It's recommended to make this a global instance called `log`.
|
|
|
87 func New() *Logger {
|
|
|
88 return &Logger{
|
|
|
89 Out: os.Stderr,
|
|
|
90 Formatter: new(TextFormatter),
|
|
|
91 Hooks: make(LevelHooks),
|
|
|
92 Level: InfoLevel,
|
|
|
93 ExitFunc: os.Exit,
|
|
|
94 ReportCaller: false,
|
|
|
95 }
|
|
|
96 }
|
|
|
97
|
|
|
98 func (logger *Logger) newEntry() *Entry {
|
|
|
99 entry, ok := logger.entryPool.Get().(*Entry)
|
|
|
100 if ok {
|
|
|
101 return entry
|
|
|
102 }
|
|
|
103 return NewEntry(logger)
|
|
|
104 }
|
|
|
105
|
|
|
106 func (logger *Logger) releaseEntry(entry *Entry) {
|
|
|
107 entry.Data = map[string]interface{}{}
|
|
|
108 logger.entryPool.Put(entry)
|
|
|
109 }
|
|
|
110
|
|
|
111 // WithField allocates a new entry and adds a field to it.
|
|
|
112 // Debug, Print, Info, Warn, Error, Fatal or Panic must be then applied to
|
|
|
113 // this new returned entry.
|
|
|
114 // If you want multiple fields, use `WithFields`.
|
|
|
115 func (logger *Logger) WithField(key string, value interface{}) *Entry {
|
|
|
116 entry := logger.newEntry()
|
|
|
117 defer logger.releaseEntry(entry)
|
|
|
118 return entry.WithField(key, value)
|
|
|
119 }
|
|
|
120
|
|
|
121 // Adds a struct of fields to the log entry. All it does is call `WithField` for
|
|
|
122 // each `Field`.
|
|
|
123 func (logger *Logger) WithFields(fields Fields) *Entry {
|
|
|
124 entry := logger.newEntry()
|
|
|
125 defer logger.releaseEntry(entry)
|
|
|
126 return entry.WithFields(fields)
|
|
|
127 }
|
|
|
128
|
|
|
129 // Add an error as single field to the log entry. All it does is call
|
|
|
130 // `WithError` for the given `error`.
|
|
|
131 func (logger *Logger) WithError(err error) *Entry {
|
|
|
132 entry := logger.newEntry()
|
|
|
133 defer logger.releaseEntry(entry)
|
|
|
134 return entry.WithError(err)
|
|
|
135 }
|
|
|
136
|
|
|
137 // Add a context to the log entry.
|
|
|
138 func (logger *Logger) WithContext(ctx context.Context) *Entry {
|
|
|
139 entry := logger.newEntry()
|
|
|
140 defer logger.releaseEntry(entry)
|
|
|
141 return entry.WithContext(ctx)
|
|
|
142 }
|
|
|
143
|
|
|
144 // Overrides the time of the log entry.
|
|
|
145 func (logger *Logger) WithTime(t time.Time) *Entry {
|
|
|
146 entry := logger.newEntry()
|
|
|
147 defer logger.releaseEntry(entry)
|
|
|
148 return entry.WithTime(t)
|
|
|
149 }
|
|
|
150
|
|
|
151 func (logger *Logger) Logf(level Level, format string, args ...interface{}) {
|
|
|
152 if logger.IsLevelEnabled(level) {
|
|
|
153 entry := logger.newEntry()
|
|
|
154 entry.Logf(level, format, args...)
|
|
|
155 logger.releaseEntry(entry)
|
|
|
156 }
|
|
|
157 }
|
|
|
158
|
|
|
159 func (logger *Logger) Tracef(format string, args ...interface{}) {
|
|
|
160 logger.Logf(TraceLevel, format, args...)
|
|
|
161 }
|
|
|
162
|
|
|
163 func (logger *Logger) Debugf(format string, args ...interface{}) {
|
|
|
164 logger.Logf(DebugLevel, format, args...)
|
|
|
165 }
|
|
|
166
|
|
|
167 func (logger *Logger) Infof(format string, args ...interface{}) {
|
|
|
168 logger.Logf(InfoLevel, format, args...)
|
|
|
169 }
|
|
|
170
|
|
|
171 func (logger *Logger) Printf(format string, args ...interface{}) {
|
|
|
172 entry := logger.newEntry()
|
|
|
173 entry.Printf(format, args...)
|
|
|
174 logger.releaseEntry(entry)
|
|
|
175 }
|
|
|
176
|
|
|
177 func (logger *Logger) Warnf(format string, args ...interface{}) {
|
|
|
178 logger.Logf(WarnLevel, format, args...)
|
|
|
179 }
|
|
|
180
|
|
|
181 func (logger *Logger) Warningf(format string, args ...interface{}) {
|
|
|
182 logger.Warnf(format, args...)
|
|
|
183 }
|
|
|
184
|
|
|
185 func (logger *Logger) Errorf(format string, args ...interface{}) {
|
|
|
186 logger.Logf(ErrorLevel, format, args...)
|
|
|
187 }
|
|
|
188
|
|
|
189 func (logger *Logger) Fatalf(format string, args ...interface{}) {
|
|
|
190 logger.Logf(FatalLevel, format, args...)
|
|
|
191 logger.Exit(1)
|
|
|
192 }
|
|
|
193
|
|
|
194 func (logger *Logger) Panicf(format string, args ...interface{}) {
|
|
|
195 logger.Logf(PanicLevel, format, args...)
|
|
|
196 }
|
|
|
197
|
|
|
198 // Log will log a message at the level given as parameter.
|
|
|
199 // Warning: using Log at Panic or Fatal level will not respectively Panic nor Exit.
|
|
|
200 // For this behaviour Logger.Panic or Logger.Fatal should be used instead.
|
|
|
201 func (logger *Logger) Log(level Level, args ...interface{}) {
|
|
|
202 if logger.IsLevelEnabled(level) {
|
|
|
203 entry := logger.newEntry()
|
|
|
204 entry.Log(level, args...)
|
|
|
205 logger.releaseEntry(entry)
|
|
|
206 }
|
|
|
207 }
|
|
|
208
|
|
|
209 func (logger *Logger) LogFn(level Level, fn LogFunction) {
|
|
|
210 if logger.IsLevelEnabled(level) {
|
|
|
211 entry := logger.newEntry()
|
|
|
212 entry.Log(level, fn()...)
|
|
|
213 logger.releaseEntry(entry)
|
|
|
214 }
|
|
|
215 }
|
|
|
216
|
|
|
217 func (logger *Logger) Trace(args ...interface{}) {
|
|
|
218 logger.Log(TraceLevel, args...)
|
|
|
219 }
|
|
|
220
|
|
|
221 func (logger *Logger) Debug(args ...interface{}) {
|
|
|
222 logger.Log(DebugLevel, args...)
|
|
|
223 }
|
|
|
224
|
|
|
225 func (logger *Logger) Info(args ...interface{}) {
|
|
|
226 logger.Log(InfoLevel, args...)
|
|
|
227 }
|
|
|
228
|
|
|
229 func (logger *Logger) Print(args ...interface{}) {
|
|
|
230 entry := logger.newEntry()
|
|
|
231 entry.Print(args...)
|
|
|
232 logger.releaseEntry(entry)
|
|
|
233 }
|
|
|
234
|
|
|
235 func (logger *Logger) Warn(args ...interface{}) {
|
|
|
236 logger.Log(WarnLevel, args...)
|
|
|
237 }
|
|
|
238
|
|
|
239 func (logger *Logger) Warning(args ...interface{}) {
|
|
|
240 logger.Warn(args...)
|
|
|
241 }
|
|
|
242
|
|
|
243 func (logger *Logger) Error(args ...interface{}) {
|
|
|
244 logger.Log(ErrorLevel, args...)
|
|
|
245 }
|
|
|
246
|
|
|
247 func (logger *Logger) Fatal(args ...interface{}) {
|
|
|
248 logger.Log(FatalLevel, args...)
|
|
|
249 logger.Exit(1)
|
|
|
250 }
|
|
|
251
|
|
|
252 func (logger *Logger) Panic(args ...interface{}) {
|
|
|
253 logger.Log(PanicLevel, args...)
|
|
|
254 }
|
|
|
255
|
|
|
256 func (logger *Logger) TraceFn(fn LogFunction) {
|
|
|
257 logger.LogFn(TraceLevel, fn)
|
|
|
258 }
|
|
|
259
|
|
|
260 func (logger *Logger) DebugFn(fn LogFunction) {
|
|
|
261 logger.LogFn(DebugLevel, fn)
|
|
|
262 }
|
|
|
263
|
|
|
264 func (logger *Logger) InfoFn(fn LogFunction) {
|
|
|
265 logger.LogFn(InfoLevel, fn)
|
|
|
266 }
|
|
|
267
|
|
|
268 func (logger *Logger) PrintFn(fn LogFunction) {
|
|
|
269 entry := logger.newEntry()
|
|
|
270 entry.Print(fn()...)
|
|
|
271 logger.releaseEntry(entry)
|
|
|
272 }
|
|
|
273
|
|
|
274 func (logger *Logger) WarnFn(fn LogFunction) {
|
|
|
275 logger.LogFn(WarnLevel, fn)
|
|
|
276 }
|
|
|
277
|
|
|
278 func (logger *Logger) WarningFn(fn LogFunction) {
|
|
|
279 logger.WarnFn(fn)
|
|
|
280 }
|
|
|
281
|
|
|
282 func (logger *Logger) ErrorFn(fn LogFunction) {
|
|
|
283 logger.LogFn(ErrorLevel, fn)
|
|
|
284 }
|
|
|
285
|
|
|
286 func (logger *Logger) FatalFn(fn LogFunction) {
|
|
|
287 logger.LogFn(FatalLevel, fn)
|
|
|
288 logger.Exit(1)
|
|
|
289 }
|
|
|
290
|
|
|
291 func (logger *Logger) PanicFn(fn LogFunction) {
|
|
|
292 logger.LogFn(PanicLevel, fn)
|
|
|
293 }
|
|
|
294
|
|
|
295 func (logger *Logger) Logln(level Level, args ...interface{}) {
|
|
|
296 if logger.IsLevelEnabled(level) {
|
|
|
297 entry := logger.newEntry()
|
|
|
298 entry.Logln(level, args...)
|
|
|
299 logger.releaseEntry(entry)
|
|
|
300 }
|
|
|
301 }
|
|
|
302
|
|
|
303 func (logger *Logger) Traceln(args ...interface{}) {
|
|
|
304 logger.Logln(TraceLevel, args...)
|
|
|
305 }
|
|
|
306
|
|
|
307 func (logger *Logger) Debugln(args ...interface{}) {
|
|
|
308 logger.Logln(DebugLevel, args...)
|
|
|
309 }
|
|
|
310
|
|
|
311 func (logger *Logger) Infoln(args ...interface{}) {
|
|
|
312 logger.Logln(InfoLevel, args...)
|
|
|
313 }
|
|
|
314
|
|
|
315 func (logger *Logger) Println(args ...interface{}) {
|
|
|
316 entry := logger.newEntry()
|
|
|
317 entry.Println(args...)
|
|
|
318 logger.releaseEntry(entry)
|
|
|
319 }
|
|
|
320
|
|
|
321 func (logger *Logger) Warnln(args ...interface{}) {
|
|
|
322 logger.Logln(WarnLevel, args...)
|
|
|
323 }
|
|
|
324
|
|
|
325 func (logger *Logger) Warningln(args ...interface{}) {
|
|
|
326 logger.Warnln(args...)
|
|
|
327 }
|
|
|
328
|
|
|
329 func (logger *Logger) Errorln(args ...interface{}) {
|
|
|
330 logger.Logln(ErrorLevel, args...)
|
|
|
331 }
|
|
|
332
|
|
|
333 func (logger *Logger) Fatalln(args ...interface{}) {
|
|
|
334 logger.Logln(FatalLevel, args...)
|
|
|
335 logger.Exit(1)
|
|
|
336 }
|
|
|
337
|
|
|
338 func (logger *Logger) Panicln(args ...interface{}) {
|
|
|
339 logger.Logln(PanicLevel, args...)
|
|
|
340 }
|
|
|
341
|
|
|
342 func (logger *Logger) Exit(code int) {
|
|
|
343 runHandlers()
|
|
|
344 if logger.ExitFunc == nil {
|
|
|
345 logger.ExitFunc = os.Exit
|
|
|
346 }
|
|
|
347 logger.ExitFunc(code)
|
|
|
348 }
|
|
|
349
|
|
|
350 //When file is opened with appending mode, it's safe to
|
|
|
351 //write concurrently to a file (within 4k message on Linux).
|
|
|
352 //In these cases user can choose to disable the lock.
|
|
|
353 func (logger *Logger) SetNoLock() {
|
|
|
354 logger.mu.Disable()
|
|
|
355 }
|
|
|
356
|
|
|
357 func (logger *Logger) level() Level {
|
|
|
358 return Level(atomic.LoadUint32((*uint32)(&logger.Level)))
|
|
|
359 }
|
|
|
360
|
|
|
361 // SetLevel sets the logger level.
|
|
|
362 func (logger *Logger) SetLevel(level Level) {
|
|
|
363 atomic.StoreUint32((*uint32)(&logger.Level), uint32(level))
|
|
|
364 }
|
|
|
365
|
|
|
366 // GetLevel returns the logger level.
|
|
|
367 func (logger *Logger) GetLevel() Level {
|
|
|
368 return logger.level()
|
|
|
369 }
|
|
|
370
|
|
|
371 // AddHook adds a hook to the logger hooks.
|
|
|
372 func (logger *Logger) AddHook(hook Hook) {
|
|
|
373 logger.mu.Lock()
|
|
|
374 defer logger.mu.Unlock()
|
|
|
375 logger.Hooks.Add(hook)
|
|
|
376 }
|
|
|
377
|
|
|
378 // IsLevelEnabled checks if the log level of the logger is greater than the level param
|
|
|
379 func (logger *Logger) IsLevelEnabled(level Level) bool {
|
|
|
380 return logger.level() >= level
|
|
|
381 }
|
|
|
382
|
|
|
383 // SetFormatter sets the logger formatter.
|
|
|
384 func (logger *Logger) SetFormatter(formatter Formatter) {
|
|
|
385 logger.mu.Lock()
|
|
|
386 defer logger.mu.Unlock()
|
|
|
387 logger.Formatter = formatter
|
|
|
388 }
|
|
|
389
|
|
|
390 // SetOutput sets the logger output.
|
|
|
391 func (logger *Logger) SetOutput(output io.Writer) {
|
|
|
392 logger.mu.Lock()
|
|
|
393 defer logger.mu.Unlock()
|
|
|
394 logger.Out = output
|
|
|
395 }
|
|
|
396
|
|
|
397 func (logger *Logger) SetReportCaller(reportCaller bool) {
|
|
|
398 logger.mu.Lock()
|
|
|
399 defer logger.mu.Unlock()
|
|
|
400 logger.ReportCaller = reportCaller
|
|
|
401 }
|
|
|
402
|
|
|
403 // ReplaceHooks replaces the logger hooks and returns the old ones
|
|
|
404 func (logger *Logger) ReplaceHooks(hooks LevelHooks) LevelHooks {
|
|
|
405 logger.mu.Lock()
|
|
|
406 oldHooks := logger.Hooks
|
|
|
407 logger.Hooks = hooks
|
|
|
408 logger.mu.Unlock()
|
|
|
409 return oldHooks
|
|
|
410 }
|
|
|
411
|
|
|
412 // SetBufferPool sets the logger buffer pool.
|
|
|
413 func (logger *Logger) SetBufferPool(pool BufferPool) {
|
|
|
414 logger.mu.Lock()
|
|
|
415 defer logger.mu.Unlock()
|
|
|
416 logger.BufferPool = pool
|
|
|
417 }
|
