vendor/github.com/fsouza/go-dockerclient/external/github.com/Sirupsen/logrus/logger.go

   1 package logrus
   2
   3 import (
   4         "io"
   5         "os"
   6         "sync"
   7 )
   8
   9 type Logger struct {
  10         // The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
  11         // file, or leave it default which is `os.Stderr`. You can also set this to
  12         // something more adventorous, such as logging to Kafka.
  13         Out io.Writer
  14         // Hooks for the logger instance. These allow firing events based on logging
  15         // levels and log entries. For example, to send errors to an error tracking
  16         // service, log to StatsD or dump the core on fatal errors.
  17         Hooks LevelHooks
  18         // All log entries pass through the formatter before logged to Out. The
  19         // included formatters are `TextFormatter` and `JSONFormatter` for which
  20         // TextFormatter is the default. In development (when a TTY is attached) it
  21         // logs with colors, but to a file it wouldn't. You can easily implement your
  22         // own that implements the `Formatter` interface, see the `README` or included
  23         // formatters for examples.
  24         Formatter Formatter
  25         // The logging level the logger should log at. This is typically (and defaults
  26         // to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
  27         // logged. `logrus.Debug` is useful in
  28         Level Level
  29         // Used to sync writing to the log.
  30         mu sync.Mutex
  31 }
  32
  33 // Creates a new logger. Configuration should be set by changing `Formatter`,
  34 // `Out` and `Hooks` directly on the default logger instance. You can also just
  35 // instantiate your own:
  36 //
  37 //    var log = &Logger{
  38 //      Out: os.Stderr,
  39 //      Formatter: new(JSONFormatter),
  40 //      Hooks: make(LevelHooks),
  41 //      Level: logrus.DebugLevel,
  42 //    }
  43 //
  44 // It's recommended to make this a global instance called `log`.
  45 func New() *Logger {
  46         return &Logger{
  47                 Out:       os.Stderr,
  48                 Formatter: new(TextFormatter),
  49                 Hooks:     make(LevelHooks),
  50                 Level:     InfoLevel,
  51         }
  52 }
  53
  54 // Adds a field to the log entry, note that you it doesn't log until you call
  55 // Debug, Print, Info, Warn, Fatal or Panic. It only creates a log entry.
  56 // If you want multiple fields, use `WithFields`.
  57 func (logger *Logger) WithField(key string, value interface{}) *Entry {
  58         return NewEntry(logger).WithField(key, value)
  59 }
  60
  61 // Adds a struct of fields to the log entry. All it does is call `WithField` for
  62 // each `Field`.
  63 func (logger *Logger) WithFields(fields Fields) *Entry {
  64         return NewEntry(logger).WithFields(fields)
  65 }
  66
  67 // Add an error as single field to the log entry.  All it does is call
  68 // `WithError` for the given `error`.
  69 func (logger *Logger) WithError(err error) *Entry {
  70         return NewEntry(logger).WithError(err)
  71 }
  72
  73 func (logger *Logger) Debugf(format string, args ...interface{}) {
  74         if logger.Level >= DebugLevel {
  75                 NewEntry(logger).Debugf(format, args...)
  76         }
  77 }
  78
  79 func (logger *Logger) Infof(format string, args ...interface{}) {
  80         if logger.Level >= InfoLevel {
  81                 NewEntry(logger).Infof(format, args...)
  82         }
  83 }
  84
  85 func (logger *Logger) Printf(format string, args ...interface{}) {
  86         NewEntry(logger).Printf(format, args...)
  87 }
  88
  89 func (logger *Logger) Warnf(format string, args ...interface{}) {
  90         if logger.Level >= WarnLevel {
  91                 NewEntry(logger).Warnf(format, args...)
  92         }
  93 }
  94
  95 func (logger *Logger) Warningf(format string, args ...interface{}) {
  96         if logger.Level >= WarnLevel {
  97                 NewEntry(logger).Warnf(format, args...)
  98         }
  99 }
 100
 101 func (logger *Logger) Errorf(format string, args ...interface{}) {
 102         if logger.Level >= ErrorLevel {
 103                 NewEntry(logger).Errorf(format, args...)
 104         }
 105 }
 106
 107 func (logger *Logger) Fatalf(format string, args ...interface{}) {
 108         if logger.Level >= FatalLevel {
 109                 NewEntry(logger).Fatalf(format, args...)
 110         }
 111         os.Exit(1)
 112 }
 113
 114 func (logger *Logger) Panicf(format string, args ...interface{}) {
 115         if logger.Level >= PanicLevel {
 116                 NewEntry(logger).Panicf(format, args...)
 117         }
 118 }
 119
 120 func (logger *Logger) Debug(args ...interface{}) {
 121         if logger.Level >= DebugLevel {
 122                 NewEntry(logger).Debug(args...)
 123         }
 124 }
 125
 126 func (logger *Logger) Info(args ...interface{}) {
 127         if logger.Level >= InfoLevel {
 128                 NewEntry(logger).Info(args...)
 129         }
 130 }
 131
 132 func (logger *Logger) Print(args ...interface{}) {
 133         NewEntry(logger).Info(args...)
 134 }
 135
 136 func (logger *Logger) Warn(args ...interface{}) {
 137         if logger.Level >= WarnLevel {
 138                 NewEntry(logger).Warn(args...)
 139         }
 140 }
 141
 142 func (logger *Logger) Warning(args ...interface{}) {
 143         if logger.Level >= WarnLevel {
 144                 NewEntry(logger).Warn(args...)
 145         }
 146 }
 147
 148 func (logger *Logger) Error(args ...interface{}) {
 149         if logger.Level >= ErrorLevel {
 150                 NewEntry(logger).Error(args...)
 151         }
 152 }
 153
 154 func (logger *Logger) Fatal(args ...interface{}) {
 155         if logger.Level >= FatalLevel {
 156                 NewEntry(logger).Fatal(args...)
 157         }
 158         os.Exit(1)
 159 }
 160
 161 func (logger *Logger) Panic(args ...interface{}) {
 162         if logger.Level >= PanicLevel {
 163                 NewEntry(logger).Panic(args...)
 164         }
 165 }
 166
 167 func (logger *Logger) Debugln(args ...interface{}) {
 168         if logger.Level >= DebugLevel {
 169                 NewEntry(logger).Debugln(args...)
 170         }
 171 }
 172
 173 func (logger *Logger) Infoln(args ...interface{}) {
 174         if logger.Level >= InfoLevel {
 175                 NewEntry(logger).Infoln(args...)
 176         }
 177 }
 178
 179 func (logger *Logger) Println(args ...interface{}) {
 180         NewEntry(logger).Println(args...)
 181 }
 182
 183 func (logger *Logger) Warnln(args ...interface{}) {
 184         if logger.Level >= WarnLevel {
 185                 NewEntry(logger).Warnln(args...)
 186         }
 187 }
 188
 189 func (logger *Logger) Warningln(args ...interface{}) {
 190         if logger.Level >= WarnLevel {
 191                 NewEntry(logger).Warnln(args...)
 192         }
 193 }
 194
 195 func (logger *Logger) Errorln(args ...interface{}) {
 196         if logger.Level >= ErrorLevel {
 197                 NewEntry(logger).Errorln(args...)
 198         }
 199 }
 200
 201 func (logger *Logger) Fatalln(args ...interface{}) {
 202         if logger.Level >= FatalLevel {
 203                 NewEntry(logger).Fatalln(args...)
 204         }
 205         os.Exit(1)
 206 }
 207
 208 func (logger *Logger) Panicln(args ...interface{}) {
 209         if logger.Level >= PanicLevel {
 210                 NewEntry(logger).Panicln(args...)
 211         }
 212 }