podman

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