Mercurial > yakumo_izuru > aya

comparison vendor/github.com/sirupsen/logrus/logrus.go @ 66:787b5ee0289d draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Use vendored modules Signed-off-by: Izuru Yakumo <yakumo.izuru@chaotic.ninja>
author yakumo.izuru
date Sun, 23 Jul 2023 13:18:53 +0000
parents
children
comparison
equal deleted inserted replaced
65:6d985efa0f7a 66:787b5ee0289d
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 }