logger.go raw
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 }
418