podman

1
package logrus
2

3
import (
4
	"bytes"
5
	"fmt"
6
	"os"
7
	"runtime"
8
	"sort"
9
	"strconv"
10
	"strings"
11
	"sync"
12
	"time"
13
	"unicode/utf8"
14
)
15

16
const (
17
	red    = 31
18
	yellow = 33
19
	blue   = 36
20
	gray   = 37
21
)
22

23
var baseTimestamp time.Time
24

25
func init() {
26
	baseTimestamp = time.Now()
27
}
28

29
// TextFormatter formats logs into text
30
type TextFormatter struct {
31
	// Set to true to bypass checking for a TTY before outputting colors.
32
	ForceColors bool
33

34
	// Force disabling colors.
35
	DisableColors bool
36

37
	// Force quoting of all values
38
	ForceQuote bool
39

40
	// DisableQuote disables quoting for all values.
41
	// DisableQuote will have a lower priority than ForceQuote.
42
	// If both of them are set to true, quote will be forced on all values.
43
	DisableQuote bool
44

45
	// Override coloring based on CLICOLOR and CLICOLOR_FORCE. - https://bixense.com/clicolors/
46
	EnvironmentOverrideColors bool
47

48
	// Disable timestamp logging. useful when output is redirected to logging
49
	// system that already adds timestamps.
50
	DisableTimestamp bool
51

52
	// Enable logging the full timestamp when a TTY is attached instead of just
53
	// the time passed since beginning of execution.
54
	FullTimestamp bool
55

56
	// TimestampFormat to use for display when a full timestamp is printed.
57
	// The format to use is the same than for time.Format or time.Parse from the standard
58
	// library.
59
	// The standard Library already provides a set of predefined format.
60
	TimestampFormat string
61

62
	// The fields are sorted by default for a consistent output. For applications
63
	// that log extremely frequently and don't use the JSON formatter this may not
64
	// be desired.
65
	DisableSorting bool
66

67
	// The keys sorting function, when uninitialized it uses sort.Strings.
68
	SortingFunc func([]string)
69

70
	// Disables the truncation of the level text to 4 characters.
71
	DisableLevelTruncation bool
72

73
	// PadLevelText Adds padding the level text so that all the levels output at the same length
74
	// PadLevelText is a superset of the DisableLevelTruncation option
75
	PadLevelText bool
76

77
	// QuoteEmptyFields will wrap empty fields in quotes if true
78
	QuoteEmptyFields bool
79

80
	// Whether the logger's out is to a terminal
81
	isTerminal bool
82

83
	// FieldMap allows users to customize the names of keys for default fields.
84
	// As an example:
85
	// formatter := &TextFormatter{
86
	//     FieldMap: FieldMap{
87
	//         FieldKeyTime:  "@timestamp",
88
	//         FieldKeyLevel: "@level",
89
	//         FieldKeyMsg:   "@message"}}
90
	FieldMap FieldMap
91

92
	// CallerPrettyfier can be set by the user to modify the content
93
	// of the function and file keys in the data when ReportCaller is
94
	// activated. If any of the returned value is the empty string the
95
	// corresponding key will be removed from fields.
96
	CallerPrettyfier func(*runtime.Frame) (function string, file string)
97

98
	terminalInitOnce sync.Once
99

100
	// The max length of the level text, generated dynamically on init
101
	levelTextMaxLength int
102
}
103

104
func (f *TextFormatter) init(entry *Entry) {
105
	if entry.Logger != nil {
106
		f.isTerminal = checkIfTerminal(entry.Logger.Out)
107
	}
108
	// Get the max length of the level text
109
	for _, level := range AllLevels {
110
		levelTextLength := utf8.RuneCount([]byte(level.String()))
111
		if levelTextLength > f.levelTextMaxLength {
112
			f.levelTextMaxLength = levelTextLength
113
		}
114
	}
115
}
116

117
func (f *TextFormatter) isColored() bool {
118
	isColored := f.ForceColors || (f.isTerminal && (runtime.GOOS != "windows"))
119

120
	if f.EnvironmentOverrideColors {
121
		switch force, ok := os.LookupEnv("CLICOLOR_FORCE"); {
122
		case ok && force != "0":
123
			isColored = true
124
		case ok && force == "0", os.Getenv("CLICOLOR") == "0":
125
			isColored = false
126
		}
127
	}
128

129
	return isColored && !f.DisableColors
130
}
131

132
// Format renders a single log entry
133
func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
134
	data := make(Fields)
135
	for k, v := range entry.Data {
136
		data[k] = v
137
	}
138
	prefixFieldClashes(data, f.FieldMap, entry.HasCaller())
139
	keys := make([]string, 0, len(data))
140
	for k := range data {
141
		keys = append(keys, k)
142
	}
143

144
	var funcVal, fileVal string
145

146
	fixedKeys := make([]string, 0, 4+len(data))
147
	if !f.DisableTimestamp {
148
		fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyTime))
149
	}
150
	fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLevel))
151
	if entry.Message != "" {
152
		fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyMsg))
153
	}
154
	if entry.err != "" {
155
		fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLogrusError))
156
	}
157
	if entry.HasCaller() {
158
		if f.CallerPrettyfier != nil {
159
			funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
160
		} else {
161
			funcVal = entry.Caller.Function
162
			fileVal = fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
163
		}
164

165
		if funcVal != "" {
166
			fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFunc))
167
		}
168
		if fileVal != "" {
169
			fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFile))
170
		}
171
	}
172

173
	if !f.DisableSorting {
174
		if f.SortingFunc == nil {
175
			sort.Strings(keys)
176
			fixedKeys = append(fixedKeys, keys...)
177
		} else {
178
			if !f.isColored() {
179
				fixedKeys = append(fixedKeys, keys...)
180
				f.SortingFunc(fixedKeys)
181
			} else {
182
				f.SortingFunc(keys)
183
			}
184
		}
185
	} else {
186
		fixedKeys = append(fixedKeys, keys...)
187
	}
188

189
	var b *bytes.Buffer
190
	if entry.Buffer != nil {
191
		b = entry.Buffer
192
	} else {
193
		b = &bytes.Buffer{}
194
	}
195

196
	f.terminalInitOnce.Do(func() { f.init(entry) })
197

198
	timestampFormat := f.TimestampFormat
199
	if timestampFormat == "" {
200
		timestampFormat = defaultTimestampFormat
201
	}
202
	if f.isColored() {
203
		f.printColored(b, entry, keys, data, timestampFormat)
204
	} else {
205

206
		for _, key := range fixedKeys {
207
			var value interface{}
208
			switch {
209
			case key == f.FieldMap.resolve(FieldKeyTime):
210
				value = entry.Time.Format(timestampFormat)
211
			case key == f.FieldMap.resolve(FieldKeyLevel):
212
				value = entry.Level.String()
213
			case key == f.FieldMap.resolve(FieldKeyMsg):
214
				value = entry.Message
215
			case key == f.FieldMap.resolve(FieldKeyLogrusError):
216
				value = entry.err
217
			case key == f.FieldMap.resolve(FieldKeyFunc) && entry.HasCaller():
218
				value = funcVal
219
			case key == f.FieldMap.resolve(FieldKeyFile) && entry.HasCaller():
220
				value = fileVal
221
			default:
222
				value = data[key]
223
			}
224
			f.appendKeyValue(b, key, value)
225
		}
226
	}
227

228
	b.WriteByte('\n')
229
	return b.Bytes(), nil
230
}
231

232
func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, data Fields, timestampFormat string) {
233
	var levelColor int
234
	switch entry.Level {
235
	case DebugLevel, TraceLevel:
236
		levelColor = gray
237
	case WarnLevel:
238
		levelColor = yellow
239
	case ErrorLevel, FatalLevel, PanicLevel:
240
		levelColor = red
241
	case InfoLevel:
242
		levelColor = blue
243
	default:
244
		levelColor = blue
245
	}
246

247
	levelText := strings.ToUpper(entry.Level.String())
248
	if !f.DisableLevelTruncation && !f.PadLevelText {
249
		levelText = levelText[0:4]
250
	}
251
	if f.PadLevelText {
252
		// Generates the format string used in the next line, for example "%-6s" or "%-7s".
253
		// Based on the max level text length.
254
		formatString := "%-" + strconv.Itoa(f.levelTextMaxLength) + "s"
255
		// Formats the level text by appending spaces up to the max length, for example:
256
		// 	- "INFO   "
257
		//	- "WARNING"
258
		levelText = fmt.Sprintf(formatString, levelText)
259
	}
260

261
	// Remove a single newline if it already exists in the message to keep
262
	// the behavior of logrus text_formatter the same as the stdlib log package
263
	entry.Message = strings.TrimSuffix(entry.Message, "\n")
264

265
	caller := ""
266
	if entry.HasCaller() {
267
		funcVal := fmt.Sprintf("%s()", entry.Caller.Function)
268
		fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
269

270
		if f.CallerPrettyfier != nil {
271
			funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
272
		}
273

274
		if fileVal == "" {
275
			caller = funcVal
276
		} else if funcVal == "" {
277
			caller = fileVal
278
		} else {
279
			caller = fileVal + " " + funcVal
280
		}
281
	}
282

283
	switch {
284
	case f.DisableTimestamp:
285
		fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m%s %-44s ", levelColor, levelText, caller, entry.Message)
286
	case !f.FullTimestamp:
287
		fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d]%s %-44s ", levelColor, levelText, int(entry.Time.Sub(baseTimestamp)/time.Second), caller, entry.Message)
288
	default:
289
		fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s]%s %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), caller, entry.Message)
290
	}
291
	for _, k := range keys {
292
		v := data[k]
293
		fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=", levelColor, k)
294
		f.appendValue(b, v)
295
	}
296
}
297

298
func (f *TextFormatter) needsQuoting(text string) bool {
299
	if f.ForceQuote {
300
		return true
301
	}
302
	if f.QuoteEmptyFields && len(text) == 0 {
303
		return true
304
	}
305
	if f.DisableQuote {
306
		return false
307
	}
308
	for _, ch := range text {
309
		if !((ch >= 'a' && ch <= 'z') ||
310
			(ch >= 'A' && ch <= 'Z') ||
311
			(ch >= '0' && ch <= '9') ||
312
			ch == '-' || ch == '.' || ch == '_' || ch == '/' || ch == '@' || ch == '^' || ch == '+') {
313
			return true
314
		}
315
	}
316
	return false
317
}
318

319
func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) {
320
	if b.Len() > 0 {
321
		b.WriteByte(' ')
322
	}
323
	b.WriteString(key)
324
	b.WriteByte('=')
325
	f.appendValue(b, value)
326
}
327

328
func (f *TextFormatter) appendValue(b *bytes.Buffer, value interface{}) {
329
	stringVal, ok := value.(string)
330
	if !ok {
331
		stringVal = fmt.Sprint(value)
332
	}
333

334
	if !f.needsQuoting(stringVal) {
335
		b.WriteString(stringVal)
336
	} else {
337
		b.WriteString(fmt.Sprintf("%q", stringVal))
338
	}
339
}
340