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

   1 package logrus
   2
   3 import (
   4         "fmt"
   5         "log"
   6 )
   7
   8 // Fields type, used to pass to `WithFields`.
   9 type Fields map[string]interface{}
  10
  11 // Level type
  12 type Level uint8
  13
  14 // Convert the Level to a string. E.g. PanicLevel becomes "panic".
  15 func (level Level) String() string {
  16         switch level {
  17         case DebugLevel:
  18                 return "debug"
  19         case InfoLevel:
  20                 return "info"
  21         case WarnLevel:
  22                 return "warning"
  23         case ErrorLevel:
  24                 return "error"
  25         case FatalLevel:
  26                 return "fatal"
  27         case PanicLevel:
  28                 return "panic"
  29         }
  30
  31         return "unknown"
  32 }
  33
  34 // ParseLevel takes a string level and returns the Logrus log level constant.
  35 func ParseLevel(lvl string) (Level, error) {
  36         switch lvl {
  37         case "panic":
  38                 return PanicLevel, nil
  39         case "fatal":
  40                 return FatalLevel, nil
  41         case "error":
  42                 return ErrorLevel, nil
  43         case "warn", "warning":
  44                 return WarnLevel, nil
  45         case "info":
  46                 return InfoLevel, nil
  47         case "debug":
  48                 return DebugLevel, nil
  49         }
  50
  51         var l Level
  52         return l, fmt.Errorf("not a valid logrus Level: %q", lvl)
  53 }
  54
  55 // These are the different logging levels. You can set the logging level to log
  56 // on your instance of logger, obtained with `logrus.New()`.
  57 const (
  58         // PanicLevel level, highest level of severity. Logs and then calls panic with the
  59         // message passed to Debug, Info, ...
  60         PanicLevel Level = iota
  61         // FatalLevel level. Logs and then calls `os.Exit(1)`. It will exit even if the
  62         // logging level is set to Panic.
  63         FatalLevel
  64         // ErrorLevel level. Logs. Used for errors that should definitely be noted.
  65         // Commonly used for hooks to send errors to an error tracking service.
  66         ErrorLevel
  67         // WarnLevel level. Non-critical entries that deserve eyes.
  68         WarnLevel
  69         // InfoLevel level. General operational entries about what's going on inside the
  70         // application.
  71         InfoLevel
  72         // DebugLevel level. Usually only enabled when debugging. Very verbose logging.
  73         DebugLevel
  74 )
  75
  76 // Won't compile if StdLogger can't be realized by a log.Logger
  77 var (
  78         _ StdLogger = &log.Logger{}
  79         _ StdLogger = &Entry{}
  80         _ StdLogger = &Logger{}
  81 )
  82
  83 // StdLogger is what your logrus-enabled library should take, that way
  84 // it'll accept a stdlib logger and a logrus logger. There's no standard
  85 // interface, this is the closest we get, unfortunately.
  86 type StdLogger interface {
  87         Print(...interface{})
  88         Printf(string, ...interface{})
  89         Println(...interface{})
  90
  91         Fatal(...interface{})
  92         Fatalf(string, ...interface{})
  93         Fatalln(...interface{})
  94
  95         Panic(...interface{})
  96         Panicf(string, ...interface{})
  97         Panicln(...interface{})
  98 }