737 lines
18 KiB
Go
737 lines
18 KiB
Go
|
package zerolog
|
||
|
|
|
||
|
|
import (
|
||
|
|
"fmt"
|
||
|
|
"net"
|
||
|
|
"os"
|
||
|
|
"runtime"
|
||
|
|
"sync"
|
||
|
|
"time"
|
||
|
|
)
|
||
|
|
|
||
|
|
var eventPool = &sync.Pool{
|
||
|
|
New: func() interface{} {
|
||
|
|
return &Event{
|
||
|
|
buf: make([]byte, 0, 500),
|
||
|
|
}
|
||
|
|
},
|
||
|
|
}
|
||
|
|
|
||
|
|
// Event represents a log event. It is instanced by one of the level method of
|
||
|
|
// Logger and finalized by the Msg or Msgf method.
|
||
|
|
type Event struct {
|
||
|
|
buf []byte
|
||
|
|
w LevelWriter
|
||
|
|
level Level
|
||
|
|
done func(msg string)
|
||
|
|
stack bool // enable error stack trace
|
||
|
|
ch []Hook // hooks from context
|
||
|
|
}
|
||
|
|
|
||
|
|
func putEvent(e *Event) {
|
||
|
|
// Proper usage of a sync.Pool requires each entry to have approximately
|
||
|
|
// the same memory cost. To obtain this property when the stored type
|
||
|
|
// contains a variably-sized buffer, we add a hard limit on the maximum buffer
|
||
|
|
// to place back in the pool.
|
||
|
|
//
|
||
|
|
// See https://golang.org/issue/23199
|
||
|
|
const maxSize = 1 << 16 // 64KiB
|
||
|
|
if cap(e.buf) > maxSize {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
eventPool.Put(e)
|
||
|
|
}
|
||
|
|
|
||
|
|
// LogObjectMarshaler provides a strongly-typed and encoding-agnostic interface
|
||
|
|
// to be implemented by types used with Event/Context's Object methods.
|
||
|
|
type LogObjectMarshaler interface {
|
||
|
|
MarshalZerologObject(e *Event)
|
||
|
|
}
|
||
|
|
|
||
|
|
// LogArrayMarshaler provides a strongly-typed and encoding-agnostic interface
|
||
|
|
// to be implemented by types used with Event/Context's Array methods.
|
||
|
|
type LogArrayMarshaler interface {
|
||
|
|
MarshalZerologArray(a *Array)
|
||
|
|
}
|
||
|
|
|
||
|
|
func newEvent(w LevelWriter, level Level) *Event {
|
||
|
|
e := eventPool.Get().(*Event)
|
||
|
|
e.buf = e.buf[:0]
|
||
|
|
e.ch = nil
|
||
|
|
e.buf = enc.AppendBeginMarker(e.buf)
|
||
|
|
e.w = w
|
||
|
|
e.level = level
|
||
|
|
e.stack = false
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
func (e *Event) write() (err error) {
|
||
|
|
if e == nil {
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
if e.level != Disabled {
|
||
|
|
e.buf = enc.AppendEndMarker(e.buf)
|
||
|
|
e.buf = enc.AppendLineBreak(e.buf)
|
||
|
|
if e.w != nil {
|
||
|
|
_, err = e.w.WriteLevel(e.level, e.buf)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
putEvent(e)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// Enabled return false if the *Event is going to be filtered out by
|
||
|
|
// log level or sampling.
|
||
|
|
func (e *Event) Enabled() bool {
|
||
|
|
return e != nil && e.level != Disabled
|
||
|
|
}
|
||
|
|
|
||
|
|
// Discard disables the event so Msg(f) won't print it.
|
||
|
|
func (e *Event) Discard() *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.level = Disabled
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// Msg sends the *Event with msg added as the message field if not empty.
|
||
|
|
//
|
||
|
|
// NOTICE: once this method is called, the *Event should be disposed.
|
||
|
|
// Calling Msg twice can have unexpected result.
|
||
|
|
func (e *Event) Msg(msg string) {
|
||
|
|
if e == nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
e.msg(msg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Send is equivalent to calling Msg("").
|
||
|
|
//
|
||
|
|
// NOTICE: once this method is called, the *Event should be disposed.
|
||
|
|
func (e *Event) Send() {
|
||
|
|
if e == nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
e.msg("")
|
||
|
|
}
|
||
|
|
|
||
|
|
// Msgf sends the event with formatted msg added as the message field if not empty.
|
||
|
|
//
|
||
|
|
// NOTICE: once this method is called, the *Event should be disposed.
|
||
|
|
// Calling Msgf twice can have unexpected result.
|
||
|
|
func (e *Event) Msgf(format string, v ...interface{}) {
|
||
|
|
if e == nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
e.msg(fmt.Sprintf(format, v...))
|
||
|
|
}
|
||
|
|
|
||
|
|
func (e *Event) msg(msg string) {
|
||
|
|
for _, hook := range e.ch {
|
||
|
|
hook.Run(e, e.level, msg)
|
||
|
|
}
|
||
|
|
if msg != "" {
|
||
|
|
e.buf = enc.AppendString(enc.AppendKey(e.buf, MessageFieldName), msg)
|
||
|
|
}
|
||
|
|
if e.done != nil {
|
||
|
|
defer e.done(msg)
|
||
|
|
}
|
||
|
|
if err := e.write(); err != nil {
|
||
|
|
if ErrorHandler != nil {
|
||
|
|
ErrorHandler(err)
|
||
|
|
} else {
|
||
|
|
fmt.Fprintf(os.Stderr, "zerolog: could not write event: %v\n", err)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Fields is a helper function to use a map to set fields using type assertion.
|
||
|
|
func (e *Event) Fields(fields map[string]interface{}) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = appendFields(e.buf, fields)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Dict adds the field key with a dict to the event context.
|
||
|
|
// Use zerolog.Dict() to create the dictionary.
|
||
|
|
func (e *Event) Dict(key string, dict *Event) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
dict.buf = enc.AppendEndMarker(dict.buf)
|
||
|
|
e.buf = append(enc.AppendKey(e.buf, key), dict.buf...)
|
||
|
|
putEvent(dict)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Dict creates an Event to be used with the *Event.Dict method.
|
||
|
|
// Call usual field methods like Str, Int etc to add fields to this
|
||
|
|
// event and give it as argument the *Event.Dict method.
|
||
|
|
func Dict() *Event {
|
||
|
|
return newEvent(nil, 0)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Array adds the field key with an array to the event context.
|
||
|
|
// Use zerolog.Arr() to create the array or pass a type that
|
||
|
|
// implement the LogArrayMarshaler interface.
|
||
|
|
func (e *Event) Array(key string, arr LogArrayMarshaler) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendKey(e.buf, key)
|
||
|
|
var a *Array
|
||
|
|
if aa, ok := arr.(*Array); ok {
|
||
|
|
a = aa
|
||
|
|
} else {
|
||
|
|
a = Arr()
|
||
|
|
arr.MarshalZerologArray(a)
|
||
|
|
}
|
||
|
|
e.buf = a.write(e.buf)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
func (e *Event) appendObject(obj LogObjectMarshaler) {
|
||
|
|
e.buf = enc.AppendBeginMarker(e.buf)
|
||
|
|
obj.MarshalZerologObject(e)
|
||
|
|
e.buf = enc.AppendEndMarker(e.buf)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Object marshals an object that implement the LogObjectMarshaler interface.
|
||
|
|
func (e *Event) Object(key string, obj LogObjectMarshaler) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendKey(e.buf, key)
|
||
|
|
e.appendObject(obj)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// EmbedObject marshals an object that implement the LogObjectMarshaler interface.
|
||
|
|
func (e *Event) EmbedObject(obj LogObjectMarshaler) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
obj.MarshalZerologObject(e)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Str adds the field key with val as a string to the *Event context.
|
||
|
|
func (e *Event) Str(key, val string) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendString(enc.AppendKey(e.buf, key), val)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Strs adds the field key with vals as a []string to the *Event context.
|
||
|
|
func (e *Event) Strs(key string, vals []string) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendStrings(enc.AppendKey(e.buf, key), vals)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Stringer adds the field key with val.String() (or null if val is nil) to the *Event context.
|
||
|
|
func (e *Event) Stringer(key string, val fmt.Stringer) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
if val != nil {
|
||
|
|
e.buf = enc.AppendString(enc.AppendKey(e.buf, key), val.String())
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
e.buf = enc.AppendInterface(enc.AppendKey(e.buf, key), nil)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Bytes adds the field key with val as a string to the *Event context.
|
||
|
|
//
|
||
|
|
// Runes outside of normal ASCII ranges will be hex-encoded in the resulting
|
||
|
|
// JSON.
|
||
|
|
func (e *Event) Bytes(key string, val []byte) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendBytes(enc.AppendKey(e.buf, key), val)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Hex adds the field key with val as a hex string to the *Event context.
|
||
|
|
func (e *Event) Hex(key string, val []byte) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendHex(enc.AppendKey(e.buf, key), val)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// RawJSON adds already encoded JSON to the log line under key.
|
||
|
|
//
|
||
|
|
// No sanity check is performed on b; it must not contain carriage returns and
|
||
|
|
// be valid JSON.
|
||
|
|
func (e *Event) RawJSON(key string, b []byte) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = appendJSON(enc.AppendKey(e.buf, key), b)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// AnErr adds the field key with serialized err to the *Event context.
|
||
|
|
// If err is nil, no field is added.
|
||
|
|
func (e *Event) AnErr(key string, err error) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
switch m := ErrorMarshalFunc(err).(type) {
|
||
|
|
case nil:
|
||
|
|
return e
|
||
|
|
case LogObjectMarshaler:
|
||
|
|
return e.Object(key, m)
|
||
|
|
case error:
|
||
|
|
if m == nil || isNilValue(m) {
|
||
|
|
return e
|
||
|
|
} else {
|
||
|
|
return e.Str(key, m.Error())
|
||
|
|
}
|
||
|
|
case string:
|
||
|
|
return e.Str(key, m)
|
||
|
|
default:
|
||
|
|
return e.Interface(key, m)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Errs adds the field key with errs as an array of serialized errors to the
|
||
|
|
// *Event context.
|
||
|
|
func (e *Event) Errs(key string, errs []error) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
arr := Arr()
|
||
|
|
for _, err := range errs {
|
||
|
|
switch m := ErrorMarshalFunc(err).(type) {
|
||
|
|
case LogObjectMarshaler:
|
||
|
|
arr = arr.Object(m)
|
||
|
|
case error:
|
||
|
|
arr = arr.Err(m)
|
||
|
|
case string:
|
||
|
|
arr = arr.Str(m)
|
||
|
|
default:
|
||
|
|
arr = arr.Interface(m)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return e.Array(key, arr)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Err adds the field "error" with serialized err to the *Event context.
|
||
|
|
// If err is nil, no field is added.
|
||
|
|
//
|
||
|
|
// To customize the key name, change zerolog.ErrorFieldName.
|
||
|
|
//
|
||
|
|
// If Stack() has been called before and zerolog.ErrorStackMarshaler is defined,
|
||
|
|
// the err is passed to ErrorStackMarshaler and the result is appended to the
|
||
|
|
// zerolog.ErrorStackFieldName.
|
||
|
|
func (e *Event) Err(err error) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
if e.stack && ErrorStackMarshaler != nil {
|
||
|
|
switch m := ErrorStackMarshaler(err).(type) {
|
||
|
|
case nil:
|
||
|
|
case LogObjectMarshaler:
|
||
|
|
e.Object(ErrorStackFieldName, m)
|
||
|
|
case error:
|
||
|
|
if m != nil && !isNilValue(m) {
|
||
|
|
e.Str(ErrorStackFieldName, m.Error())
|
||
|
|
}
|
||
|
|
case string:
|
||
|
|
e.Str(ErrorStackFieldName, m)
|
||
|
|
default:
|
||
|
|
e.Interface(ErrorStackFieldName, m)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return e.AnErr(ErrorFieldName, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Stack enables stack trace printing for the error passed to Err().
|
||
|
|
//
|
||
|
|
// ErrorStackMarshaler must be set for this method to do something.
|
||
|
|
func (e *Event) Stack() *Event {
|
||
|
|
if e != nil {
|
||
|
|
e.stack = true
|
||
|
|
}
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Bool adds the field key with val as a bool to the *Event context.
|
||
|
|
func (e *Event) Bool(key string, b bool) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendBool(enc.AppendKey(e.buf, key), b)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Bools adds the field key with val as a []bool to the *Event context.
|
||
|
|
func (e *Event) Bools(key string, b []bool) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendBools(enc.AppendKey(e.buf, key), b)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Int adds the field key with i as a int to the *Event context.
|
||
|
|
func (e *Event) Int(key string, i int) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendInt(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Ints adds the field key with i as a []int to the *Event context.
|
||
|
|
func (e *Event) Ints(key string, i []int) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendInts(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Int8 adds the field key with i as a int8 to the *Event context.
|
||
|
|
func (e *Event) Int8(key string, i int8) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendInt8(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Ints8 adds the field key with i as a []int8 to the *Event context.
|
||
|
|
func (e *Event) Ints8(key string, i []int8) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendInts8(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Int16 adds the field key with i as a int16 to the *Event context.
|
||
|
|
func (e *Event) Int16(key string, i int16) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendInt16(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Ints16 adds the field key with i as a []int16 to the *Event context.
|
||
|
|
func (e *Event) Ints16(key string, i []int16) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendInts16(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Int32 adds the field key with i as a int32 to the *Event context.
|
||
|
|
func (e *Event) Int32(key string, i int32) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendInt32(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Ints32 adds the field key with i as a []int32 to the *Event context.
|
||
|
|
func (e *Event) Ints32(key string, i []int32) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendInts32(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Int64 adds the field key with i as a int64 to the *Event context.
|
||
|
|
func (e *Event) Int64(key string, i int64) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendInt64(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Ints64 adds the field key with i as a []int64 to the *Event context.
|
||
|
|
func (e *Event) Ints64(key string, i []int64) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendInts64(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Uint adds the field key with i as a uint to the *Event context.
|
||
|
|
func (e *Event) Uint(key string, i uint) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendUint(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Uints adds the field key with i as a []int to the *Event context.
|
||
|
|
func (e *Event) Uints(key string, i []uint) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendUints(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Uint8 adds the field key with i as a uint8 to the *Event context.
|
||
|
|
func (e *Event) Uint8(key string, i uint8) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendUint8(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Uints8 adds the field key with i as a []int8 to the *Event context.
|
||
|
|
func (e *Event) Uints8(key string, i []uint8) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendUints8(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Uint16 adds the field key with i as a uint16 to the *Event context.
|
||
|
|
func (e *Event) Uint16(key string, i uint16) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendUint16(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Uints16 adds the field key with i as a []int16 to the *Event context.
|
||
|
|
func (e *Event) Uints16(key string, i []uint16) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendUints16(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Uint32 adds the field key with i as a uint32 to the *Event context.
|
||
|
|
func (e *Event) Uint32(key string, i uint32) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendUint32(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Uints32 adds the field key with i as a []int32 to the *Event context.
|
||
|
|
func (e *Event) Uints32(key string, i []uint32) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendUints32(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Uint64 adds the field key with i as a uint64 to the *Event context.
|
||
|
|
func (e *Event) Uint64(key string, i uint64) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendUint64(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Uints64 adds the field key with i as a []int64 to the *Event context.
|
||
|
|
func (e *Event) Uints64(key string, i []uint64) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendUints64(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Float32 adds the field key with f as a float32 to the *Event context.
|
||
|
|
func (e *Event) Float32(key string, f float32) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendFloat32(enc.AppendKey(e.buf, key), f)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Floats32 adds the field key with f as a []float32 to the *Event context.
|
||
|
|
func (e *Event) Floats32(key string, f []float32) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendFloats32(enc.AppendKey(e.buf, key), f)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Float64 adds the field key with f as a float64 to the *Event context.
|
||
|
|
func (e *Event) Float64(key string, f float64) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendFloat64(enc.AppendKey(e.buf, key), f)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Floats64 adds the field key with f as a []float64 to the *Event context.
|
||
|
|
func (e *Event) Floats64(key string, f []float64) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendFloats64(enc.AppendKey(e.buf, key), f)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Timestamp adds the current local time as UNIX timestamp to the *Event context with the "time" key.
|
||
|
|
// To customize the key name, change zerolog.TimestampFieldName.
|
||
|
|
//
|
||
|
|
// NOTE: It won't dedupe the "time" key if the *Event (or *Context) has one
|
||
|
|
// already.
|
||
|
|
func (e *Event) Timestamp() *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendTime(enc.AppendKey(e.buf, TimestampFieldName), TimestampFunc(), TimeFieldFormat)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Time adds the field key with t formated as string using zerolog.TimeFieldFormat.
|
||
|
|
func (e *Event) Time(key string, t time.Time) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendTime(enc.AppendKey(e.buf, key), t, TimeFieldFormat)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Times adds the field key with t formated as string using zerolog.TimeFieldFormat.
|
||
|
|
func (e *Event) Times(key string, t []time.Time) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendTimes(enc.AppendKey(e.buf, key), t, TimeFieldFormat)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Dur adds the field key with duration d stored as zerolog.DurationFieldUnit.
|
||
|
|
// If zerolog.DurationFieldInteger is true, durations are rendered as integer
|
||
|
|
// instead of float.
|
||
|
|
func (e *Event) Dur(key string, d time.Duration) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendDuration(enc.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Durs adds the field key with duration d stored as zerolog.DurationFieldUnit.
|
||
|
|
// If zerolog.DurationFieldInteger is true, durations are rendered as integer
|
||
|
|
// instead of float.
|
||
|
|
func (e *Event) Durs(key string, d []time.Duration) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendDurations(enc.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// TimeDiff adds the field key with positive duration between time t and start.
|
||
|
|
// If time t is not greater than start, duration will be 0.
|
||
|
|
// Duration format follows the same principle as Dur().
|
||
|
|
func (e *Event) TimeDiff(key string, t time.Time, start time.Time) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
var d time.Duration
|
||
|
|
if t.After(start) {
|
||
|
|
d = t.Sub(start)
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendDuration(enc.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Interface adds the field key with i marshaled using reflection.
|
||
|
|
func (e *Event) Interface(key string, i interface{}) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
if obj, ok := i.(LogObjectMarshaler); ok {
|
||
|
|
return e.Object(key, obj)
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendInterface(enc.AppendKey(e.buf, key), i)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// Caller adds the file:line of the caller with the zerolog.CallerFieldName key.
|
||
|
|
// The argument skip is the number of stack frames to ascend
|
||
|
|
// Skip If not passed, use the global variable CallerSkipFrameCount
|
||
|
|
func (e *Event) Caller(skip ...int) *Event {
|
||
|
|
sk := CallerSkipFrameCount
|
||
|
|
if len(skip) > 0 {
|
||
|
|
sk = skip[0] + CallerSkipFrameCount
|
||
|
|
}
|
||
|
|
return e.caller(sk)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (e *Event) caller(skip int) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
_, file, line, ok := runtime.Caller(skip)
|
||
|
|
if !ok {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendString(enc.AppendKey(e.buf, CallerFieldName), CallerMarshalFunc(file, line))
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// IPAddr adds IPv4 or IPv6 Address to the event
|
||
|
|
func (e *Event) IPAddr(key string, ip net.IP) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendIPAddr(enc.AppendKey(e.buf, key), ip)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// IPPrefix adds IPv4 or IPv6 Prefix (address and mask) to the event
|
||
|
|
func (e *Event) IPPrefix(key string, pfx net.IPNet) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendIPPrefix(enc.AppendKey(e.buf, key), pfx)
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
// MACAddr adds MAC address to the event
|
||
|
|
func (e *Event) MACAddr(key string, ha net.HardwareAddr) *Event {
|
||
|
|
if e == nil {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
e.buf = enc.AppendMACAddr(enc.AppendKey(e.buf, key), ha)
|
||
|
|
return e
|
||
|
|
}
|