mirror of
https://github.com/kevin-DL/revel-cmd.git
synced 2026-01-11 10:44:28 +00:00
657 lines
18 KiB
Go
657 lines
18 KiB
Go
package logger
|
|
|
|
|
|
// LoggedError is wrapper to differentiate logged panics from unexpected ones.
|
|
import (
|
|
"os"
|
|
"fmt"
|
|
"strings"
|
|
"go.uber.org/zap"
|
|
"go.uber.org/zap/zapcore"
|
|
"sync"
|
|
"go.uber.org/zap/buffer"
|
|
"time"
|
|
"encoding/base64"
|
|
"unicode/utf8"
|
|
"encoding/json"
|
|
"math"
|
|
|
|
"io"
|
|
)
|
|
|
|
type (
|
|
MultiLogger interface {
|
|
//log15.Logger
|
|
//// New returns a new Logger that has this logger's context plus the given context
|
|
New(ctx ...interface{}) MultiLogger
|
|
//
|
|
// The encoders job is to encode the
|
|
SetHandler(h LogHandler)
|
|
SetStackDepth(int) MultiLogger
|
|
//
|
|
//// Log a message at the given level with context key/value pairs
|
|
Debug(msg string, ctx ...interface{})
|
|
Debugf(msg string, params ...interface{})
|
|
Info(msg string, ctx ...interface{})
|
|
Infof(msg string, params ...interface{})
|
|
Warn(msg string, ctx ...interface{})
|
|
Warnf(msg string, params ...interface{})
|
|
Error(msg string, ctx ...interface{})
|
|
Errorf(msg string, params ...interface{})
|
|
Crit(msg string, ctx ...interface{})
|
|
Critf(msg string, params ...interface{})
|
|
|
|
//// Logs a message as an Crit and exits
|
|
Fatal(msg string, ctx ...interface{})
|
|
Fatalf(msg string, params ...interface{})
|
|
//// Logs a message as an Crit and panics
|
|
Panic(msg string, ctx ...interface{})
|
|
Panicf(msg string, params ...interface{})
|
|
}
|
|
|
|
// The log han
|
|
LogHandler interface {
|
|
Encode(Record) ([]byte, error)
|
|
GetLevel() Level
|
|
GetWriter() io.Writer
|
|
}
|
|
|
|
// The Record
|
|
Record struct {
|
|
Level Level
|
|
Time time.Time
|
|
LoggerName string
|
|
Message string
|
|
Caller EntryCaller
|
|
Stack string
|
|
Context []Field
|
|
}
|
|
|
|
// The fields passed in
|
|
Field interface {
|
|
GetKey() string
|
|
GetValueAsString() string
|
|
GetValue() interface{}
|
|
}
|
|
|
|
EntryCaller interface {
|
|
IsDefined() bool
|
|
GetPC() uintptr
|
|
GetFile() string
|
|
GetLine() int
|
|
}
|
|
|
|
// Called only if the logger needs
|
|
ResolveLaterLogger func() interface{}
|
|
|
|
FieldType int
|
|
Level int
|
|
)
|
|
|
|
type (
|
|
zapLogger struct {
|
|
logger *zap.SugaredLogger
|
|
coreList []*zapcore.Core
|
|
}
|
|
zapField struct {
|
|
Key string
|
|
Type FieldType
|
|
Integer int64
|
|
String string
|
|
Interface interface{}
|
|
}
|
|
zapEntryCaller struct {
|
|
Defined bool
|
|
PC uintptr
|
|
File string
|
|
Line int
|
|
}
|
|
zapEncoder struct {
|
|
lh LogHandler
|
|
}
|
|
)
|
|
|
|
func newLogger(addCaller bool) MultiLogger {
|
|
logger := zap.New(nil).WithOptions(zap.AddCaller())
|
|
l := &zapLogger{logger:logger.Sugar()}
|
|
|
|
return l
|
|
}
|
|
|
|
// It is up to the handler to determine the synchronization to the output
|
|
// streams
|
|
func (z *zapLogger) SetHandler(lh LogHandler) {
|
|
// Swap out the logger when a new handler is attached
|
|
encoder := &zapEncoder{lh}
|
|
levelHandler := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
|
|
return lvl >= zapcore.Level(lh.GetLevel())
|
|
})
|
|
logger := zap.New(zapcore.NewCore(encoder, nil, levelHandler)).WithOptions(zap.AddCaller())
|
|
Logger.With("foo","bar").Desugar().Core()
|
|
}
|
|
|
|
var Logger *zap.SugaredLogger
|
|
|
|
func InitLogger(logLevel zapcore.Level) {
|
|
config :=zap.NewDevelopmentEncoderConfig()
|
|
config.EncodeLevel = zapcore.CapitalColorLevelEncoder
|
|
|
|
consoleEncoder := NewConsoleEncoder(config)
|
|
lowPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
|
|
return lvl >= logLevel
|
|
})
|
|
|
|
consoleDebugging := zapcore.Lock(os.Stdout)
|
|
core := zapcore.NewTee(
|
|
zapcore.NewCore(consoleEncoder, consoleDebugging, lowPriority),
|
|
)
|
|
logger := zap.New(core).WithOptions(zap.AddCaller())
|
|
Logger = logger.Sugar()
|
|
}
|
|
type LoggedError struct{ error }
|
|
|
|
func NewLoggedError(err error) *LoggedError {
|
|
return &LoggedError{err}
|
|
}
|
|
|
|
func Errorf(format string, args ...interface{}) {
|
|
// Ensure the user's command prompt starts on the next line.
|
|
if !strings.HasSuffix(format, "\n") {
|
|
format += "\n"
|
|
}
|
|
fmt.Fprintf(os.Stderr, format, args...)
|
|
panic(format) // Panic instead of os.Exit so that deferred will run.
|
|
}
|
|
|
|
|
|
|
|
// This is all for the Console logger - a little wordy but it works
|
|
|
|
var _sliceEncoderPool = sync.Pool{
|
|
New: func() interface{} {
|
|
return &sliceArrayEncoder{elems: make([]interface{}, 0, 2)}
|
|
},
|
|
}
|
|
|
|
func getSliceEncoder() *sliceArrayEncoder {
|
|
return _sliceEncoderPool.Get().(*sliceArrayEncoder)
|
|
}
|
|
|
|
func putSliceEncoder(e *sliceArrayEncoder) {
|
|
e.elems = e.elems[:0]
|
|
_sliceEncoderPool.Put(e)
|
|
}
|
|
|
|
type consoleEncoder struct {
|
|
*zapcore.EncoderConfig
|
|
openNamespaces int
|
|
buf *buffer.Buffer
|
|
reflectBuf *buffer.Buffer
|
|
reflectEnc *json.Encoder
|
|
}
|
|
|
|
var (
|
|
_pool = buffer.NewPool()
|
|
// Get retrieves a buffer from the pool, creating one if necessary.
|
|
Get = _pool.Get
|
|
)
|
|
|
|
|
|
// NewConsoleEncoder creates an encoder whose output is designed for human -
|
|
// rather than machine - consumption. It serializes the core log entry data
|
|
// (message, level, timestamp, etc.) in a plain-text format and leaves the
|
|
// structured context as JSON.
|
|
//
|
|
// Note that although the console encoder doesn't use the keys specified in the
|
|
// encoder configuration, it will omit any element whose key is set to the empty
|
|
// string.
|
|
func NewConsoleEncoder(cfg zapcore.EncoderConfig) zapcore.Encoder {
|
|
ec := &consoleEncoder{buf : Get(), reflectBuf: Get()}
|
|
ec.EncoderConfig = &cfg
|
|
return ec
|
|
}
|
|
|
|
func (c consoleEncoder) Clone() zapcore.Encoder {
|
|
return &consoleEncoder{buf : Get(), reflectBuf: Get()}
|
|
}
|
|
|
|
func (c consoleEncoder) EncodeEntry(ent zapcore.Entry, fields []zapcore.Field) (*buffer.Buffer, error) {
|
|
line := Get()
|
|
|
|
var color = 0
|
|
switch ent.Level {
|
|
case zap.PanicLevel:
|
|
// Magenta
|
|
color = 35
|
|
case zap.ErrorLevel:
|
|
// Red
|
|
color = 31
|
|
case zap.WarnLevel:
|
|
// Yellow
|
|
color = 33
|
|
case zap.InfoLevel:
|
|
// Green
|
|
color = 32
|
|
case zap.DebugLevel:
|
|
// Cyan
|
|
color = 36
|
|
}
|
|
|
|
// We don't want the entry's metadata to be quoted and escaped (if it's
|
|
// encoded as strings), which means that we can't use the JSON encoder. The
|
|
// simplest option is to use the memory encoder and fmt.Fprint.
|
|
//
|
|
// If this ever becomes a performance bottleneck, we can implement
|
|
// ArrayEncoder for our plain-text format.
|
|
arr := getSliceEncoder()
|
|
if c.LevelKey != "" && c.EncodeLevel != nil {
|
|
arr.AppendString(fmt.Sprintf("\x1b[%dm%-5s\x1b[0m",color,ent.Level.CapitalString()))
|
|
}
|
|
if ent.LoggerName != "" && c.NameKey != "" {
|
|
nameEncoder := c.EncodeName
|
|
|
|
if nameEncoder == nil {
|
|
// Fall back to FullNameEncoder for backward compatibility.
|
|
nameEncoder = zapcore.FullNameEncoder
|
|
}
|
|
|
|
nameEncoder(ent.LoggerName, arr)
|
|
}
|
|
if c.TimeKey != "" && c.EncodeTime != nil {
|
|
arr.AppendString(ent.Time.Format("15:04:05"))
|
|
}
|
|
|
|
if ent.Caller.Defined && c.CallerKey != "" && c.EncodeCaller != nil {
|
|
c.EncodeCaller(ent.Caller, arr)
|
|
}
|
|
for i := range arr.elems {
|
|
if i > 0 {
|
|
line.AppendByte(' ')
|
|
}
|
|
fmt.Fprint(line, arr.elems[i])
|
|
}
|
|
putSliceEncoder(arr)
|
|
|
|
// Add the message itself.
|
|
if c.MessageKey != "" {
|
|
c.addTabIfNecessary(line)
|
|
line.AppendString(ent.Message)
|
|
}
|
|
|
|
// Add any structured context.
|
|
c.writeContext(line, fields)
|
|
|
|
// If there's no stacktrace key, honor that; this allows users to force
|
|
// single-line output.
|
|
if ent.Stack != "" && c.StacktraceKey != "" {
|
|
line.AppendByte('\n')
|
|
line.AppendString(ent.Stack)
|
|
}
|
|
|
|
if c.LineEnding != "" {
|
|
line.AppendString(c.LineEnding)
|
|
} else {
|
|
line.AppendString(zapcore.DefaultLineEnding)
|
|
}
|
|
return line, nil
|
|
}
|
|
|
|
func (c consoleEncoder) writeContext(line *buffer.Buffer, extra []zapcore.Field) {
|
|
context := c.Clone().(*consoleEncoder)
|
|
defer context.buf.Free()
|
|
//
|
|
addFields(context, extra)
|
|
context.closeOpenNamespaces()
|
|
if context.buf.Len() == 0 {
|
|
return
|
|
}
|
|
//
|
|
line.Write(context.buf.Bytes())
|
|
}
|
|
func addFields(enc zapcore.ObjectEncoder, fields []zapcore.Field) {
|
|
for i := range fields {
|
|
fields[i].AddTo(enc)
|
|
}
|
|
}
|
|
|
|
|
|
func (c consoleEncoder) addTabIfNecessary(line *buffer.Buffer) {
|
|
if line.Len() > 0 {
|
|
line.AppendByte('\t')
|
|
}
|
|
}
|
|
|
|
|
|
func (enc *consoleEncoder) AddArray(key string, arr zapcore.ArrayMarshaler) error {
|
|
enc.addKey(key)
|
|
return enc.AppendArray(arr)
|
|
}
|
|
|
|
func (enc *consoleEncoder) AddObject(key string, obj zapcore.ObjectMarshaler) error {
|
|
enc.addKey(key)
|
|
return enc.AppendObject(obj)
|
|
}
|
|
|
|
func (enc *consoleEncoder) AddBinary(key string, val []byte) {
|
|
enc.AddString(key, base64.StdEncoding.EncodeToString(val))
|
|
}
|
|
|
|
func (enc *consoleEncoder) AddByteString(key string, val []byte) {
|
|
enc.addKey(key)
|
|
enc.AppendByteString(val)
|
|
}
|
|
|
|
func (enc *consoleEncoder) AddBool(key string, val bool) {
|
|
enc.addKey(key)
|
|
enc.AppendBool(val)
|
|
}
|
|
|
|
func (enc *consoleEncoder) AddComplex128(key string, val complex128) {
|
|
enc.addKey(key)
|
|
enc.AppendComplex128(val)
|
|
}
|
|
|
|
func (enc *consoleEncoder) AddDuration(key string, val time.Duration) {
|
|
enc.addKey(key)
|
|
enc.AppendDuration(val)
|
|
}
|
|
|
|
func (enc *consoleEncoder) AddFloat64(key string, val float64) {
|
|
enc.addKey(key)
|
|
enc.AppendFloat64(val)
|
|
}
|
|
|
|
func (enc *consoleEncoder) AddInt64(key string, val int64) {
|
|
enc.addKey(key)
|
|
enc.AppendInt64(val)
|
|
}
|
|
|
|
func (enc *consoleEncoder) AddReflected(key string, obj interface{}) error {
|
|
enc.resetReflectBuf()
|
|
err := enc.reflectEnc.Encode(obj)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc.reflectBuf.TrimNewline()
|
|
enc.addKey(key)
|
|
_, err = enc.buf.Write(enc.reflectBuf.Bytes())
|
|
return err
|
|
}
|
|
|
|
func (enc *consoleEncoder) OpenNamespace(key string) {
|
|
enc.addKey(key)
|
|
enc.buf.AppendByte('{')
|
|
enc.openNamespaces++
|
|
}
|
|
|
|
func (enc *consoleEncoder) AddString(key, val string) {
|
|
enc.addKey(key)
|
|
enc.AppendString(val)
|
|
}
|
|
|
|
func (enc *consoleEncoder) AddTime(key string, val time.Time) {
|
|
enc.addKey(key)
|
|
enc.AppendTime(val)
|
|
}
|
|
|
|
func (enc *consoleEncoder) AddUint64(key string, val uint64) {
|
|
enc.addKey(key)
|
|
enc.AppendUint64(val)
|
|
}
|
|
|
|
func (enc *consoleEncoder) addKey(key string) {
|
|
// Print key in different color
|
|
enc.buf.AppendString(fmt.Sprintf(" \x1b[%dm%s\x1b[0m",36,key))
|
|
|
|
enc.buf.AppendByte('=')
|
|
}
|
|
|
|
func (enc *consoleEncoder) AppendArray(arr zapcore.ArrayMarshaler) error {
|
|
enc.buf.AppendByte('[')
|
|
err := arr.MarshalLogArray(enc)
|
|
enc.buf.AppendByte(']')
|
|
return err
|
|
}
|
|
|
|
func (enc *consoleEncoder) AppendObject(obj zapcore.ObjectMarshaler) error {
|
|
enc.buf.AppendByte('{')
|
|
err := obj.MarshalLogObject(enc)
|
|
enc.buf.AppendByte('}')
|
|
return err
|
|
}
|
|
|
|
func (enc *consoleEncoder) AppendBool(val bool) {
|
|
enc.buf.AppendBool(val)
|
|
}
|
|
|
|
func (enc *consoleEncoder) AppendByteString(val []byte) {
|
|
enc.buf.AppendByte('"')
|
|
enc.safeAddByteString(val)
|
|
enc.buf.AppendByte('"')
|
|
}
|
|
|
|
func (enc *consoleEncoder) AppendComplex128(val complex128) {
|
|
// Cast to a platform-independent, fixed-size type.
|
|
r, i := float64(real(val)), float64(imag(val))
|
|
enc.buf.AppendByte('"')
|
|
// Because we're always in a quoted string, we can use strconv without
|
|
// special-casing NaN and +/-Inf.
|
|
enc.buf.AppendFloat(r, 64)
|
|
enc.buf.AppendByte('+')
|
|
enc.buf.AppendFloat(i, 64)
|
|
enc.buf.AppendByte('i')
|
|
enc.buf.AppendByte('"')
|
|
}
|
|
|
|
func (enc *consoleEncoder) AppendDuration(val time.Duration) {
|
|
cur := enc.buf.Len()
|
|
enc.EncodeDuration(val, enc)
|
|
if cur == enc.buf.Len() {
|
|
// User-supplied EncodeDuration is a no-op. Fall back to nanoseconds to keep
|
|
// JSON valid.
|
|
enc.AppendInt64(int64(val))
|
|
}
|
|
}
|
|
|
|
func (enc *consoleEncoder) AppendInt64(val int64) {
|
|
enc.buf.AppendInt(val)
|
|
}
|
|
func (enc *consoleEncoder) resetReflectBuf() {
|
|
if enc.reflectBuf == nil {
|
|
enc.reflectBuf = Get()
|
|
enc.reflectEnc = json.NewEncoder(enc.reflectBuf)
|
|
} else {
|
|
enc.reflectBuf.Reset()
|
|
}
|
|
}
|
|
func (enc *consoleEncoder) AppendReflected(val interface{}) error {
|
|
enc.resetReflectBuf()
|
|
err := enc.reflectEnc.Encode(val)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc.reflectBuf.TrimNewline()
|
|
_, err = enc.buf.Write(enc.reflectBuf.Bytes())
|
|
return err
|
|
}
|
|
|
|
func (enc *consoleEncoder) AppendString(val string) {
|
|
enc.safeAddString(val)
|
|
}
|
|
|
|
func (enc *consoleEncoder) AppendTime(val time.Time) {
|
|
cur := enc.buf.Len()
|
|
enc.EncodeTime(val, enc)
|
|
if cur == enc.buf.Len() {
|
|
// User-supplied EncodeTime is a no-op. Fall back to nanos since epoch to keep
|
|
// output JSON valid.
|
|
enc.AppendInt64(val.UnixNano())
|
|
}
|
|
}
|
|
|
|
func (enc *consoleEncoder) AppendUint64(val uint64) {
|
|
enc.buf.AppendUint(val)
|
|
}
|
|
func (enc *consoleEncoder) appendFloat(val float64, bitSize int) {
|
|
switch {
|
|
case math.IsNaN(val):
|
|
enc.buf.AppendString(`"NaN"`)
|
|
case math.IsInf(val, 1):
|
|
enc.buf.AppendString(`"+Inf"`)
|
|
case math.IsInf(val, -1):
|
|
enc.buf.AppendString(`"-Inf"`)
|
|
default:
|
|
enc.buf.AppendFloat(val, bitSize)
|
|
}
|
|
}
|
|
|
|
// safeAddString JSON-escapes a string and appends it to the internal buffer.
|
|
// Unlike the standard library's encoder, it doesn't attempt to protect the
|
|
// user from browser vulnerabilities or JSONP-related problems.
|
|
func (enc *consoleEncoder) safeAddString(s string) {
|
|
for i := 0; i < len(s); {
|
|
if enc.tryAddRuneSelf(s[i]) {
|
|
i++
|
|
continue
|
|
}
|
|
r, size := utf8.DecodeRuneInString(s[i:])
|
|
if enc.tryAddRuneError(r, size) {
|
|
i++
|
|
continue
|
|
}
|
|
enc.buf.AppendString(s[i : i+size])
|
|
i += size
|
|
}
|
|
}
|
|
|
|
// safeAddByteString is no-alloc equivalent of safeAddString(string(s)) for s []byte.
|
|
func (enc *consoleEncoder) safeAddByteString(s []byte) {
|
|
for i := 0; i < len(s); {
|
|
if enc.tryAddRuneSelf(s[i]) {
|
|
i++
|
|
continue
|
|
}
|
|
r, size := utf8.DecodeRune(s[i:])
|
|
if enc.tryAddRuneError(r, size) {
|
|
i++
|
|
continue
|
|
}
|
|
enc.buf.Write(s[i : i+size])
|
|
i += size
|
|
}
|
|
}
|
|
|
|
// tryAddRuneSelf appends b if it is valid UTF-8 character represented in a single byte.
|
|
func (enc *consoleEncoder) tryAddRuneSelf(b byte) bool {
|
|
if b >= utf8.RuneSelf {
|
|
return false
|
|
}
|
|
if 0x20 <= b && b != '\\' && b != '"' {
|
|
enc.buf.AppendByte(b)
|
|
return true
|
|
}
|
|
switch b {
|
|
case '\\', '"':
|
|
enc.buf.AppendByte('\\')
|
|
enc.buf.AppendByte(b)
|
|
case '\n':
|
|
enc.buf.AppendByte('\\')
|
|
enc.buf.AppendByte('n')
|
|
case '\r':
|
|
enc.buf.AppendByte('\\')
|
|
enc.buf.AppendByte('r')
|
|
case '\t':
|
|
enc.buf.AppendByte('\\')
|
|
enc.buf.AppendByte('t')
|
|
default:
|
|
// Encode bytes < 0x20, except for the escape sequences above.
|
|
enc.buf.AppendString(`\u00`)
|
|
enc.buf.AppendByte(_hex[b>>4])
|
|
enc.buf.AppendByte(_hex[b&0xF])
|
|
}
|
|
return true
|
|
}
|
|
func (enc *consoleEncoder) closeOpenNamespaces() {
|
|
for i := 0; i < enc.openNamespaces; i++ {
|
|
enc.buf.AppendByte('}')
|
|
}
|
|
}
|
|
|
|
|
|
func (enc *consoleEncoder) tryAddRuneError(r rune, size int) bool {
|
|
if r == utf8.RuneError && size == 1 {
|
|
enc.buf.AppendString(`\ufffd`)
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
func (enc *consoleEncoder) AddComplex64(k string, v complex64) { enc.AddComplex128(k, complex128(v)) }
|
|
func (enc *consoleEncoder) AddFloat32(k string, v float32) { enc.AddFloat64(k, float64(v)) }
|
|
func (enc *consoleEncoder) AddInt(k string, v int) { enc.AddInt64(k, int64(v)) }
|
|
func (enc *consoleEncoder) AddInt32(k string, v int32) { enc.AddInt64(k, int64(v)) }
|
|
func (enc *consoleEncoder) AddInt16(k string, v int16) { enc.AddInt64(k, int64(v)) }
|
|
func (enc *consoleEncoder) AddInt8(k string, v int8) { enc.AddInt64(k, int64(v)) }
|
|
func (enc *consoleEncoder) AddUint(k string, v uint) { enc.AddUint64(k, uint64(v)) }
|
|
func (enc *consoleEncoder) AddUint32(k string, v uint32) { enc.AddUint64(k, uint64(v)) }
|
|
func (enc *consoleEncoder) AddUint16(k string, v uint16) { enc.AddUint64(k, uint64(v)) }
|
|
func (enc *consoleEncoder) AddUint8(k string, v uint8) { enc.AddUint64(k, uint64(v)) }
|
|
func (enc *consoleEncoder) AddUintptr(k string, v uintptr) { enc.AddUint64(k, uint64(v)) }
|
|
func (enc *consoleEncoder) AppendComplex64(v complex64) { enc.AppendComplex128(complex128(v)) }
|
|
func (enc *consoleEncoder) AppendFloat64(v float64) { enc.appendFloat(v, 64) }
|
|
func (enc *consoleEncoder) AppendFloat32(v float32) { enc.appendFloat(float64(v), 32) }
|
|
func (enc *consoleEncoder) AppendInt(v int) { enc.AppendInt64(int64(v)) }
|
|
func (enc *consoleEncoder) AppendInt32(v int32) { enc.AppendInt64(int64(v)) }
|
|
func (enc *consoleEncoder) AppendInt16(v int16) { enc.AppendInt64(int64(v)) }
|
|
func (enc *consoleEncoder) AppendInt8(v int8) { enc.AppendInt64(int64(v)) }
|
|
func (enc *consoleEncoder) AppendUint(v uint) { enc.AppendUint64(uint64(v)) }
|
|
func (enc *consoleEncoder) AppendUint32(v uint32) { enc.AppendUint64(uint64(v)) }
|
|
func (enc *consoleEncoder) AppendUint16(v uint16) { enc.AppendUint64(uint64(v)) }
|
|
func (enc *consoleEncoder) AppendUint8(v uint8) { enc.AppendUint64(uint64(v)) }
|
|
func (enc *consoleEncoder) AppendUintptr(v uintptr) { enc.AppendUint64(uint64(v)) }
|
|
|
|
const _hex = "0123456789abcdef"
|
|
|
|
type sliceArrayEncoder struct {
|
|
elems []interface{}
|
|
}
|
|
|
|
func (s *sliceArrayEncoder) AppendArray(v zapcore.ArrayMarshaler) error {
|
|
enc := &sliceArrayEncoder{}
|
|
err := v.MarshalLogArray(enc)
|
|
s.elems = append(s.elems, enc.elems)
|
|
return err
|
|
}
|
|
|
|
func (s *sliceArrayEncoder) AppendObject(v zapcore.ObjectMarshaler) error {
|
|
m := zapcore.NewMapObjectEncoder()
|
|
err := v.MarshalLogObject(m)
|
|
s.elems = append(s.elems, m.Fields)
|
|
return err
|
|
}
|
|
|
|
func (s *sliceArrayEncoder) AppendReflected(v interface{}) error {
|
|
s.elems = append(s.elems, v)
|
|
return nil
|
|
}
|
|
|
|
func (s *sliceArrayEncoder) AppendBool(v bool) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendByteString(v []byte) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendComplex128(v complex128) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendComplex64(v complex64) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendDuration(v time.Duration) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendFloat64(v float64) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendFloat32(v float32) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendInt(v int) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendInt64(v int64) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendInt32(v int32) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendInt16(v int16) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendInt8(v int8) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendString(v string) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendTime(v time.Time) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendUint(v uint) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendUint64(v uint64) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendUint32(v uint32) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendUint16(v uint16) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendUint8(v uint8) { s.elems = append(s.elems, v) }
|
|
func (s *sliceArrayEncoder) AppendUintptr(v uintptr) { s.elems = append(s.elems, v) }
|