Matteo Scandolo | a6a3aee | 2019-11-26 13:30:14 -0700 | [diff] [blame] | 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 = 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 | } |