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