fermentord/vendor/github.com/mgutz/logxi/v1/happyDevFormatter.go
Søren Rasmussen 07a23c1845
Some checks reported errors
continuous-integration/drone/push Build encountered an error
Upgrade to go 1.20 and add vendor catalog
2023-04-22 10:37:23 +02:00

373 lines
8.8 KiB
Go

package log
import (
"encoding/json"
"fmt"
"io"
"runtime/debug"
"strings"
"github.com/mgutz/ansi"
)
// colorScheme defines a color theme for HappyDevFormatter
type colorScheme struct {
Key string
Message string
Value string
Misc string
Source string
Trace string
Debug string
Info string
Warn string
Error string
}
var indent = " "
var maxCol = defaultMaxCol
var theme *colorScheme
func parseKVList(s, separator string) map[string]string {
pairs := strings.Split(s, separator)
if len(pairs) == 0 {
return nil
}
m := map[string]string{}
for _, pair := range pairs {
if pair == "" {
continue
}
parts := strings.Split(pair, "=")
switch len(parts) {
case 1:
m[parts[0]] = ""
case 2:
m[parts[0]] = parts[1]
}
}
return m
}
func parseTheme(theme string) *colorScheme {
m := parseKVList(theme, ",")
cs := &colorScheme{}
var wildcard string
var color = func(key string) string {
if disableColors {
return ""
}
style := m[key]
c := ansi.ColorCode(style)
if c == "" {
c = wildcard
}
//fmt.Printf("plain=%b [%s] %s=%q\n", ansi.DefaultFG, key, style, c)
return c
}
wildcard = color("*")
if wildcard != ansi.Reset {
cs.Key = wildcard
cs.Value = wildcard
cs.Misc = wildcard
cs.Source = wildcard
cs.Message = wildcard
cs.Trace = wildcard
cs.Debug = wildcard
cs.Warn = wildcard
cs.Info = wildcard
cs.Error = wildcard
}
cs.Key = color("key")
cs.Value = color("value")
cs.Misc = color("misc")
cs.Source = color("source")
cs.Message = color("message")
cs.Trace = color("TRC")
cs.Debug = color("DBG")
cs.Warn = color("WRN")
cs.Info = color("INF")
cs.Error = color("ERR")
return cs
}
// HappyDevFormatter is the formatter used for terminals. It is
// colorful, dev friendly and provides meaningful logs when
// warnings and errors occur.
//
// HappyDevFormatter does not worry about performance. It's at least 3-4X
// slower than JSONFormatter since it delegates to JSONFormatter to marshal
// then unmarshal JSON. Then it does other stuff like read source files, sort
// keys all to give a developer more information.
//
// SHOULD NOT be used in production for extended period of time. However, it
// works fine in SSH terminals and binary deployments.
type HappyDevFormatter struct {
name string
col int
// always use the production formatter
jsonFormatter *JSONFormatter
}
// NewHappyDevFormatter returns a new instance of HappyDevFormatter.
func NewHappyDevFormatter(name string) *HappyDevFormatter {
jf := NewJSONFormatter(name)
return &HappyDevFormatter{
name: name,
jsonFormatter: jf,
}
}
func (hd *HappyDevFormatter) writeKey(buf bufferWriter, key string) {
// assumes this is not the first key
hd.writeString(buf, Separator)
if key == "" {
return
}
buf.WriteString(theme.Key)
hd.writeString(buf, key)
hd.writeString(buf, AssignmentChar)
if !disableColors {
buf.WriteString(ansi.Reset)
}
}
func (hd *HappyDevFormatter) set(buf bufferWriter, key string, value interface{}, color string) {
var str string
if s, ok := value.(string); ok {
str = s
} else if s, ok := value.(fmt.Stringer); ok {
str = s.String()
} else {
str = fmt.Sprintf("%v", value)
}
val := strings.Trim(str, "\n ")
if (isPretty && key != "") || hd.col+len(key)+2+len(val) >= maxCol {
buf.WriteString("\n")
hd.col = 0
hd.writeString(buf, indent)
}
hd.writeKey(buf, key)
if color != "" {
buf.WriteString(color)
}
hd.writeString(buf, val)
if color != "" && !disableColors {
buf.WriteString(ansi.Reset)
}
}
// Write a string and tracks the position of the string so we can break lines
// cleanly. Do not send ANSI escape sequences, just raw strings
func (hd *HappyDevFormatter) writeString(buf bufferWriter, s string) {
buf.WriteString(s)
hd.col += len(s)
}
func (hd *HappyDevFormatter) getContext(color string) string {
if disableCallstack {
return ""
}
frames := parseDebugStack(string(debug.Stack()), 5, true)
if len(frames) == 0 {
return ""
}
for _, frame := range frames {
context := frame.String(color, theme.Source)
if context != "" {
return context
}
}
return ""
}
func (hd *HappyDevFormatter) getLevelContext(level int, entry map[string]interface{}) (message string, context string, color string) {
switch level {
case LevelTrace:
color = theme.Trace
context = hd.getContext(color)
context += "\n"
case LevelDebug:
color = theme.Debug
case LevelInfo:
color = theme.Info
// case LevelWarn:
// color = theme.Warn
// context = hd.getContext(color)
// context += "\n"
case LevelWarn, LevelError, LevelFatal:
// warnings return an error but if it does not have an error
// then print line info only
if level == LevelWarn {
color = theme.Warn
kv := entry[KeyMap.CallStack]
if kv == nil {
context = hd.getContext(color)
context += "\n"
break
}
} else {
color = theme.Error
}
if disableCallstack || contextLines == -1 {
context = trimDebugStack(string(debug.Stack()))
break
}
frames := parseLogxiStack(entry, 4, true)
if frames == nil {
frames = parseDebugStack(string(debug.Stack()), 4, true)
}
if len(frames) == 0 {
break
}
errbuf := pool.Get()
defer pool.Put(errbuf)
lines := 0
for _, frame := range frames {
err := frame.readSource(contextLines)
if err != nil {
// by setting to empty, the original stack is used
errbuf.Reset()
break
}
ctx := frame.String(color, theme.Source)
if ctx == "" {
continue
}
errbuf.WriteString(ctx)
errbuf.WriteRune('\n')
lines++
}
context = errbuf.String()
default:
panic("should never get here")
}
return message, context, color
}
// Format a log entry.
func (hd *HappyDevFormatter) Format(writer io.Writer, level int, msg string, args []interface{}) {
buf := pool.Get()
defer pool.Put(buf)
if len(args) == 1 {
args = append(args, 0)
copy(args[1:], args[0:])
args[0] = singleArgKey
}
// warn about reserved, bad and complex keys
for i := 0; i < len(args); i += 2 {
isReserved, err := isReservedKey(args[i])
if err != nil {
InternalLog.Error("Key is not a string.", "err", fmt.Errorf("args[%d]=%v", i, args[i]))
} else if isReserved {
InternalLog.Fatal("Key conflicts with reserved key. Avoiding using single rune keys.", "key", args[i].(string))
} else {
// Ensure keys are simple strings. The JSONFormatter doesn't escape
// keys as a performance tradeoff. This panics if the JSON key
// value has a different value than a simple quoted string.
key := args[i].(string)
b, err := json.Marshal(key)
if err != nil {
panic("Key is invalid. " + err.Error())
}
if string(b) != `"`+key+`"` {
panic("Key is complex. Use simpler key for: " + fmt.Sprintf("%q", key))
}
}
}
// use the production JSON formatter to format the log first. This
// ensures JSON will marshal/unmarshal correctly in production.
entry := hd.jsonFormatter.LogEntry(level, msg, args)
// reset the column tracker used for fancy formatting
hd.col = 0
// timestamp
buf.WriteString(theme.Misc)
hd.writeString(buf, entry[KeyMap.Time].(string))
if !disableColors {
buf.WriteString(ansi.Reset)
}
// emphasize warnings and errors
message, context, color := hd.getLevelContext(level, entry)
if message == "" {
message = entry[KeyMap.Message].(string)
}
// DBG, INF ...
hd.set(buf, "", entry[KeyMap.Level].(string), color)
// logger name
hd.set(buf, "", entry[KeyMap.Name], theme.Misc)
// message from user
hd.set(buf, "", message, theme.Message)
// Preserve key order in the sequencethey were added by developer.This
// makes it easier for developers to follow the log.
order := []string{}
lenArgs := len(args)
for i := 0; i < len(args); i += 2 {
if i+1 >= lenArgs {
continue
}
if key, ok := args[i].(string); ok {
order = append(order, key)
} else {
order = append(order, badKeyAtIndex(i))
}
}
for _, key := range order {
// skip reserved keys which were already added to buffer above
isReserved, err := isReservedKey(key)
if err != nil {
panic("key is invalid. Should never get here. " + err.Error())
} else if isReserved {
continue
}
hd.set(buf, key, entry[key], theme.Value)
}
addLF := true
hasCallStack := entry[KeyMap.CallStack] != nil
// WRN,ERR file, line number context
if context != "" {
// warnings and traces are single line, space can be optimized
if level == LevelTrace || (level == LevelWarn && !hasCallStack) {
// gets rid of "in "
idx := strings.IndexRune(context, 'n')
hd.set(buf, "in", context[idx+2:], color)
} else {
buf.WriteRune('\n')
if !disableColors {
buf.WriteString(color)
}
addLF = context[len(context)-1:len(context)] != "\n"
buf.WriteString(context)
if !disableColors {
buf.WriteString(ansi.Reset)
}
}
} else if hasCallStack {
hd.set(buf, "", entry[KeyMap.CallStack], color)
}
if addLF {
buf.WriteRune('\n')
}
buf.WriteTo(writer)
}