traefik/vendor/github.com/sirupsen/logrus/text_formatter.go

250 lines
6 KiB
Go
Raw Normal View History

2017-02-07 21:33:23 +00:00
package logrus
import (
"bytes"
"fmt"
2018-10-02 14:28:04 +00:00
"os"
2017-02-07 21:33:23 +00:00
"sort"
"strings"
"sync"
2017-02-07 21:33:23 +00:00
"time"
)
const (
nocolor = 0
red = 31
green = 32
yellow = 33
2018-01-22 11:16:03 +00:00
blue = 36
2017-02-07 21:33:23 +00:00
gray = 37
)
var (
baseTimestamp time.Time
2018-10-02 14:28:04 +00:00
emptyFieldMap FieldMap
2017-02-07 21:33:23 +00:00
)
func init() {
baseTimestamp = time.Now()
}
2018-01-22 11:16:03 +00:00
// TextFormatter formats logs into text
2017-02-07 21:33:23 +00:00
type TextFormatter struct {
// Set to true to bypass checking for a TTY before outputting colors.
ForceColors bool
// Force disabling colors.
DisableColors bool
2018-10-02 14:28:04 +00:00
// Override coloring based on CLICOLOR and CLICOLOR_FORCE. - https://bixense.com/clicolors/
EnvironmentOverrideColors bool
2017-02-07 21:33:23 +00:00
// Disable timestamp logging. useful when output is redirected to logging
// system that already adds timestamps.
DisableTimestamp bool
// Enable logging the full timestamp when a TTY is attached instead of just
// the time passed since beginning of execution.
FullTimestamp bool
// TimestampFormat to use for display when a full timestamp is printed
TimestampFormat string
// The fields are sorted by default for a consistent output. For applications
// that log extremely frequently and don't use the JSON formatter this may not
// be desired.
DisableSorting bool
2018-10-02 14:28:04 +00:00
// The keys sorting function, when uninitialized it uses sort.Strings.
SortingFunc func([]string)
// Disables the truncation of the level text to 4 characters.
DisableLevelTruncation bool
// QuoteEmptyFields will wrap empty fields in quotes if true
QuoteEmptyFields bool
// Whether the logger's out is to a terminal
isTerminal bool
2018-10-02 14:28:04 +00:00
// FieldMap allows users to customize the names of keys for default fields.
// As an example:
// formatter := &TextFormatter{
// FieldMap: FieldMap{
// FieldKeyTime: "@timestamp",
// FieldKeyLevel: "@level",
// FieldKeyMsg: "@message"}}
FieldMap FieldMap
terminalInitOnce sync.Once
}
func (f *TextFormatter) init(entry *Entry) {
if entry.Logger != nil {
2018-01-22 11:16:03 +00:00
f.isTerminal = checkIfTerminal(entry.Logger.Out)
2018-10-02 14:28:04 +00:00
if f.isTerminal {
initTerminal(entry.Logger.Out)
}
}
}
func (f *TextFormatter) isColored() bool {
isColored := f.ForceColors || f.isTerminal
if f.EnvironmentOverrideColors {
if force, ok := os.LookupEnv("CLICOLOR_FORCE"); ok && force != "0" {
isColored = true
} else if ok && force == "0" {
isColored = false
} else if os.Getenv("CLICOLOR") == "0" {
isColored = false
}
}
2018-10-02 14:28:04 +00:00
return isColored && !f.DisableColors
2017-02-07 21:33:23 +00:00
}
2018-01-22 11:16:03 +00:00
// Format renders a single log entry
2017-02-07 21:33:23 +00:00
func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
2018-10-02 14:28:04 +00:00
prefixFieldClashes(entry.Data, f.FieldMap)
keys := make([]string, 0, len(entry.Data))
2017-02-07 21:33:23 +00:00
for k := range entry.Data {
keys = append(keys, k)
}
2018-10-02 14:28:04 +00:00
fixedKeys := make([]string, 0, 3+len(entry.Data))
if !f.DisableTimestamp {
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyTime))
}
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLevel))
if entry.Message != "" {
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyMsg))
}
2017-02-07 21:33:23 +00:00
if !f.DisableSorting {
2018-10-02 14:28:04 +00:00
if f.SortingFunc == nil {
sort.Strings(keys)
fixedKeys = append(fixedKeys, keys...)
} else {
if !f.isColored() {
fixedKeys = append(fixedKeys, keys...)
f.SortingFunc(fixedKeys)
} else {
f.SortingFunc(keys)
}
}
} else {
fixedKeys = append(fixedKeys, keys...)
2017-02-07 21:33:23 +00:00
}
2018-10-02 14:28:04 +00:00
var b *bytes.Buffer
if entry.Buffer != nil {
b = entry.Buffer
} else {
b = &bytes.Buffer{}
}
2017-02-07 21:33:23 +00:00
2018-10-02 14:28:04 +00:00
f.terminalInitOnce.Do(func() { f.init(entry) })
2017-02-07 21:33:23 +00:00
timestampFormat := f.TimestampFormat
if timestampFormat == "" {
2018-01-22 11:16:03 +00:00
timestampFormat = defaultTimestampFormat
2017-02-07 21:33:23 +00:00
}
2018-10-02 14:28:04 +00:00
if f.isColored() {
2017-02-07 21:33:23 +00:00
f.printColored(b, entry, keys, timestampFormat)
} else {
2018-10-02 14:28:04 +00:00
for _, key := range fixedKeys {
var value interface{}
switch key {
case f.FieldMap.resolve(FieldKeyTime):
value = entry.Time.Format(timestampFormat)
case f.FieldMap.resolve(FieldKeyLevel):
value = entry.Level.String()
case f.FieldMap.resolve(FieldKeyMsg):
value = entry.Message
default:
value = entry.Data[key]
}
f.appendKeyValue(b, key, value)
2017-02-07 21:33:23 +00:00
}
}
b.WriteByte('\n')
return b.Bytes(), nil
}
func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, timestampFormat string) {
var levelColor int
switch entry.Level {
case DebugLevel:
levelColor = gray
case WarnLevel:
levelColor = yellow
case ErrorLevel, FatalLevel, PanicLevel:
levelColor = red
default:
levelColor = blue
}
2018-10-02 14:28:04 +00:00
levelText := strings.ToUpper(entry.Level.String())
if !f.DisableLevelTruncation {
levelText = levelText[0:4]
}
// Remove a single newline if it already exists in the message to keep
// the behavior of logrus text_formatter the same as the stdlib log package
entry.Message = strings.TrimSuffix(entry.Message, "\n")
2017-02-07 21:33:23 +00:00
if f.DisableTimestamp {
fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m %-44s ", levelColor, levelText, entry.Message)
} else if !f.FullTimestamp {
fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d] %-44s ", levelColor, levelText, int(entry.Time.Sub(baseTimestamp)/time.Second), entry.Message)
2017-02-07 21:33:23 +00:00
} else {
fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s] %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), entry.Message)
}
for _, k := range keys {
v := entry.Data[k]
fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=", levelColor, k)
f.appendValue(b, v)
2017-02-07 21:33:23 +00:00
}
}
func (f *TextFormatter) needsQuoting(text string) bool {
if f.QuoteEmptyFields && len(text) == 0 {
return true
}
2017-02-07 21:33:23 +00:00
for _, ch := range text {
if !((ch >= 'a' && ch <= 'z') ||
(ch >= 'A' && ch <= 'Z') ||
(ch >= '0' && ch <= '9') ||
2018-01-22 11:16:03 +00:00
ch == '-' || ch == '.' || ch == '_' || ch == '/' || ch == '@' || ch == '^' || ch == '+') {
2017-02-07 21:33:23 +00:00
return true
}
}
return false
}
func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) {
2018-01-22 11:16:03 +00:00
if b.Len() > 0 {
b.WriteByte(' ')
}
2017-02-07 21:33:23 +00:00
b.WriteString(key)
b.WriteByte('=')
f.appendValue(b, value)
}
2017-02-07 21:33:23 +00:00
func (f *TextFormatter) appendValue(b *bytes.Buffer, value interface{}) {
2018-01-22 11:16:03 +00:00
stringVal, ok := value.(string)
if !ok {
stringVal = fmt.Sprint(value)
}
if !f.needsQuoting(stringVal) {
b.WriteString(stringVal)
} else {
b.WriteString(fmt.Sprintf("%q", stringVal))
2017-02-07 21:33:23 +00:00
}
}