From 2aa3c3ae4f8bc5fa17be275eccab2f6f4611f231 Mon Sep 17 00:00:00 2001 From: Olivier Poitrey Date: Tue, 25 Jul 2017 12:50:35 -0700 Subject: [PATCH] Add some array types support --- context.go | 104 +++++++++++++- event.go | 158 ++++++++++++++++++++- field.go | 337 +++++++++++++++++++++++++++++++++++++++++++- log_example_test.go | 32 +++++ log_test.go | 81 +++++++++++ 5 files changed, 708 insertions(+), 4 deletions(-) diff --git a/context.go b/context.go index 6c62e00..1e3a330 100644 --- a/context.go +++ b/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) diff --git a/event.go b/event.go index e7c0e1b..94676f0 100644 --- a/event.go +++ b/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(). diff --git a/field.go b/field.go index e4829c7..31be55b 100644 --- a/field.go +++ b/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 { diff --git a/log_example_test.go b/log_example_test.go index 7915865..63c1a44 100644 --- a/log_example_test.go +++ b/log_example_test.go @@ -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"} +} diff --git a/log_test.go b/log_test.go index c2b8a58..a0f2f11 100644 --- a/log_test.go +++ b/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)