diff options
author | Rutger Broekhoff | 2024-01-02 18:56:31 +0100 |
---|---|---|
committer | Rutger Broekhoff | 2024-01-02 18:56:31 +0100 |
commit | 8db41da676ac8368ef7c2549d56239a5ff5eedde (patch) | |
tree | 09c427fd66de2ec1ebffc8342f5fdbb84b0701b5 /vendor/github.com/sirupsen/logrus/exported.go | |
parent | d4f75fb6db22e57577867445a022227e70958931 (diff) | |
download | gitolfs3-8db41da676ac8368ef7c2549d56239a5ff5eedde.tar.gz gitolfs3-8db41da676ac8368ef7c2549d56239a5ff5eedde.zip |
Delete vendor directory
Diffstat (limited to 'vendor/github.com/sirupsen/logrus/exported.go')
-rw-r--r-- | vendor/github.com/sirupsen/logrus/exported.go | 270 |
1 files changed, 0 insertions, 270 deletions
diff --git a/vendor/github.com/sirupsen/logrus/exported.go b/vendor/github.com/sirupsen/logrus/exported.go deleted file mode 100644 index 017c30c..0000000 --- a/vendor/github.com/sirupsen/logrus/exported.go +++ /dev/null | |||
@@ -1,270 +0,0 @@ | |||
1 | package logrus | ||
2 | |||
3 | import ( | ||
4 | "context" | ||
5 | "io" | ||
6 | "time" | ||
7 | ) | ||
8 | |||
9 | var ( | ||
10 | // std is the name of the standard logger in stdlib `log` | ||
11 | std = New() | ||
12 | ) | ||
13 | |||
14 | func StandardLogger() *Logger { | ||
15 | return std | ||
16 | } | ||
17 | |||
18 | // SetOutput sets the standard logger output. | ||
19 | func SetOutput(out io.Writer) { | ||
20 | std.SetOutput(out) | ||
21 | } | ||
22 | |||
23 | // SetFormatter sets the standard logger formatter. | ||
24 | func SetFormatter(formatter Formatter) { | ||
25 | std.SetFormatter(formatter) | ||
26 | } | ||
27 | |||
28 | // SetReportCaller sets whether the standard logger will include the calling | ||
29 | // method as a field. | ||
30 | func SetReportCaller(include bool) { | ||
31 | std.SetReportCaller(include) | ||
32 | } | ||
33 | |||
34 | // SetLevel sets the standard logger level. | ||
35 | func SetLevel(level Level) { | ||
36 | std.SetLevel(level) | ||
37 | } | ||
38 | |||
39 | // GetLevel returns the standard logger level. | ||
40 | func GetLevel() Level { | ||
41 | return std.GetLevel() | ||
42 | } | ||
43 | |||
44 | // IsLevelEnabled checks if the log level of the standard logger is greater than the level param | ||
45 | func IsLevelEnabled(level Level) bool { | ||
46 | return std.IsLevelEnabled(level) | ||
47 | } | ||
48 | |||
49 | // AddHook adds a hook to the standard logger hooks. | ||
50 | func AddHook(hook Hook) { | ||
51 | std.AddHook(hook) | ||
52 | } | ||
53 | |||
54 | // WithError creates an entry from the standard logger and adds an error to it, using the value defined in ErrorKey as key. | ||
55 | func WithError(err error) *Entry { | ||
56 | return std.WithField(ErrorKey, err) | ||
57 | } | ||
58 | |||
59 | // WithContext creates an entry from the standard logger and adds a context to it. | ||
60 | func WithContext(ctx context.Context) *Entry { | ||
61 | return std.WithContext(ctx) | ||
62 | } | ||
63 | |||
64 | // WithField creates an entry from the standard logger and adds a field to | ||
65 | // it. If you want multiple fields, use `WithFields`. | ||
66 | // | ||
67 | // Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal | ||
68 | // or Panic on the Entry it returns. | ||
69 | func WithField(key string, value interface{}) *Entry { | ||
70 | return std.WithField(key, value) | ||
71 | } | ||
72 | |||
73 | // WithFields creates an entry from the standard logger and adds multiple | ||
74 | // fields to it. This is simply a helper for `WithField`, invoking it | ||
75 | // once for each field. | ||
76 | // | ||
77 | // Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal | ||
78 | // or Panic on the Entry it returns. | ||
79 | func WithFields(fields Fields) *Entry { | ||
80 | return std.WithFields(fields) | ||
81 | } | ||
82 | |||
83 | // WithTime creates an entry from the standard logger and overrides the time of | ||
84 | // logs generated with it. | ||
85 | // | ||
86 | // Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal | ||
87 | // or Panic on the Entry it returns. | ||
88 | func WithTime(t time.Time) *Entry { | ||
89 | return std.WithTime(t) | ||
90 | } | ||
91 | |||
92 | // Trace logs a message at level Trace on the standard logger. | ||
93 | func Trace(args ...interface{}) { | ||
94 | std.Trace(args...) | ||
95 | } | ||
96 | |||
97 | // Debug logs a message at level Debug on the standard logger. | ||
98 | func Debug(args ...interface{}) { | ||
99 | std.Debug(args...) | ||
100 | } | ||
101 | |||
102 | // Print logs a message at level Info on the standard logger. | ||
103 | func Print(args ...interface{}) { | ||
104 | std.Print(args...) | ||
105 | } | ||
106 | |||
107 | // Info logs a message at level Info on the standard logger. | ||
108 | func Info(args ...interface{}) { | ||
109 | std.Info(args...) | ||
110 | } | ||
111 | |||
112 | // Warn logs a message at level Warn on the standard logger. | ||
113 | func Warn(args ...interface{}) { | ||
114 | std.Warn(args...) | ||
115 | } | ||
116 | |||
117 | // Warning logs a message at level Warn on the standard logger. | ||
118 | func Warning(args ...interface{}) { | ||
119 | std.Warning(args...) | ||
120 | } | ||
121 | |||
122 | // Error logs a message at level Error on the standard logger. | ||
123 | func Error(args ...interface{}) { | ||
124 | std.Error(args...) | ||
125 | } | ||
126 | |||
127 | // Panic logs a message at level Panic on the standard logger. | ||
128 | func Panic(args ...interface{}) { | ||
129 | std.Panic(args...) | ||
130 | } | ||
131 | |||
132 | // Fatal logs a message at level Fatal on the standard logger then the process will exit with status set to 1. | ||
133 | func Fatal(args ...interface{}) { | ||
134 | std.Fatal(args...) | ||
135 | } | ||
136 | |||
137 | // TraceFn logs a message from a func at level Trace on the standard logger. | ||
138 | func TraceFn(fn LogFunction) { | ||
139 | std.TraceFn(fn) | ||
140 | } | ||
141 | |||
142 | // DebugFn logs a message from a func at level Debug on the standard logger. | ||
143 | func DebugFn(fn LogFunction) { | ||
144 | std.DebugFn(fn) | ||
145 | } | ||
146 | |||
147 | // PrintFn logs a message from a func at level Info on the standard logger. | ||
148 | func PrintFn(fn LogFunction) { | ||
149 | std.PrintFn(fn) | ||
150 | } | ||
151 | |||
152 | // InfoFn logs a message from a func at level Info on the standard logger. | ||
153 | func InfoFn(fn LogFunction) { | ||
154 | std.InfoFn(fn) | ||
155 | } | ||
156 | |||
157 | // WarnFn logs a message from a func at level Warn on the standard logger. | ||
158 | func WarnFn(fn LogFunction) { | ||
159 | std.WarnFn(fn) | ||
160 | } | ||
161 | |||
162 | // WarningFn logs a message from a func at level Warn on the standard logger. | ||
163 | func WarningFn(fn LogFunction) { | ||
164 | std.WarningFn(fn) | ||
165 | } | ||
166 | |||
167 | // ErrorFn logs a message from a func at level Error on the standard logger. | ||
168 | func ErrorFn(fn LogFunction) { | ||
169 | std.ErrorFn(fn) | ||
170 | } | ||
171 | |||
172 | // PanicFn logs a message from a func at level Panic on the standard logger. | ||
173 | func PanicFn(fn LogFunction) { | ||
174 | std.PanicFn(fn) | ||
175 | } | ||
176 | |||
177 | // FatalFn logs a message from a func at level Fatal on the standard logger then the process will exit with status set to 1. | ||
178 | func FatalFn(fn LogFunction) { | ||
179 | std.FatalFn(fn) | ||
180 | } | ||
181 | |||
182 | // Tracef logs a message at level Trace on the standard logger. | ||
183 | func Tracef(format string, args ...interface{}) { | ||
184 | std.Tracef(format, args...) | ||
185 | } | ||
186 | |||
187 | // Debugf logs a message at level Debug on the standard logger. | ||
188 | func Debugf(format string, args ...interface{}) { | ||
189 | std.Debugf(format, args...) | ||
190 | } | ||
191 | |||
192 | // Printf logs a message at level Info on the standard logger. | ||
193 | func Printf(format string, args ...interface{}) { | ||
194 | std.Printf(format, args...) | ||
195 | } | ||
196 | |||
197 | // Infof logs a message at level Info on the standard logger. | ||
198 | func Infof(format string, args ...interface{}) { | ||
199 | std.Infof(format, args...) | ||
200 | } | ||
201 | |||
202 | // Warnf logs a message at level Warn on the standard logger. | ||
203 | func Warnf(format string, args ...interface{}) { | ||
204 | std.Warnf(format, args...) | ||
205 | } | ||
206 | |||
207 | // Warningf logs a message at level Warn on the standard logger. | ||
208 | func Warningf(format string, args ...interface{}) { | ||
209 | std.Warningf(format, args...) | ||
210 | } | ||
211 | |||
212 | // Errorf logs a message at level Error on the standard logger. | ||
213 | func Errorf(format string, args ...interface{}) { | ||
214 | std.Errorf(format, args...) | ||
215 | } | ||
216 | |||
217 | // Panicf logs a message at level Panic on the standard logger. | ||
218 | func Panicf(format string, args ...interface{}) { | ||
219 | std.Panicf(format, args...) | ||
220 | } | ||
221 | |||
222 | // Fatalf logs a message at level Fatal on the standard logger then the process will exit with status set to 1. | ||
223 | func Fatalf(format string, args ...interface{}) { | ||
224 | std.Fatalf(format, args...) | ||
225 | } | ||
226 | |||
227 | // Traceln logs a message at level Trace on the standard logger. | ||
228 | func Traceln(args ...interface{}) { | ||
229 | std.Traceln(args...) | ||
230 | } | ||
231 | |||
232 | // Debugln logs a message at level Debug on the standard logger. | ||
233 | func Debugln(args ...interface{}) { | ||
234 | std.Debugln(args...) | ||
235 | } | ||
236 | |||
237 | // Println logs a message at level Info on the standard logger. | ||
238 | func Println(args ...interface{}) { | ||
239 | std.Println(args...) | ||
240 | } | ||
241 | |||
242 | // Infoln logs a message at level Info on the standard logger. | ||
243 | func Infoln(args ...interface{}) { | ||
244 | std.Infoln(args...) | ||
245 | } | ||
246 | |||
247 | // Warnln logs a message at level Warn on the standard logger. | ||
248 | func Warnln(args ...interface{}) { | ||
249 | std.Warnln(args...) | ||
250 | } | ||
251 | |||
252 | // Warningln logs a message at level Warn on the standard logger. | ||
253 | func Warningln(args ...interface{}) { | ||
254 | std.Warningln(args...) | ||
255 | } | ||
256 | |||
257 | // Errorln logs a message at level Error on the standard logger. | ||
258 | func Errorln(args ...interface{}) { | ||
259 | std.Errorln(args...) | ||
260 | } | ||
261 | |||
262 | // Panicln logs a message at level Panic on the standard logger. | ||
263 | func Panicln(args ...interface{}) { | ||
264 | std.Panicln(args...) | ||
265 | } | ||
266 | |||
267 | // Fatalln logs a message at level Fatal on the standard logger then the process will exit with status set to 1. | ||
268 | func Fatalln(args ...interface{}) { | ||
269 | std.Fatalln(args...) | ||
270 | } | ||