PageRenderTime 48ms CodeModel.GetById 13ms RepoModel.GetById 0ms app.codeStats 0ms

/Godeps/_workspace/src/github.com/fsouza/go-dockerclient/vendor/github.com/Sirupsen/logrus/logger.go

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