1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 package logger
16
17 import (
18 "os"
19 "runtime"
20 "sync"
21 "time"
22 )
23
24
25
26
27 const (
28 OffsetLevel = 10
29
30 TraceLevel = 0
31 DebugLevel = OffsetLevel + TraceLevel
32 InfoLevel = OffsetLevel + DebugLevel
33 NoticeLevel = OffsetLevel + InfoLevel
34 WarningLevel = OffsetLevel + NoticeLevel
35 ErrorLevel = OffsetLevel + WarningLevel
36 CriticalLevel = OffsetLevel + ErrorLevel
37 AlertLevel = OffsetLevel + CriticalLevel
38 FatalLevel = OffsetLevel + AlertLevel
39 PanicLevel = OffsetLevel + FatalLevel
40
41 MinimumLevel = TraceLevel
42 MaximumLevel = PanicLevel
43
44 TraceName = "trace"
45 DebugName = "debug"
46 InfoName = "info"
47 NoticeName = "notice"
48 WarningName = "warning"
49 ErrorName = "error"
50 CriticalName = "critical"
51 AlertName = "alert"
52 FatalName = "fatal"
53 PanicName = "panic"
54
55 DefaultTypeName = "log"
56
57 DefaultErrorCode = 1
58
59 loggerSkipCall = 2
60 )
61
62
63
64
65
66 type Logger struct {
67 name string
68 handlers Handlers
69 idGenerator IDGenerator
70 errorCode int
71 mutex sync.RWMutex
72 }
73
74
75 func New() *Logger {
76 return &Logger{
77 handlers: Handlers{
78 "stdout": NewStdout(),
79 "stderr": NewStderr(),
80 },
81 errorCode: DefaultErrorCode,
82 idGenerator: NewUUID4(),
83 }
84 }
85
86
87 func (l *Logger) Enable() *Logger {
88 l.mutex.Lock()
89 defer l.mutex.Unlock()
90
91 for _, handler := range l.handlers {
92 handler.Enable()
93 }
94
95 return l
96 }
97
98
99 func (l *Logger) Disable() *Logger {
100 l.mutex.Lock()
101 defer l.mutex.Unlock()
102
103 for _, handler := range l.handlers {
104 handler.Disable()
105 }
106
107 return l
108 }
109
110
111 func (l *Logger) IsEnabled() bool {
112 l.mutex.RLock()
113 defer l.mutex.RUnlock()
114
115 for _, handler := range l.handlers {
116 if handler.IsEnabled() {
117 return true
118 }
119 }
120
121 return false
122 }
123
124
125 func (l *Logger) SetLevel(level int) *Logger {
126 l.mutex.Lock()
127 defer l.mutex.Unlock()
128
129 for _, handler := range l.handlers {
130 handler.SetLevel(level)
131 }
132
133 return l
134 }
135
136
137 func (l *Logger) SetMinimumLevel(level int) *Logger {
138 l.mutex.Lock()
139 defer l.mutex.Unlock()
140
141 for _, handler := range l.handlers {
142 handler.SetMinimumLevel(level)
143 }
144
145 return l
146 }
147
148
149 func (l *Logger) SetMaximumLevel(level int) *Logger {
150 l.mutex.Lock()
151 defer l.mutex.Unlock()
152
153 for _, handler := range l.handlers {
154 handler.SetMaximumLevel(level)
155 }
156
157 return l
158 }
159
160
161 func (l *Logger) SetLevelRange(min, max int) *Logger {
162 l.mutex.Lock()
163 defer l.mutex.Unlock()
164
165 for _, handler := range l.handlers {
166 handler.SetLevelRange(min, max)
167 }
168
169 return l
170 }
171
172
173 func (l *Logger) SetFormatter(formatter *Formatter) *Logger {
174 l.mutex.Lock()
175 defer l.mutex.Unlock()
176
177 for _, handler := range l.handlers {
178 handler.SetFormatter(formatter)
179 }
180
181 return l
182 }
183
184
185 func (l *Logger) SetFormat(format string) *Logger {
186 l.mutex.Lock()
187 defer l.mutex.Unlock()
188
189 for _, handler := range l.handlers {
190 handler.GetFormatter().SetFormat(format)
191 }
192
193 return l
194 }
195
196
197 func (l *Logger) SetDateFormat(format string) *Logger {
198 l.mutex.Lock()
199 defer l.mutex.Unlock()
200
201 for _, handler := range l.handlers {
202 handler.GetFormatter().SetDateFormat(format)
203 }
204
205 return l
206 }
207
208
209 func (l *Logger) SetPlaceholder(placeholder string) *Logger {
210 l.mutex.Lock()
211 defer l.mutex.Unlock()
212
213 for _, handler := range l.handlers {
214 handler.GetFormatter().SetPlaceholder(placeholder)
215 }
216
217 return l
218 }
219
220
221 func (l *Logger) AddFuncs(funcs FormatterFuncs) *Logger {
222 l.mutex.Lock()
223 defer l.mutex.Unlock()
224
225 for _, handler := range l.handlers {
226 handler.GetFormatter().AddFuncs(funcs)
227 }
228
229 return l
230 }
231
232
233 func (l *Logger) ResetFormatters() *Logger {
234 l.mutex.Lock()
235 defer l.mutex.Unlock()
236
237 for _, handler := range l.handlers {
238 handler.GetFormatter().Reset()
239 }
240
241 return l
242 }
243
244
245
246 func (l *Logger) SetErrorCode(errorCode int) *Logger {
247 l.mutex.Lock()
248 defer l.mutex.Unlock()
249
250 l.errorCode = errorCode
251
252 return l
253 }
254
255
256 func (l *Logger) GetErrorCode() int {
257 l.mutex.RLock()
258 defer l.mutex.RUnlock()
259
260 return l.errorCode
261 }
262
263
264 func (l *Logger) SetName(name string) *Logger {
265 l.mutex.Lock()
266 defer l.mutex.Unlock()
267
268 l.name = name
269
270 return l
271 }
272
273
274 func (l *Logger) GetName() string {
275 l.mutex.RLock()
276 defer l.mutex.RUnlock()
277
278 return l.name
279 }
280
281
282 func (l *Logger) AddHandler(name string, handler Handler) *Logger {
283 l.mutex.Lock()
284 defer l.mutex.Unlock()
285
286 l.handlers[name] = handler
287
288 return l
289 }
290
291
292
293 func (l *Logger) SetHandler(name string, handler Handler) *Logger {
294 l.mutex.Lock()
295 defer l.mutex.Unlock()
296
297 l.handlers = Handlers{name: handler}
298
299 return l
300 }
301
302
303 func (l *Logger) SetHandlers(handlers Handlers) *Logger {
304 l.mutex.Lock()
305 defer l.mutex.Unlock()
306
307 l.handlers = handlers
308
309 return l
310 }
311
312
313 func (l *Logger) GetHandler(name string) (Handler, error) {
314 l.mutex.RLock()
315 defer l.mutex.RUnlock()
316
317 handler, ok := l.handlers[name]
318
319 if !ok {
320 return nil, NewRuntimeError("cannot get handler", name)
321 }
322
323 return handler, nil
324 }
325
326
327 func (l *Logger) GetHandlers() Handlers {
328 l.mutex.RLock()
329 defer l.mutex.RUnlock()
330
331 return l.handlers
332 }
333
334
335 func (l *Logger) RemoveHandler(name string) *Logger {
336 l.mutex.Lock()
337 defer l.mutex.Unlock()
338
339 delete(l.handlers, name)
340
341 return l
342 }
343
344
345 func (l *Logger) RemoveHandlers() *Logger {
346 l.mutex.Lock()
347 defer l.mutex.Unlock()
348
349 l.handlers = make(Handlers)
350
351 return l
352 }
353
354
355 func (l *Logger) ResetHandlers() *Logger {
356 l.mutex.Lock()
357 defer l.mutex.Unlock()
358
359 l.handlers = Handlers{
360 "stdout": NewStdout(),
361 "stderr": NewStderr(),
362 }
363
364 return l
365 }
366
367
368 func (l *Logger) Reset() *Logger {
369 l.mutex.Lock()
370 defer l.mutex.Unlock()
371
372 l.idGenerator = NewUUID4()
373 l.errorCode = DefaultErrorCode
374 l.handlers = Handlers{
375 "stdout": NewStdout(),
376 "stderr": NewStderr(),
377 }
378
379 return l
380 }
381
382
383
384 func (l *Logger) SetIDGenerator(idGenerator IDGenerator) *Logger {
385 l.mutex.Lock()
386 defer l.mutex.Unlock()
387
388 l.idGenerator = idGenerator
389
390 return l
391 }
392
393
394
395 func (l *Logger) GetIDGenerator() IDGenerator {
396 l.mutex.RLock()
397 defer l.mutex.RUnlock()
398
399 return l.idGenerator
400 }
401
402
403
404
405
406 func (l *Logger) Trace(message string, arguments ...interface{}) {
407 l.LogMessage(TraceLevel, TraceName, message, arguments...)
408 }
409
410
411
412
413 func (l *Logger) Debug(message string, arguments ...interface{}) {
414 l.LogMessage(DebugLevel, DebugName, message, arguments...)
415 }
416
417
418
419
420 func (l *Logger) Info(message string, arguments ...interface{}) {
421 l.LogMessage(InfoLevel, InfoName, message, arguments...)
422 }
423
424
425
426
427 func (l *Logger) Notice(message string, arguments ...interface{}) {
428 l.LogMessage(NoticeLevel, NoticeName, message, arguments...)
429 }
430
431
432
433
434
435 func (l *Logger) Warning(message string, arguments ...interface{}) {
436 l.LogMessage(WarningLevel, WarningName, message, arguments...)
437 }
438
439
440
441
442 func (l *Logger) Error(message string, arguments ...interface{}) {
443 l.LogMessage(ErrorLevel, ErrorName, message, arguments...)
444 }
445
446
447
448
449 func (l *Logger) Critical(message string, arguments ...interface{}) {
450 l.LogMessage(CriticalLevel, CriticalName, message, arguments...)
451 }
452
453
454
455
456 func (l *Logger) Alert(message string, arguments ...interface{}) {
457 l.LogMessage(AlertLevel, AlertName, message, arguments...)
458 }
459
460
461
462
463
464 func (l *Logger) Fatal(message string, arguments ...interface{}) {
465 l.LogMessage(FatalLevel, FatalName, message, arguments...)
466 Close()
467 os.Exit(l.errorCode)
468 }
469
470
471
472
473
474 func (l *Logger) Panic(message string, arguments ...interface{}) {
475 l.LogMessage(PanicLevel, PanicName, message, arguments...)
476 Close()
477 panic(NewRuntimeError("Panic error"))
478 }
479
480
481
482
483
484 func (l *Logger) Log(level int, levelName, message string, arguments ...interface{}) {
485 l.LogMessage(level, levelName, message, arguments...)
486 }
487
488
489 func (l *Logger) Flush() *Logger {
490 GetWorker().Flush()
491
492 return l
493 }
494
495
496 func (l *Logger) Close() error {
497 GetWorker().Flush()
498
499 l.mutex.Lock()
500 defer l.mutex.Unlock()
501
502 var err error
503
504 for _, handler := range l.handlers {
505 handlerError := handler.Close()
506
507 if handlerError != nil {
508 err = NewRuntimeError("cannot close log handler", handlerError)
509 printError(err)
510 }
511 }
512
513 return err
514 }
515
516
517
518
519
520 func (l *Logger) CloseDefer() {
521 if err := l.Close(); err != nil {
522 printError(NewRuntimeError("cannot close logger", err))
523 }
524 }
525
526
527
528
529
530 func (l *Logger) LogMessage(level int, levelName, message string, arguments ...interface{}) {
531 now := time.Now()
532
533 pc, path, line, _ := runtime.Caller(loggerSkipCall)
534
535 GetWorker().records <- &Record{
536 Time: now,
537 Message: message,
538 Arguments: arguments,
539 Level: Level{
540 Name: levelName,
541 Value: level,
542 },
543 File: Source{
544 Line: line,
545 Path: path,
546 Function: runtime.FuncForPC(pc).Name(),
547 },
548 logger: l,
549 }
550 }
551
552
553
554 func (l *Logger) Emit(record *Record) *Logger {
555 record.logger = l
556 GetWorker().records <- record
557
558 return l
559 }
560
View as plain text