1package logrus 2 3import ( 4 "fmt" 5 "log" 6 "strings" 7) 8 9// Fields type, used to pass to `WithFields`. 10type Fields map[string]interface{} 11 12// Level type 13type Level uint32 14 15// Convert the Level to a string. E.g. PanicLevel becomes "panic". 16func (level Level) String() string { 17 switch level { 18 case DebugLevel: 19 return "debug" 20 case InfoLevel: 21 return "info" 22 case WarnLevel: 23 return "warning" 24 case ErrorLevel: 25 return "error" 26 case FatalLevel: 27 return "fatal" 28 case PanicLevel: 29 return "panic" 30 } 31 32 return "unknown" 33} 34 35// ParseLevel takes a string level and returns the Logrus log level constant. 36func ParseLevel(lvl string) (Level, error) { 37 switch strings.ToLower(lvl) { 38 case "panic": 39 return PanicLevel, nil 40 case "fatal": 41 return FatalLevel, nil 42 case "error": 43 return ErrorLevel, nil 44 case "warn", "warning": 45 return WarnLevel, nil 46 case "info": 47 return InfoLevel, nil 48 case "debug": 49 return DebugLevel, nil 50 } 51 52 var l Level 53 return l, fmt.Errorf("not a valid logrus Level: %q", lvl) 54} 55 56// A constant exposing all logging levels 57var AllLevels = []Level{ 58 PanicLevel, 59 FatalLevel, 60 ErrorLevel, 61 WarnLevel, 62 InfoLevel, 63 DebugLevel, 64} 65 66// These are the different logging levels. You can set the logging level to log 67// on your instance of logger, obtained with `logrus.New()`. 68const ( 69 // PanicLevel level, highest level of severity. Logs and then calls panic with the 70 // message passed to Debug, Info, ... 71 PanicLevel Level = iota 72 // FatalLevel level. Logs and then calls `os.Exit(1)`. It will exit even if the 73 // logging level is set to Panic. 74 FatalLevel 75 // ErrorLevel level. Logs. Used for errors that should definitely be noted. 76 // Commonly used for hooks to send errors to an error tracking service. 77 ErrorLevel 78 // WarnLevel level. Non-critical entries that deserve eyes. 79 WarnLevel 80 // InfoLevel level. General operational entries about what's going on inside the 81 // application. 82 InfoLevel 83 // DebugLevel level. Usually only enabled when debugging. Very verbose logging. 84 DebugLevel 85) 86 87// Won't compile if StdLogger can't be realized by a log.Logger 88var ( 89 _ StdLogger = &log.Logger{} 90 _ StdLogger = &Entry{} 91 _ StdLogger = &Logger{} 92) 93 94// StdLogger is what your logrus-enabled library should take, that way 95// it'll accept a stdlib logger and a logrus logger. There's no standard 96// interface, this is the closest we get, unfortunately. 97type StdLogger interface { 98 Print(...interface{}) 99 Printf(string, ...interface{}) 100 Println(...interface{}) 101 102 Fatal(...interface{}) 103 Fatalf(string, ...interface{}) 104 Fatalln(...interface{}) 105 106 Panic(...interface{}) 107 Panicf(string, ...interface{}) 108 Panicln(...interface{}) 109} 110 111// The FieldLogger interface generalizes the Entry and Logger types 112type FieldLogger interface { 113 WithField(key string, value interface{}) *Entry 114 WithFields(fields Fields) *Entry 115 WithError(err error) *Entry 116 117 Debugf(format string, args ...interface{}) 118 Infof(format string, args ...interface{}) 119 Printf(format string, args ...interface{}) 120 Warnf(format string, args ...interface{}) 121 Warningf(format string, args ...interface{}) 122 Errorf(format string, args ...interface{}) 123 Fatalf(format string, args ...interface{}) 124 Panicf(format string, args ...interface{}) 125 126 Debug(args ...interface{}) 127 Info(args ...interface{}) 128 Print(args ...interface{}) 129 Warn(args ...interface{}) 130 Warning(args ...interface{}) 131 Error(args ...interface{}) 132 Fatal(args ...interface{}) 133 Panic(args ...interface{}) 134 135 Debugln(args ...interface{}) 136 Infoln(args ...interface{}) 137 Println(args ...interface{}) 138 Warnln(args ...interface{}) 139 Warningln(args ...interface{}) 140 Errorln(args ...interface{}) 141 Fatalln(args ...interface{}) 142 Panicln(args ...interface{}) 143} 144