Add some array types support
This commit is contained in:
Olivier Poitrey
parent
eed4c2b94d
commit
2aa3c3ae4f
104
context.go
104
context.go
|
|
@ -32,6 +32,12 @@ func (c Context) Str(key, val string) Context {
|
|||
return c
|
||||
}
|
||||
|
||||
// Strs adds the field key with val as a string to the logger context.
|
||||
func (c Context) Strs(key string, vals []string) Context {
|
||||
c.l.context = appendStrings(c.l.context, key, vals)
|
||||
return c
|
||||
}
|
||||
|
||||
// Bytes adds the field key with val as a []byte to the logger context.
|
||||
func (c Context) Bytes(key string, val []byte) Context {
|
||||
c.l.context = appendBytes(c.l.context, key, val)
|
||||
|
|
@ -44,6 +50,12 @@ func (c Context) AnErr(key string, err error) Context {
|
|||
return c
|
||||
}
|
||||
|
||||
// Errs adds the field key with errs as an array of strings to the logger context.
|
||||
func (c Context) Errs(key string, errs []error) Context {
|
||||
c.l.context = appendErrorsKey(c.l.context, key, errs)
|
||||
return c
|
||||
}
|
||||
|
||||
// Err adds the field "error" with err as a string to the logger context.
|
||||
// To customize the key name, change zerolog.ErrorFieldName.
|
||||
func (c Context) Err(err error) Context {
|
||||
|
|
@ -51,84 +63,162 @@ func (c Context) Err(err error) Context {
|
|||
return c
|
||||
}
|
||||
|
||||
// Bool adds the field key with val as a Boolean to the logger context.
|
||||
// Bool adds the field key with val as a bool to the logger context.
|
||||
func (c Context) Bool(key string, b bool) Context {
|
||||
c.l.context = appendBool(c.l.context, key, b)
|
||||
return c
|
||||
}
|
||||
|
||||
// Bools adds the field key with val as a []bool to the logger context.
|
||||
func (c Context) Bools(key string, b []bool) Context {
|
||||
c.l.context = appendBools(c.l.context, key, b)
|
||||
return c
|
||||
}
|
||||
|
||||
// Int adds the field key with i as a int to the logger context.
|
||||
func (c Context) Int(key string, i int) Context {
|
||||
c.l.context = appendInt(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Ints adds the field key with i as a []int to the logger context.
|
||||
func (c Context) Ints(key string, i []int) Context {
|
||||
c.l.context = appendInts(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Int8 adds the field key with i as a int8 to the logger context.
|
||||
func (c Context) Int8(key string, i int8) Context {
|
||||
c.l.context = appendInt8(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Ints8 adds the field key with i as a []int8 to the logger context.
|
||||
func (c Context) Ints8(key string, i []int8) Context {
|
||||
c.l.context = appendInts8(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Int16 adds the field key with i as a int16 to the logger context.
|
||||
func (c Context) Int16(key string, i int16) Context {
|
||||
c.l.context = appendInt16(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Ints16 adds the field key with i as a []int16 to the logger context.
|
||||
func (c Context) Ints16(key string, i []int16) Context {
|
||||
c.l.context = appendInts16(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Int32 adds the field key with i as a int32 to the logger context.
|
||||
func (c Context) Int32(key string, i int32) Context {
|
||||
c.l.context = appendInt32(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Ints32 adds the field key with i as a []int32 to the logger context.
|
||||
func (c Context) Ints32(key string, i []int32) Context {
|
||||
c.l.context = appendInts32(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Int64 adds the field key with i as a int64 to the logger context.
|
||||
func (c Context) Int64(key string, i int64) Context {
|
||||
c.l.context = appendInt64(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Ints64 adds the field key with i as a []int64 to the logger context.
|
||||
func (c Context) Ints64(key string, i []int64) Context {
|
||||
c.l.context = appendInts64(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Uint adds the field key with i as a uint to the logger context.
|
||||
func (c Context) Uint(key string, i uint) Context {
|
||||
c.l.context = appendUint(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Uints adds the field key with i as a []uint to the logger context.
|
||||
func (c Context) Uints(key string, i []uint) Context {
|
||||
c.l.context = appendUints(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Uint8 adds the field key with i as a uint8 to the logger context.
|
||||
func (c Context) Uint8(key string, i uint8) Context {
|
||||
c.l.context = appendUint8(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Uints8 adds the field key with i as a []uint8 to the logger context.
|
||||
func (c Context) Uints8(key string, i []uint8) Context {
|
||||
c.l.context = appendUints8(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Uint16 adds the field key with i as a uint16 to the logger context.
|
||||
func (c Context) Uint16(key string, i uint16) Context {
|
||||
c.l.context = appendUint16(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Uints16 adds the field key with i as a []uint16 to the logger context.
|
||||
func (c Context) Uints16(key string, i []uint16) Context {
|
||||
c.l.context = appendUints16(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Uint32 adds the field key with i as a uint32 to the logger context.
|
||||
func (c Context) Uint32(key string, i uint32) Context {
|
||||
c.l.context = appendUint32(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Uints32 adds the field key with i as a []uint32 to the logger context.
|
||||
func (c Context) Uints32(key string, i []uint32) Context {
|
||||
c.l.context = appendUints32(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Uint64 adds the field key with i as a uint64 to the logger context.
|
||||
func (c Context) Uint64(key string, i uint64) Context {
|
||||
c.l.context = appendUint64(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Uints64 adds the field key with i as a []uint64 to the logger context.
|
||||
func (c Context) Uints64(key string, i []uint64) Context {
|
||||
c.l.context = appendUints64(c.l.context, key, i)
|
||||
return c
|
||||
}
|
||||
|
||||
// Float32 adds the field key with f as a float32 to the logger context.
|
||||
func (c Context) Float32(key string, f float32) Context {
|
||||
c.l.context = appendFloat32(c.l.context, key, f)
|
||||
return c
|
||||
}
|
||||
|
||||
// Floats32 adds the field key with f as a []float32 to the logger context.
|
||||
func (c Context) Floats32(key string, f []float32) Context {
|
||||
c.l.context = appendFloats32(c.l.context, key, f)
|
||||
return c
|
||||
}
|
||||
|
||||
// Float64 adds the field key with f as a float64 to the logger context.
|
||||
func (c Context) Float64(key string, f float64) Context {
|
||||
c.l.context = appendFloat64(c.l.context, key, f)
|
||||
return c
|
||||
}
|
||||
|
||||
// Floats64 adds the field key with f as a []float64 to the logger context.
|
||||
func (c Context) Floats64(key string, f []float64) Context {
|
||||
c.l.context = appendFloats64(c.l.context, key, f)
|
||||
return c
|
||||
}
|
||||
|
||||
// Timestamp adds the current local time as UNIX timestamp to the logger context with the "time" key.
|
||||
// To customize the key name, change zerolog.TimestampFieldName.
|
||||
func (c Context) Timestamp() Context {
|
||||
|
|
@ -146,12 +236,24 @@ func (c Context) Time(key string, t time.Time) Context {
|
|||
return c
|
||||
}
|
||||
|
||||
// Times adds the field key with t formated as string using zerolog.TimeFieldFormat.
|
||||
func (c Context) Times(key string, t []time.Time) Context {
|
||||
c.l.context = appendTimes(c.l.context, key, t)
|
||||
return c
|
||||
}
|
||||
|
||||
// Dur adds the fields key with d divided by unit and stored as a float.
|
||||
func (c Context) Dur(key string, d time.Duration) Context {
|
||||
c.l.context = appendDuration(c.l.context, key, d)
|
||||
return c
|
||||
}
|
||||
|
||||
// Durs adds the fields key with d divided by unit and stored as a float.
|
||||
func (c Context) Durs(key string, d []time.Duration) Context {
|
||||
c.l.context = appendDurations(c.l.context, key, d)
|
||||
return c
|
||||
}
|
||||
|
||||
// Interface adds the field key with obj marshaled using reflection.
|
||||
func (c Context) Interface(key string, i interface{}) Context {
|
||||
c.l.context = appendInterface(c.l.context, key, i)
|
||||
|
|
|
|||
158
event.go
158
event.go
|
|
@ -130,6 +130,15 @@ func (e *Event) Str(key, val string) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendStrings(e.buf, key, vals)
|
||||
return e
|
||||
}
|
||||
|
||||
// Bytes adds the field key with val as a []byte to the *Event context.
|
||||
func (e *Event) Bytes(key string, val []byte) *Event {
|
||||
if !e.enabled {
|
||||
|
|
@ -149,6 +158,16 @@ func (e *Event) AnErr(key string, err error) *Event {
|
|||
return e
|
||||
}
|
||||
|
||||
// Errs adds the field key with errs as an array of strings to the *Event context.
|
||||
// If err is nil, no field is added.
|
||||
func (e *Event) Errs(key string, errs []error) *Event {
|
||||
if !e.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendErrorsKey(e.buf, key, errs)
|
||||
return e
|
||||
}
|
||||
|
||||
// Err adds the field "error" with err as a string to the *Event context.
|
||||
// If err is nil, no field is added.
|
||||
// To customize the key name, change zerolog.ErrorFieldName.
|
||||
|
|
@ -160,7 +179,7 @@ func (e *Event) Err(err error) *Event {
|
|||
return e
|
||||
}
|
||||
|
||||
// Bool adds the field key with val as a Boolean to the *Event context.
|
||||
// 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.enabled {
|
||||
return e
|
||||
|
|
@ -169,6 +188,15 @@ func (e *Event) Bool(key string, b bool) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendBools(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.enabled {
|
||||
|
|
@ -178,6 +206,15 @@ func (e *Event) Int(key string, i int) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendInts(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.enabled {
|
||||
|
|
@ -187,6 +224,15 @@ func (e *Event) Int8(key string, i int8) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendInts8(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.enabled {
|
||||
|
|
@ -196,6 +242,15 @@ func (e *Event) Int16(key string, i int16) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendInts16(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.enabled {
|
||||
|
|
@ -205,6 +260,15 @@ func (e *Event) Int32(key string, i int32) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendInts32(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.enabled {
|
||||
|
|
@ -214,6 +278,15 @@ func (e *Event) Int64(key string, i int64) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendInts64(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.enabled {
|
||||
|
|
@ -223,6 +296,15 @@ func (e *Event) Uint(key string, i uint) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendUints(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.enabled {
|
||||
|
|
@ -232,6 +314,15 @@ func (e *Event) Uint8(key string, i uint8) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendUints8(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.enabled {
|
||||
|
|
@ -241,6 +332,15 @@ func (e *Event) Uint16(key string, i uint16) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendUints16(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.enabled {
|
||||
|
|
@ -250,6 +350,15 @@ func (e *Event) Uint32(key string, i uint32) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendUints32(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.enabled {
|
||||
|
|
@ -259,6 +368,15 @@ func (e *Event) Uint64(key string, i uint64) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendUints64(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.enabled {
|
||||
|
|
@ -268,6 +386,15 @@ func (e *Event) Float32(key string, f float32) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendFloats32(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.enabled {
|
||||
|
|
@ -277,6 +404,15 @@ func (e *Event) Float64(key string, f float64) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendFloats64(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.
|
||||
func (e *Event) Timestamp() *Event {
|
||||
|
|
@ -296,6 +432,15 @@ func (e *Event) Time(key string, t time.Time) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendTimes(e.buf, key, t)
|
||||
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.
|
||||
|
|
@ -307,6 +452,17 @@ func (e *Event) Dur(key string, d time.Duration) *Event {
|
|||
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.enabled {
|
||||
return e
|
||||
}
|
||||
e.buf = appendDurations(e.buf, key, d)
|
||||
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().
|
||||
|
|
|
|||
337
field.go
337
field.go
|
|
@ -22,6 +22,8 @@ func appendFields(dst []byte, fields map[string]interface{}) []byte {
|
|||
dst = appendBytes(dst, key, val)
|
||||
case error:
|
||||
dst = appendErrorKey(dst, key, val)
|
||||
case []error:
|
||||
dst = appendErrorsKey(dst, key, val)
|
||||
case bool:
|
||||
dst = appendBool(dst, key, val)
|
||||
case int:
|
||||
|
|
@ -52,6 +54,38 @@ func appendFields(dst []byte, fields map[string]interface{}) []byte {
|
|||
dst = appendTime(dst, key, val)
|
||||
case time.Duration:
|
||||
dst = appendDuration(dst, key, val)
|
||||
case []string:
|
||||
dst = appendStrings(dst, key, val)
|
||||
case []bool:
|
||||
dst = appendBools(dst, key, val)
|
||||
case []int:
|
||||
dst = appendInts(dst, key, val)
|
||||
case []int8:
|
||||
dst = appendInts8(dst, key, val)
|
||||
case []int16:
|
||||
dst = appendInts16(dst, key, val)
|
||||
case []int32:
|
||||
dst = appendInts32(dst, key, val)
|
||||
case []int64:
|
||||
dst = appendInts64(dst, key, val)
|
||||
case []uint:
|
||||
dst = appendUints(dst, key, val)
|
||||
// case []uint8:
|
||||
// dst = appendUints8(dst, key, val)
|
||||
case []uint16:
|
||||
dst = appendUints16(dst, key, val)
|
||||
case []uint32:
|
||||
dst = appendUints32(dst, key, val)
|
||||
case []uint64:
|
||||
dst = appendUints64(dst, key, val)
|
||||
case []float32:
|
||||
dst = appendFloats32(dst, key, val)
|
||||
case []float64:
|
||||
dst = appendFloats64(dst, key, val)
|
||||
case []time.Time:
|
||||
dst = appendTimes(dst, key, val)
|
||||
case []time.Duration:
|
||||
dst = appendDurations(dst, key, val)
|
||||
case nil:
|
||||
dst = append(appendKey(dst, key), "null"...)
|
||||
default:
|
||||
|
|
@ -73,6 +107,21 @@ func appendString(dst []byte, key, val string) []byte {
|
|||
return appendJSONString(appendKey(dst, key), val)
|
||||
}
|
||||
|
||||
func appendStrings(dst []byte, key string, vals []string) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = appendJSONString(dst, vals[0])
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = appendJSONString(append(dst, ','), val)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendBytes(dst []byte, key string, val []byte) []byte {
|
||||
return appendJSONBytes(appendKey(dst, key), val)
|
||||
}
|
||||
|
|
@ -84,6 +133,29 @@ func appendErrorKey(dst []byte, key string, err error) []byte {
|
|||
return appendJSONString(appendKey(dst, key), err.Error())
|
||||
}
|
||||
|
||||
func appendErrorsKey(dst []byte, key string, errs []error) []byte {
|
||||
if len(errs) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
if errs[0] != nil {
|
||||
dst = appendJSONString(dst, errs[0].Error())
|
||||
} else {
|
||||
dst = append(dst, "null"...)
|
||||
}
|
||||
if len(errs) > 1 {
|
||||
for _, err := range errs[1:] {
|
||||
if err == nil {
|
||||
dst = append(dst, ",null"...)
|
||||
continue
|
||||
}
|
||||
dst = appendJSONString(append(dst, ','), err.Error())
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendError(dst []byte, err error) []byte {
|
||||
return appendErrorKey(dst, ErrorFieldName, err)
|
||||
}
|
||||
|
|
@ -92,52 +164,247 @@ func appendBool(dst []byte, key string, val bool) []byte {
|
|||
return strconv.AppendBool(appendKey(dst, key), val)
|
||||
}
|
||||
|
||||
func appendBools(dst []byte, key string, vals []bool) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendBool(dst, vals[0])
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = strconv.AppendBool(append(dst, ','), val)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendInt(dst []byte, key string, val int) []byte {
|
||||
return strconv.AppendInt(appendKey(dst, key), int64(val), 10)
|
||||
}
|
||||
|
||||
func appendInts(dst []byte, key string, vals []int) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendInt(dst, int64(vals[0]), 10)
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = strconv.AppendInt(append(dst, ','), int64(val), 10)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendInt8(dst []byte, key string, val int8) []byte {
|
||||
return strconv.AppendInt(appendKey(dst, key), int64(val), 10)
|
||||
}
|
||||
|
||||
func appendInts8(dst []byte, key string, vals []int8) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendInt(dst, int64(vals[0]), 10)
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = strconv.AppendInt(append(dst, ','), int64(val), 10)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendInt16(dst []byte, key string, val int16) []byte {
|
||||
return strconv.AppendInt(appendKey(dst, key), int64(val), 10)
|
||||
}
|
||||
|
||||
func appendInts16(dst []byte, key string, vals []int16) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendInt(dst, int64(vals[0]), 10)
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = strconv.AppendInt(append(dst, ','), int64(val), 10)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendInt32(dst []byte, key string, val int32) []byte {
|
||||
return strconv.AppendInt(appendKey(dst, key), int64(val), 10)
|
||||
}
|
||||
|
||||
func appendInts32(dst []byte, key string, vals []int32) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendInt(dst, int64(vals[0]), 10)
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = strconv.AppendInt(append(dst, ','), int64(val), 10)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendInt64(dst []byte, key string, val int64) []byte {
|
||||
return strconv.AppendInt(appendKey(dst, key), int64(val), 10)
|
||||
return strconv.AppendInt(appendKey(dst, key), val, 10)
|
||||
}
|
||||
|
||||
func appendInts64(dst []byte, key string, vals []int64) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendInt(dst, vals[0], 10)
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = strconv.AppendInt(append(dst, ','), val, 10)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendUint(dst []byte, key string, val uint) []byte {
|
||||
return strconv.AppendUint(appendKey(dst, key), uint64(val), 10)
|
||||
}
|
||||
|
||||
func appendUints(dst []byte, key string, vals []uint) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendUint(dst, uint64(vals[0]), 10)
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = strconv.AppendUint(append(dst, ','), uint64(val), 10)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendUint8(dst []byte, key string, val uint8) []byte {
|
||||
return strconv.AppendUint(appendKey(dst, key), uint64(val), 10)
|
||||
}
|
||||
|
||||
func appendUints8(dst []byte, key string, vals []uint8) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendUint(dst, uint64(vals[0]), 10)
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = strconv.AppendUint(append(dst, ','), uint64(val), 10)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendUint16(dst []byte, key string, val uint16) []byte {
|
||||
return strconv.AppendUint(appendKey(dst, key), uint64(val), 10)
|
||||
}
|
||||
|
||||
func appendUints16(dst []byte, key string, vals []uint16) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendUint(dst, uint64(vals[0]), 10)
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = strconv.AppendUint(append(dst, ','), uint64(val), 10)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendUint32(dst []byte, key string, val uint32) []byte {
|
||||
return strconv.AppendUint(appendKey(dst, key), uint64(val), 10)
|
||||
}
|
||||
|
||||
func appendUints32(dst []byte, key string, vals []uint32) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendUint(dst, uint64(vals[0]), 10)
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = strconv.AppendUint(append(dst, ','), uint64(val), 10)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendUint64(dst []byte, key string, val uint64) []byte {
|
||||
return strconv.AppendUint(appendKey(dst, key), uint64(val), 10)
|
||||
}
|
||||
|
||||
func appendUints64(dst []byte, key string, vals []uint64) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendUint(dst, vals[0], 10)
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = strconv.AppendUint(append(dst, ','), val, 10)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendFloat32(dst []byte, key string, val float32) []byte {
|
||||
return strconv.AppendFloat(appendKey(dst, key), float64(val), 'f', -1, 32)
|
||||
}
|
||||
|
||||
func appendFloats32(dst []byte, key string, vals []float32) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendFloat(dst, float64(vals[0]), 'f', -1, 32)
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = strconv.AppendFloat(append(dst, ','), float64(val), 'f', -1, 32)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendFloat64(dst []byte, key string, val float64) []byte {
|
||||
return strconv.AppendFloat(appendKey(dst, key), float64(val), 'f', -1, 32)
|
||||
return strconv.AppendFloat(appendKey(dst, key), val, 'f', -1, 32)
|
||||
}
|
||||
|
||||
func appendFloats64(dst []byte, key string, vals []float64) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendFloat(dst, vals[0], 'f', -1, 32)
|
||||
if len(vals) > 1 {
|
||||
for _, val := range vals[1:] {
|
||||
dst = strconv.AppendFloat(append(dst, ','), val, 'f', -1, 32)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendTime(dst []byte, key string, t time.Time) []byte {
|
||||
|
|
@ -147,6 +414,39 @@ func appendTime(dst []byte, key string, t time.Time) []byte {
|
|||
return append(t.AppendFormat(append(appendKey(dst, key), '"'), TimeFieldFormat), '"')
|
||||
}
|
||||
|
||||
func appendTimes(dst []byte, key string, vals []time.Time) []byte {
|
||||
if TimeFieldFormat == "" {
|
||||
return appendUnixTimes(dst, key, vals)
|
||||
}
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = append(vals[0].AppendFormat(append(dst, '"'), TimeFieldFormat), '"')
|
||||
if len(vals) > 1 {
|
||||
for _, t := range vals[1:] {
|
||||
dst = append(t.AppendFormat(append(dst, ',', '"'), TimeFieldFormat), '"')
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendUnixTimes(dst []byte, key string, vals []time.Time) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendInt(dst, vals[0].Unix(), 10)
|
||||
if len(vals) > 1 {
|
||||
for _, t := range vals[1:] {
|
||||
dst = strconv.AppendInt(dst, t.Unix(), 10)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendTimestamp(dst []byte) []byte {
|
||||
return appendTime(dst, TimestampFieldName, TimestampFunc())
|
||||
}
|
||||
|
|
@ -158,6 +458,39 @@ func appendDuration(dst []byte, key string, d time.Duration) []byte {
|
|||
return appendFloat64(dst, key, float64(d)/float64(DurationFieldUnit))
|
||||
}
|
||||
|
||||
func appendDurations(dst []byte, key string, vals []time.Duration) []byte {
|
||||
if DurationFieldInteger {
|
||||
return appendIntDurations(dst, key, vals)
|
||||
}
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendFloat(dst, float64(vals[0])/float64(DurationFieldUnit), 'f', -1, 32)
|
||||
if len(vals) > 1 {
|
||||
for _, d := range vals[1:] {
|
||||
dst = strconv.AppendFloat(append(dst, ','), float64(d)/float64(DurationFieldUnit), 'f', -1, 32)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendIntDurations(dst []byte, key string, vals []time.Duration) []byte {
|
||||
if len(vals) == 0 {
|
||||
return append(appendKey(dst, key), '[', ']')
|
||||
}
|
||||
dst = append(appendKey(dst, key), '[')
|
||||
dst = strconv.AppendInt(dst, int64(vals[0]/DurationFieldUnit), 10)
|
||||
if len(vals) > 1 {
|
||||
for _, d := range vals[1:] {
|
||||
dst = strconv.AppendInt(append(dst, ','), int64(d/DurationFieldUnit), 10)
|
||||
}
|
||||
}
|
||||
dst = append(dst, ']')
|
||||
return dst
|
||||
}
|
||||
|
||||
func appendInterface(dst []byte, key string, i interface{}) []byte {
|
||||
marshaled, err := json.Marshal(i)
|
||||
if err != nil {
|
||||
|
|
|
|||
|
|
@ -168,6 +168,22 @@ func ExampleEvent_Dur() {
|
|||
// Output: {"foo":"bar","dur":10000,"message":"hello world"}
|
||||
}
|
||||
|
||||
func ExampleEvent_Durs() {
|
||||
d := []time.Duration{
|
||||
time.Duration(10 * time.Second),
|
||||
time.Duration(20 * time.Second),
|
||||
}
|
||||
|
||||
log := zerolog.New(os.Stdout)
|
||||
|
||||
log.Log().
|
||||
Str("foo", "bar").
|
||||
Durs("durs", d).
|
||||
Msg("hello world")
|
||||
|
||||
// Output: {"foo":"bar","durs":[10000,20000],"message":"hello world"}
|
||||
}
|
||||
|
||||
func ExampleContext_Dict() {
|
||||
log := zerolog.New(os.Stdout).With().
|
||||
Str("foo", "bar").
|
||||
|
|
@ -210,3 +226,19 @@ func ExampleContext_Dur() {
|
|||
|
||||
// Output: {"foo":"bar","dur":10000,"message":"hello world"}
|
||||
}
|
||||
|
||||
func ExampleContext_Durs() {
|
||||
d := []time.Duration{
|
||||
time.Duration(10 * time.Second),
|
||||
time.Duration(20 * time.Second),
|
||||
}
|
||||
|
||||
log := zerolog.New(os.Stdout).With().
|
||||
Str("foo", "bar").
|
||||
Durs("durs", d).
|
||||
Logger()
|
||||
|
||||
log.Log().Msg("hello world")
|
||||
|
||||
// Output: {"foo":"bar","durs":[10000,20000],"message":"hello world"}
|
||||
}
|
||||
|
|
|
|||
81
log_test.go
81
log_test.go
|
|
@ -159,6 +159,87 @@ func TestFields(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
func TestFieldsArrayEmpty(t *testing.T) {
|
||||
out := &bytes.Buffer{}
|
||||
log := New(out)
|
||||
log.Log().
|
||||
Strs("string", []string{}).
|
||||
Errs("err", []error{}).
|
||||
Bools("bool", []bool{}).
|
||||
Ints("int", []int{}).
|
||||
Ints8("int8", []int8{}).
|
||||
Ints16("int16", []int16{}).
|
||||
Ints32("int32", []int32{}).
|
||||
Ints64("int64", []int64{}).
|
||||
Uints("uint", []uint{}).
|
||||
Uints8("uint8", []uint8{}).
|
||||
Uints16("uint16", []uint16{}).
|
||||
Uints32("uint32", []uint32{}).
|
||||
Uints64("uint64", []uint64{}).
|
||||
Floats32("float32", []float32{}).
|
||||
Floats64("float64", []float64{}).
|
||||
Durs("dur", []time.Duration{}).
|
||||
Times("time", []time.Time{}).
|
||||
Msg("")
|
||||
if got, want := out.String(), `{"string":[],"err":[],"bool":[],"int":[],"int8":[],"int16":[],"int32":[],"int64":[],"uint":[],"uint8":[],"uint16":[],"uint32":[],"uint64":[],"float32":[],"float64":[],"dur":[],"time":[]}`+"\n"; got != want {
|
||||
t.Errorf("invalid log output:\ngot: %v\nwant: %v", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFieldsArraySingleElement(t *testing.T) {
|
||||
out := &bytes.Buffer{}
|
||||
log := New(out)
|
||||
log.Log().
|
||||
Strs("string", []string{"foo"}).
|
||||
Errs("err", []error{errors.New("some error")}).
|
||||
Bools("bool", []bool{true}).
|
||||
Ints("int", []int{1}).
|
||||
Ints8("int8", []int8{2}).
|
||||
Ints16("int16", []int16{3}).
|
||||
Ints32("int32", []int32{4}).
|
||||
Ints64("int64", []int64{5}).
|
||||
Uints("uint", []uint{6}).
|
||||
Uints8("uint8", []uint8{7}).
|
||||
Uints16("uint16", []uint16{8}).
|
||||
Uints32("uint32", []uint32{9}).
|
||||
Uints64("uint64", []uint64{10}).
|
||||
Floats32("float32", []float32{11}).
|
||||
Floats64("float64", []float64{12}).
|
||||
Durs("dur", []time.Duration{1 * time.Second}).
|
||||
Times("time", []time.Time{time.Time{}}).
|
||||
Msg("")
|
||||
if got, want := out.String(), `{"string":["foo"],"err":["some error"],"bool":[true],"int":[1],"int8":[2],"int16":[3],"int32":[4],"int64":[5],"uint":[6],"uint8":[7],"uint16":[8],"uint32":[9],"uint64":[10],"float32":[11],"float64":[12],"dur":[1000],"time":["0001-01-01T00:00:00Z"]}`+"\n"; got != want {
|
||||
t.Errorf("invalid log output:\ngot: %v\nwant: %v", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFieldsArrayMultipleElement(t *testing.T) {
|
||||
out := &bytes.Buffer{}
|
||||
log := New(out)
|
||||
log.Log().
|
||||
Strs("string", []string{"foo", "bar"}).
|
||||
Errs("err", []error{errors.New("some error"), nil}).
|
||||
Bools("bool", []bool{true, false}).
|
||||
Ints("int", []int{1, 0}).
|
||||
Ints8("int8", []int8{2, 0}).
|
||||
Ints16("int16", []int16{3, 0}).
|
||||
Ints32("int32", []int32{4, 0}).
|
||||
Ints64("int64", []int64{5, 0}).
|
||||
Uints("uint", []uint{6, 0}).
|
||||
Uints8("uint8", []uint8{7, 0}).
|
||||
Uints16("uint16", []uint16{8, 0}).
|
||||
Uints32("uint32", []uint32{9, 0}).
|
||||
Uints64("uint64", []uint64{10, 0}).
|
||||
Floats32("float32", []float32{11, 0}).
|
||||
Floats64("float64", []float64{12, 0}).
|
||||
Durs("dur", []time.Duration{1 * time.Second, 0}).
|
||||
Times("time", []time.Time{time.Time{}, time.Time{}}).
|
||||
Msg("")
|
||||
if got, want := out.String(), `{"string":["foo","bar"],"err":["some error",null],"bool":[true,false],"int":[1,0],"int8":[2,0],"int16":[3,0],"int32":[4,0],"int64":[5,0],"uint":[6,0],"uint8":[7,0],"uint16":[8,0],"uint32":[9,0],"uint64":[10,0],"float32":[11,0],"float64":[12,0],"dur":[1000,0],"time":["0001-01-01T00:00:00Z","0001-01-01T00:00:00Z"]}`+"\n"; got != want {
|
||||
t.Errorf("invalid log output:\ngot: %v\nwant: %v", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFieldsDisabled(t *testing.T) {
|
||||
out := &bytes.Buffer{}
|
||||
log := New(out).Level(InfoLevel)
|
||||
|
|
|
|||
Loading…
Reference in New Issue