github.com/kayoticsully/syncthing@v0.8.9-0.20140724133906-c45a2fdc03f8/logger/logger.go (about)

     1  // Copyright (C) 2014 Jakob Borg and Contributors (see the CONTRIBUTORS file).
     2  // All rights reserved. Use of this source code is governed by an MIT-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Package logger implements a standardized logger with callback functionality
     6  package logger
     7  
     8  import (
     9  	"fmt"
    10  	"log"
    11  	"os"
    12  	"sync"
    13  )
    14  
    15  type LogLevel int
    16  
    17  const (
    18  	LevelDebug LogLevel = iota
    19  	LevelInfo
    20  	LevelOK
    21  	LevelWarn
    22  	LevelFatal
    23  	NumLevels
    24  )
    25  
    26  type MessageHandler func(l LogLevel, msg string)
    27  
    28  type Logger struct {
    29  	logger   *log.Logger
    30  	handlers [NumLevels][]MessageHandler
    31  	mut      sync.Mutex
    32  }
    33  
    34  var DefaultLogger = New()
    35  
    36  func New() *Logger {
    37  	return &Logger{
    38  		logger: log.New(os.Stdout, "", log.Ltime),
    39  	}
    40  }
    41  
    42  func (l *Logger) AddHandler(level LogLevel, h MessageHandler) {
    43  	l.mut.Lock()
    44  	defer l.mut.Unlock()
    45  	l.handlers[level] = append(l.handlers[level], h)
    46  }
    47  
    48  func (l *Logger) SetFlags(flag int) {
    49  	l.logger.SetFlags(flag)
    50  }
    51  
    52  func (l *Logger) SetPrefix(prefix string) {
    53  	l.logger.SetPrefix(prefix)
    54  }
    55  
    56  func (l *Logger) callHandlers(level LogLevel, s string) {
    57  	for _, h := range l.handlers[level] {
    58  		h(level, s)
    59  	}
    60  }
    61  
    62  func (l *Logger) Debugln(vals ...interface{}) {
    63  	l.mut.Lock()
    64  	defer l.mut.Unlock()
    65  	s := fmt.Sprintln(vals...)
    66  	l.logger.Output(2, "DEBUG: "+s)
    67  	l.callHandlers(LevelDebug, s)
    68  }
    69  
    70  func (l *Logger) Debugf(format string, vals ...interface{}) {
    71  	l.mut.Lock()
    72  	defer l.mut.Unlock()
    73  	s := fmt.Sprintf(format, vals...)
    74  	l.logger.Output(2, "DEBUG: "+s)
    75  	l.callHandlers(LevelDebug, s)
    76  }
    77  func (l *Logger) Infoln(vals ...interface{}) {
    78  	l.mut.Lock()
    79  	defer l.mut.Unlock()
    80  	s := fmt.Sprintln(vals...)
    81  	l.logger.Output(2, "INFO: "+s)
    82  	l.callHandlers(LevelInfo, s)
    83  }
    84  
    85  func (l *Logger) Infof(format string, vals ...interface{}) {
    86  	l.mut.Lock()
    87  	defer l.mut.Unlock()
    88  	s := fmt.Sprintf(format, vals...)
    89  	l.logger.Output(2, "INFO: "+s)
    90  	l.callHandlers(LevelInfo, s)
    91  }
    92  
    93  func (l *Logger) Okln(vals ...interface{}) {
    94  	l.mut.Lock()
    95  	defer l.mut.Unlock()
    96  	s := fmt.Sprintln(vals...)
    97  	l.logger.Output(2, "OK: "+s)
    98  	l.callHandlers(LevelOK, s)
    99  }
   100  
   101  func (l *Logger) Okf(format string, vals ...interface{}) {
   102  	l.mut.Lock()
   103  	defer l.mut.Unlock()
   104  	s := fmt.Sprintf(format, vals...)
   105  	l.logger.Output(2, "OK: "+s)
   106  	l.callHandlers(LevelOK, s)
   107  }
   108  
   109  func (l *Logger) Warnln(vals ...interface{}) {
   110  	l.mut.Lock()
   111  	defer l.mut.Unlock()
   112  	s := fmt.Sprintln(vals...)
   113  	l.logger.Output(2, "WARNING: "+s)
   114  	l.callHandlers(LevelWarn, s)
   115  }
   116  
   117  func (l *Logger) Warnf(format string, vals ...interface{}) {
   118  	l.mut.Lock()
   119  	defer l.mut.Unlock()
   120  	s := fmt.Sprintf(format, vals...)
   121  	l.logger.Output(2, "WARNING: "+s)
   122  	l.callHandlers(LevelWarn, s)
   123  }
   124  
   125  func (l *Logger) Fatalln(vals ...interface{}) {
   126  	l.mut.Lock()
   127  	defer l.mut.Unlock()
   128  	s := fmt.Sprintln(vals...)
   129  	l.logger.Output(2, "FATAL: "+s)
   130  	l.callHandlers(LevelFatal, s)
   131  	os.Exit(3)
   132  }
   133  
   134  func (l *Logger) Fatalf(format string, vals ...interface{}) {
   135  	l.mut.Lock()
   136  	defer l.mut.Unlock()
   137  	s := fmt.Sprintf(format, vals...)
   138  	l.logger.Output(2, "FATAL: "+s)
   139  	l.callHandlers(LevelFatal, s)
   140  	os.Exit(3)
   141  }
   142  
   143  func (l *Logger) FatalErr(err error) {
   144  	if err != nil {
   145  		l.mut.Lock()
   146  		defer l.mut.Unlock()
   147  		l.logger.SetFlags(l.logger.Flags() | log.Lshortfile)
   148  		l.logger.Output(2, "FATAL: "+err.Error())
   149  		l.callHandlers(LevelFatal, err.Error())
   150  		os.Exit(3)
   151  	}
   152  }