|
66
|
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 }
|
