update field
This commit is contained in:
andrey
303
field/encoder.go
303
field/encoder.go
@@ -1,32 +1,281 @@
|
||||
//nolint:gomnd
|
||||
package field
|
||||
|
||||
import "time"
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"time"
|
||||
"unicode"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
//nolint:interfacebloat
|
||||
type Encoder interface {
|
||||
// Built-in types.
|
||||
AddArray(key string, value Value)
|
||||
AddAny(key string, value Value)
|
||||
AddNil(key string)
|
||||
AddBool(key string, value bool)
|
||||
AddBinary(key string, value []byte)
|
||||
AddInt(key string, value int)
|
||||
AddInt8(key string, value int8)
|
||||
AddInt16(key string, value int16)
|
||||
AddInt32(key string, value int32)
|
||||
AddInt64(key string, value int64)
|
||||
AddUint(key string, value uint)
|
||||
AddUint8(key string, value uint8)
|
||||
AddUint16(key string, value uint16)
|
||||
AddUint32(key string, value uint32)
|
||||
AddUint64(key string, value uint64)
|
||||
AddUintptr(key string, value uintptr)
|
||||
AddTime(key string, value time.Time)
|
||||
AddDuration(key string, value time.Duration)
|
||||
AddFloat32(key string, value float32)
|
||||
AddFloat64(key string, value float64)
|
||||
AddComplex64(key string, value complex64)
|
||||
AddComplex128(key string, value complex128)
|
||||
AddString(key, value string)
|
||||
AddError(key string, value error)
|
||||
AppendField(dst []byte, field Field) []byte
|
||||
AppendValue(dst []byte, val Value) []byte
|
||||
}
|
||||
|
||||
func WithAppendString(fn func(dst []byte, in string) []byte) func(*BaseEncoder) {
|
||||
return func(be *BaseEncoder) {
|
||||
be.AppendString = fn
|
||||
}
|
||||
}
|
||||
|
||||
func WithNullValue(in string) func(*BaseEncoder) {
|
||||
return func(be *BaseEncoder) {
|
||||
be.nullValue = []byte(in)
|
||||
}
|
||||
}
|
||||
|
||||
func WithDelimeter(in byte) func(*BaseEncoder) {
|
||||
return func(be *BaseEncoder) {
|
||||
be.delimeter = in
|
||||
}
|
||||
}
|
||||
|
||||
func WithGropuConfig(start, end, deli byte) func(*BaseEncoder) {
|
||||
return func(be *BaseEncoder) {
|
||||
be.group = groupConfig{
|
||||
start: start,
|
||||
end: end,
|
||||
deli: deli,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func WithDefaultValue(fn func(dst []byte, e Encoder, val Value) []byte) func(*BaseEncoder) {
|
||||
return func(be *BaseEncoder) {
|
||||
be.DefaultValue = fn
|
||||
}
|
||||
}
|
||||
|
||||
func NewEncoder(opts ...func(*BaseEncoder)) BaseEncoder {
|
||||
be := BaseEncoder{
|
||||
nullValue: []byte("null"),
|
||||
group: groupConfig{
|
||||
start: '{',
|
||||
end: '}',
|
||||
deli: ',',
|
||||
},
|
||||
array: groupConfig{
|
||||
start: '[',
|
||||
end: ']',
|
||||
deli: ',',
|
||||
},
|
||||
timeFormat: time.RFC3339,
|
||||
AppendString: AppendString,
|
||||
delimeter: '=',
|
||||
DefaultValue: func(dst []byte, e Encoder, val Value) []byte {
|
||||
return e.AppendValue(dst, StringValue(fmt.Sprintf("%+v", val.Any())))
|
||||
},
|
||||
}
|
||||
|
||||
for _, opt := range opts {
|
||||
opt(&be)
|
||||
}
|
||||
|
||||
return be
|
||||
}
|
||||
|
||||
type groupConfig struct {
|
||||
start byte
|
||||
end byte
|
||||
deli byte
|
||||
}
|
||||
|
||||
type BaseEncoder struct {
|
||||
nullValue []byte
|
||||
group groupConfig
|
||||
array groupConfig
|
||||
timeFormat string
|
||||
AppendString func(dst []byte, in string) []byte
|
||||
delimeter byte
|
||||
DefaultValue func(dst []byte, e Encoder, val Value) []byte
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendValue(dst []byte, val Value) []byte {
|
||||
return b.appendValue(dst, val, "", 0)
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendDelimiter(dst []byte, deli byte) []byte {
|
||||
if deli == 0 {
|
||||
return dst
|
||||
}
|
||||
|
||||
return append(dst, deli)
|
||||
}
|
||||
|
||||
//nolint:gocyclo,cyclop
|
||||
func (b BaseEncoder) appendValue(dst []byte, val Value, prefix string, deli byte) []byte {
|
||||
switch val.Kind {
|
||||
case KindGroup:
|
||||
return b.appendGroup(dst, val.AsGroup(), prefix)
|
||||
case KindClosure:
|
||||
return b.appendValue(dst, AnyValue(val.Resolve()), prefix, deli)
|
||||
case KindArray:
|
||||
return b.AppendArray(b.AppendDelimiter(dst, deli), val.AsArray())
|
||||
case KindNil:
|
||||
return b.AppendNull(b.AppendDelimiter(dst, deli))
|
||||
case KindBool:
|
||||
return b.AppendBool(b.AppendDelimiter(dst, deli), val.AsBool())
|
||||
case KindBinary:
|
||||
return b.AppendBytes(b.AppendDelimiter(dst, deli), val.AsBinary())
|
||||
case KindComplex128:
|
||||
return b.AppendComplex(b.AppendDelimiter(dst, deli), val.AsComplex128())
|
||||
case KindInt64:
|
||||
return b.AppendInt(b.AppendDelimiter(dst, deli), val.AsInt64())
|
||||
case KindFloat32:
|
||||
return b.AppendFloat(b.AppendDelimiter(dst, deli), float64(val.AsFloat32()), 32)
|
||||
case KindFloat64:
|
||||
return b.AppendFloat(b.AppendDelimiter(dst, deli), val.AsFloat64(), 64)
|
||||
case KindUint64:
|
||||
return b.AppendUint(b.AppendDelimiter(dst, deli), val.AsUint64())
|
||||
case KindError:
|
||||
return b.AppendString(b.AppendDelimiter(dst, deli), val.AsError().Error())
|
||||
case KindString:
|
||||
return b.AppendString(b.AppendDelimiter(dst, deli), val.AsString())
|
||||
case KindDuration:
|
||||
return b.AppendDuration(b.AppendDelimiter(dst, deli), val.AsDuration())
|
||||
case KindTime:
|
||||
return b.AppendTime(b.AppendDelimiter(dst, deli), val.AsTime())
|
||||
case KindAny:
|
||||
return b.DefaultValue(b.AppendDelimiter(dst, deli), b, val)
|
||||
}
|
||||
|
||||
return b.DefaultValue(b.AppendDelimiter(dst, deli), b, val)
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendDuration(dst []byte, d time.Duration) []byte {
|
||||
return b.AppendString(dst, d.String())
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendTime(dst []byte, t time.Time) []byte {
|
||||
return b.AppendString(dst, t.Format(b.timeFormat))
|
||||
}
|
||||
|
||||
func AppendString(dst []byte, in string) []byte {
|
||||
if needsQuoting(in) {
|
||||
return strconv.AppendQuote(dst, in)
|
||||
}
|
||||
|
||||
return append(dst, in...)
|
||||
}
|
||||
|
||||
//nolint:cyclop
|
||||
func needsQuoting(in string) bool {
|
||||
if len(in) == 0 {
|
||||
return true
|
||||
}
|
||||
|
||||
for i := 0; i < len(in); {
|
||||
char := in[i]
|
||||
if char < utf8.RuneSelf {
|
||||
// Quote anything except a backslash that would need quoting in a
|
||||
// JSON string, as well as space and '='
|
||||
if char != '\\' && (char == ' ' || char == '=' || !safeSet[char]) {
|
||||
return true
|
||||
}
|
||||
i++
|
||||
|
||||
continue
|
||||
}
|
||||
|
||||
decodeRune, size := utf8.DecodeRuneInString(in[i:])
|
||||
if decodeRune == utf8.RuneError || unicode.IsSpace(decodeRune) || !unicode.IsPrint(decodeRune) {
|
||||
return true
|
||||
}
|
||||
|
||||
i += size
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendField(dst []byte, field Field) []byte {
|
||||
prefix := ""
|
||||
|
||||
if len(dst) != 0 {
|
||||
prew := dst[len(dst)-1]
|
||||
if prew != '{' && prew != '.' {
|
||||
prefix = string(b.group.deli)
|
||||
}
|
||||
}
|
||||
|
||||
return b.appendField(dst, field, prefix, b.delimeter)
|
||||
}
|
||||
|
||||
func (b BaseEncoder) appendField(dst []byte, field Field, prefix string, deli byte) []byte {
|
||||
dst = b.AppendKey(dst, field.Key, prefix)
|
||||
|
||||
return b.appendValue(dst, field.Value, field.Key+".", deli)
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendKey(dst []byte, key string, prefix string) []byte {
|
||||
if prefix != "" {
|
||||
dst = append(dst, prefix...)
|
||||
}
|
||||
|
||||
return b.AppendString(dst, key)
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendComplex(dst []byte, c complex128) []byte {
|
||||
cmplx := strconv.FormatComplex(c, 'g', -1, 128)
|
||||
|
||||
return b.AppendString(dst, cmplx)
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendFloat(dst []byte, f float64, bitSize int) []byte {
|
||||
return strconv.AppendFloat(dst, f, 'g', -1, bitSize)
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendUint(dst []byte, u uint64) []byte {
|
||||
return strconv.AppendUint(dst, u, 10)
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendNull(dst []byte) []byte {
|
||||
return append(dst, b.nullValue...)
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendInt(dst []byte, val int64) []byte {
|
||||
return strconv.AppendInt(dst, val, 10)
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendBool(dst []byte, val bool) []byte {
|
||||
return strconv.AppendBool(dst, val)
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendGroup(dst []byte, fields []Field) []byte {
|
||||
dst = append(dst, b.group.start)
|
||||
dst = b.appendGroup(dst, fields, "")
|
||||
|
||||
return append(dst, b.group.end)
|
||||
}
|
||||
|
||||
func (b BaseEncoder) appendGroup(dst []byte, fields []Field, prefix string) []byte {
|
||||
if len(fields) > 0 {
|
||||
dst = b.appendField(dst, fields[0], ".", b.delimeter)
|
||||
for _, field := range fields[1:] {
|
||||
dst = b.appendField(append(dst, b.group.deli), field, prefix, b.delimeter)
|
||||
}
|
||||
}
|
||||
|
||||
return dst
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendArray(dst []byte, in []Value) []byte {
|
||||
dst = append(dst, b.array.start)
|
||||
if len(in) > 0 {
|
||||
dst = b.appendValue(dst, in[0], "", 0)
|
||||
for _, value := range in[1:] {
|
||||
dst = b.appendValue(append(dst, b.array.deli), value, "", 0)
|
||||
}
|
||||
}
|
||||
|
||||
return append(dst, b.array.end)
|
||||
}
|
||||
|
||||
func (b BaseEncoder) AppendBytes(dst, in []byte) []byte {
|
||||
dst = append(dst, '"')
|
||||
dst = append(dst, in...)
|
||||
|
||||
return append(dst, '"')
|
||||
}
|
||||
|
||||
23
field/encoder_json.go
Normal file
23
field/encoder_json.go
Normal file
@@ -0,0 +1,23 @@
|
||||
package field
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
func NewEncoderJSON(opts ...func(*BaseEncoder)) BaseEncoder {
|
||||
opts = append([]func(*BaseEncoder){
|
||||
WithAppendString(strconv.AppendQuote),
|
||||
WithDelimeter(':'),
|
||||
WithDefaultValue(func(dst []byte, e Encoder, val Value) []byte {
|
||||
js, err := json.Marshal(val.Any())
|
||||
if err != nil {
|
||||
return e.AppendValue(dst, ErrorValue(err))
|
||||
}
|
||||
|
||||
return append(dst, js...)
|
||||
}),
|
||||
}, opts...)
|
||||
|
||||
return NewEncoder(opts...)
|
||||
}
|
||||
38
field/encoder_json_test.go
Normal file
38
field/encoder_json_test.go
Normal file
@@ -0,0 +1,38 @@
|
||||
package field_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"gitoa.ru/go-4devs/log/field"
|
||||
"gitoa.ru/go-4devs/log/internal/buffer"
|
||||
)
|
||||
|
||||
func TestEncoderJSONAppendField_string(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
const expect = `"array":["value","other"],"str":"value","nullableStr":"value","nullstr":null`
|
||||
|
||||
encode := field.NewEncoderJSON()
|
||||
|
||||
buf := buffer.New()
|
||||
defer func() {
|
||||
buf.Free()
|
||||
}()
|
||||
|
||||
val := "value"
|
||||
strs := field.Strings("array", val, "other")
|
||||
*buf = encode.AppendField(*buf, strs)
|
||||
|
||||
str := field.String("str", val)
|
||||
*buf = encode.AppendField(*buf, str)
|
||||
|
||||
strp := field.Stringp("nullableStr", &val)
|
||||
*buf = encode.AppendField(*buf, strp)
|
||||
|
||||
nullStr := field.Stringp("nullstr", nil)
|
||||
*buf = encode.AppendField(*buf, nullStr)
|
||||
|
||||
if buf.String() != expect {
|
||||
t.Errorf("json string expect:%v got:%s", expect, buf)
|
||||
}
|
||||
}
|
||||
17
field/encoder_text.go
Normal file
17
field/encoder_text.go
Normal file
@@ -0,0 +1,17 @@
|
||||
package field
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
func NewEncoderText(opts ...func(*BaseEncoder)) BaseEncoder {
|
||||
opts = append([]func(*BaseEncoder){
|
||||
WithGropuConfig(0, 0, ' '),
|
||||
WithNullValue("<nil>"),
|
||||
WithDefaultValue(func(dst []byte, _ Encoder, val Value) []byte {
|
||||
return fmt.Appendf(dst, "%+v", val.Any())
|
||||
}),
|
||||
}, opts...)
|
||||
|
||||
return NewEncoder(opts...)
|
||||
}
|
||||
448
field/field.go
448
field/field.go
@@ -5,329 +5,499 @@ import (
|
||||
"time"
|
||||
)
|
||||
|
||||
func Any(key string, value interface{}) Field {
|
||||
return Key(key).Any(value)
|
||||
func Any(key string, value any) Field {
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func String(key, value string) Field {
|
||||
return Key(key).String(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: StringValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Stringp(key string, value *string) Field {
|
||||
return Key(key).Stringp(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: StringpValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Strings(key string, value ...string) Field {
|
||||
return Key(key).Strings(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: StringsValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Bool(key string, value bool) Field {
|
||||
return Key(key).Bool(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: BoolValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Bools(key string, value ...bool) Field {
|
||||
return Key(key).Bools(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: BoolsValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Boolp(key string, value *bool) Field {
|
||||
return Key(key).Boolp(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: BoolpValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Uint(key string, value uint) Field {
|
||||
return Key(key).Uint(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Uint64Value(uint64(value)),
|
||||
}
|
||||
}
|
||||
|
||||
func Uints(key string, value ...uint) Field {
|
||||
return Key(key).Uints(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Uintp(key string, value *uint) Field {
|
||||
return Key(key).Uintp(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Uint8(key string, value uint8) Field {
|
||||
return Key(key).Uint8(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Uint64Value(uint64(value)),
|
||||
}
|
||||
}
|
||||
|
||||
func Uint8s(key string, value ...uint8) Field {
|
||||
return Key(key).Uint8s(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Uint8p(key string, value *uint8) Field {
|
||||
return Key(key).Uint8p(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Uint16(key string, value uint16) Field {
|
||||
return Key(key).Uint16(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Uint64Value(uint64(value)),
|
||||
}
|
||||
}
|
||||
|
||||
func Uint16s(key string, value ...uint16) Field {
|
||||
return Key(key).Uint16s(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Uint16p(key string, value *uint16) Field {
|
||||
return Key(key).Uint16p(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Uint32(key string, value uint32) Field {
|
||||
return Key(key).Uint32(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Uint64Value(uint64(value)),
|
||||
}
|
||||
}
|
||||
|
||||
func Uint32s(key string, value ...uint32) Field {
|
||||
return Key(key).Uint32s(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Uint32p(key string, value *uint32) Field {
|
||||
return Key(key).Uint32p(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Uint64(key string, value uint64) Field {
|
||||
return Key(key).Uint64(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Uint64Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Uint64s(key string, value ...uint64) Field {
|
||||
return Key(key).Uint64s(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Uint64sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Uint64p(key string, value *uint64) Field {
|
||||
return Key(key).Uint64p(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Uint64pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Int(key string, value int) Field {
|
||||
return Key(key).Int(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Int64Value(int64(value)),
|
||||
}
|
||||
}
|
||||
|
||||
func Ints(key string, value ...int) Field {
|
||||
return Key(key).Ints(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Intp(key string, value *int) Field {
|
||||
return Key(key).Intp(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Int8(key string, value int8) Field {
|
||||
return Key(key).Int8(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Int64Value(int64(value)),
|
||||
}
|
||||
}
|
||||
|
||||
func Int8s(key string, value ...int8) Field {
|
||||
return Key(key).Int8s(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Int8p(key string, value *int8) Field {
|
||||
return Key(key).Int8p(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Int16(key string, value int16) Field {
|
||||
return Key(key).Int16(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Int64Value(int64(value)),
|
||||
}
|
||||
}
|
||||
|
||||
func Int16s(key string, value ...int16) Field {
|
||||
return Key(key).Int16s(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Int16p(key string, value *int16) Field {
|
||||
return Key(key).Int16p(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Int32(key string, value int32) Field {
|
||||
return Key(key).Int32(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Int64Value(int64(value)),
|
||||
}
|
||||
}
|
||||
|
||||
func Int32s(key string, value ...int32) Field {
|
||||
return Key(key).Int32s(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Int32p(key string, value *int32) Field {
|
||||
return Key(key).Int32p(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Int64(key string, value int64) Field {
|
||||
return Key(key).Int64(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Int64Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Int64s(key string, value ...int64) Field {
|
||||
return Key(key).Int64s(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Int64sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Int64p(key string, value *int64) Field {
|
||||
return Key(key).Int64p(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Int64pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Float32(key string, value float32) Field {
|
||||
return Key(key).Float32(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Float64Value(float64(value)),
|
||||
}
|
||||
}
|
||||
|
||||
func Float32s(key string, value ...float32) Field {
|
||||
return Key(key).Float32s(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Float32p(key string, value *float32) Field {
|
||||
return Key(key).Float32p(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Float64(key string, value float64) Field {
|
||||
return Key(key).Float64(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Float64Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Float64s(key string, value ...float64) Field {
|
||||
return Key(key).Float64s(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Float64sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Float64p(key string, value *float64) Field {
|
||||
return Key(key).Float64p(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Float64pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Complex64(key string, value complex64) Field {
|
||||
return Key(key).Complex64(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Complex128Value(complex128(value)),
|
||||
}
|
||||
}
|
||||
|
||||
func Complex64s(key string, value ...complex64) Field {
|
||||
return Key(key).Complex64s(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Complex64p(key string, value *complex64) Field {
|
||||
return Key(key).Complex64p(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Complex128(key string, value complex128) Field {
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Complex128Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Complex128s(key string, value ...complex128) Field {
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Complex128sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Complex128p(key string, value *complex128) Field {
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Complex128pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Uintptr(key string, value uintptr) Field {
|
||||
return Key(key).Uintptr(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: Uint64Value(uint64(value)),
|
||||
}
|
||||
}
|
||||
|
||||
func Uintptrs(key string, value ...uintptr) Field {
|
||||
return Key(key).Uintptrs(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Uintptrp(key string, value *uintptr) Field {
|
||||
return Key(key).Uintptrp(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Bytes(key string, value []byte) Field {
|
||||
return Key(key).Bytes(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: BytesValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Duration(key string, value time.Duration) Field {
|
||||
return Key(key).Dureation(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: DurationValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Durations(key string, value ...time.Duration) Field {
|
||||
return Key(key).Dureations(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: DurationsValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Durationp(key string, value *time.Duration) Field {
|
||||
return Key(key).Dureationp(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: DurationpValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Time(key string, value time.Time) Field {
|
||||
return Key(key).Time(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: TimeValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Times(key string, value ...time.Time) Field {
|
||||
return Key(key).Times(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: TimesValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Timep(key string, value *time.Time) Field {
|
||||
return Key(key).Timep(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: TimepValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func FormatTime(key, format string, value time.Time) Field {
|
||||
return Key(key).FormatTime(format, value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: ClosureValue(func() any {
|
||||
return value.Format(format)
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
func FormatTimes(key, foramt string, value ...time.Time) Field {
|
||||
return Key(key).FormatTimes(foramt, value...)
|
||||
func FormatTimes(key, format string, value ...time.Time) Field {
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: ClosureValue(func() any {
|
||||
times := make([]any, len(value))
|
||||
for idx, val := range value {
|
||||
times[idx] = val.Format(format)
|
||||
}
|
||||
|
||||
return times
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
func FormatTimep(key, foramt string, value *time.Time) Field {
|
||||
return Key(key).FormatTimep(foramt, value)
|
||||
func FormatTimep(key, format string, value *time.Time) Field {
|
||||
isNill := value == nil
|
||||
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: ClosureValue(func() any {
|
||||
if isNill {
|
||||
return NilValue()
|
||||
}
|
||||
|
||||
return value.Format(format)
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
func Error(key string, value error) Field {
|
||||
return Key(key).Error(value)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: ErrorValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Errors(key string, value ...error) Field {
|
||||
return Key(key).Errors(value...)
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: ErrorsValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func Groups(key string, value ...Field) Field {
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: GroupValue(value...),
|
||||
}
|
||||
}
|
||||
|
||||
func Valuer(key string, value LogValuer) Field {
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: AnyValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func ValuerFn(key string, value ClosureFn) Field {
|
||||
return Field{
|
||||
Key: key,
|
||||
Value: ClosureValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
// Field struct.
|
||||
type Field struct {
|
||||
key Key
|
||||
value Value
|
||||
}
|
||||
|
||||
//nolint:gocyclo,cyclop
|
||||
func (f Field) AddTo(enc Encoder) {
|
||||
key := string(f.key)
|
||||
|
||||
switch {
|
||||
case f.value.IsArray():
|
||||
enc.AddArray(key, f.value)
|
||||
case f.value.IsNil():
|
||||
enc.AddNil(key)
|
||||
case f.value.IsBool():
|
||||
enc.AddBool(key, f.value.asBool())
|
||||
case f.value.IsBinary():
|
||||
enc.AddBinary(key, f.value.asBinary())
|
||||
case f.value.IsInt():
|
||||
enc.AddInt(key, f.value.asInt())
|
||||
case f.value.IsInt8():
|
||||
enc.AddInt8(key, f.value.asInt8())
|
||||
case f.value.IsInt16():
|
||||
enc.AddInt16(key, f.value.asInt16())
|
||||
case f.value.IsInt32():
|
||||
enc.AddInt32(key, f.value.asInt32())
|
||||
case f.value.IsInt64():
|
||||
enc.AddInt64(key, f.value.asInt64())
|
||||
case f.value.IsUint():
|
||||
enc.AddUint(key, f.value.asUint())
|
||||
case f.value.IsUint8():
|
||||
enc.AddUint8(key, f.value.asUint8())
|
||||
case f.value.IsUint16():
|
||||
enc.AddUint16(key, f.value.asUint16())
|
||||
case f.value.IsUint32():
|
||||
enc.AddUint32(key, f.value.asUint32())
|
||||
case f.value.IsUint64():
|
||||
enc.AddUint64(key, f.value.asUint64())
|
||||
case f.value.IsUintptr():
|
||||
enc.AddUintptr(key, f.value.asUintptr())
|
||||
case f.value.IsTime():
|
||||
enc.AddTime(key, f.value.asTime())
|
||||
case f.value.IsDuration():
|
||||
enc.AddDuration(key, f.value.asDuration())
|
||||
case f.value.IsFloat32():
|
||||
enc.AddFloat32(key, f.value.asFloat32())
|
||||
case f.value.IsFloat64():
|
||||
enc.AddFloat64(key, f.value.asFloat64())
|
||||
case f.value.IsComplex64():
|
||||
enc.AddComplex64(key, f.value.asComplex64())
|
||||
case f.value.IsComplex128():
|
||||
enc.AddComplex128(key, f.value.asComplex128())
|
||||
case f.value.IsString():
|
||||
enc.AddString(key, f.value.asString())
|
||||
case f.value.IsError():
|
||||
enc.AddError(key, f.value.asError())
|
||||
default:
|
||||
enc.AddAny(key, f.value)
|
||||
}
|
||||
}
|
||||
|
||||
func (f Field) Type() Type {
|
||||
return f.value.vtype
|
||||
}
|
||||
|
||||
func (f Field) Key() Key {
|
||||
return f.key
|
||||
}
|
||||
|
||||
func (f Field) Value() Value {
|
||||
return f.value
|
||||
}
|
||||
|
||||
func (f Field) AsInterface() interface{} {
|
||||
return f.value.AsInterface()
|
||||
Key string
|
||||
Value Value
|
||||
}
|
||||
|
||||
// String implent stringer.
|
||||
func (f Field) String() string {
|
||||
return fmt.Sprintf("%s=%+v", f.key, f.value.AsInterface())
|
||||
return fmt.Sprintf("%s=%+v", f.Key, f.Value)
|
||||
}
|
||||
|
||||
@@ -2,7 +2,22 @@ package field
|
||||
|
||||
type Fields []Field
|
||||
|
||||
type MapField map[Key]Value
|
||||
func (f Fields) Fields(fn func(Field) bool) {
|
||||
for idx := range f {
|
||||
if !fn(f[idx]) {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (f Fields) Any() any {
|
||||
fields := make(map[string]any)
|
||||
for idx := range f {
|
||||
fields[f[idx].Key] = f[idx].Value.Any()
|
||||
}
|
||||
|
||||
return fields
|
||||
}
|
||||
|
||||
func (f Fields) Append(fields ...Field) Fields {
|
||||
f = append(f, fields...)
|
||||
@@ -17,13 +32,3 @@ func (f Fields) Set(idx int, field Field) {
|
||||
func (f Fields) Len() int {
|
||||
return len(f)
|
||||
}
|
||||
|
||||
func (f Fields) AsMap() MapField {
|
||||
fields := make(MapField, len(f))
|
||||
|
||||
for _, field := range f {
|
||||
fields[field.Key()] = field.Value()
|
||||
}
|
||||
|
||||
return fields
|
||||
}
|
||||
|
||||
570
field/key.go
570
field/key.go
@@ -1,570 +0,0 @@
|
||||
package field
|
||||
|
||||
import (
|
||||
"time"
|
||||
)
|
||||
|
||||
type Key string
|
||||
|
||||
//nolint:funlen,cyclop,gocyclo
|
||||
func (k Key) Any(value interface{}) Field {
|
||||
switch val := value.(type) {
|
||||
case string:
|
||||
return k.String(val)
|
||||
case *string:
|
||||
return k.Stringp(val)
|
||||
case []string:
|
||||
return k.Strings(val...)
|
||||
case bool:
|
||||
return k.Bool(val)
|
||||
case *bool:
|
||||
return k.Boolp(val)
|
||||
case []bool:
|
||||
return k.Bools(val...)
|
||||
case int8:
|
||||
return k.Int8(val)
|
||||
case []int8:
|
||||
return k.Int8s(val...)
|
||||
case *int8:
|
||||
return k.Int8p(val)
|
||||
case int16:
|
||||
return k.Int16(val)
|
||||
case []int16:
|
||||
return k.Int16s(val...)
|
||||
case *int16:
|
||||
return k.Int16p(val)
|
||||
case int32:
|
||||
return k.Int32(val)
|
||||
case []int32:
|
||||
return k.Int32s(val...)
|
||||
case *int32:
|
||||
return k.Int32p(val)
|
||||
case int64:
|
||||
return k.Int64(val)
|
||||
case []int64:
|
||||
return k.Int64s(val...)
|
||||
case *int64:
|
||||
return k.Int64p(val)
|
||||
case uint:
|
||||
return k.Uint(val)
|
||||
case []uint:
|
||||
return k.Uints(val...)
|
||||
case *uint:
|
||||
return k.Uintp(val)
|
||||
case uint8:
|
||||
return k.Uint8(val)
|
||||
case *uint8:
|
||||
return k.Uint8p(val)
|
||||
case uint16:
|
||||
return k.Uint16(val)
|
||||
case []uint16:
|
||||
return k.Uint16s(val...)
|
||||
case *uint16:
|
||||
return k.Uint16p(val)
|
||||
case uint32:
|
||||
return k.Uint32(val)
|
||||
case []uint32:
|
||||
return k.Uint32s(val...)
|
||||
case *uint32:
|
||||
return k.Uint32p(val)
|
||||
case uint64:
|
||||
return k.Uint64(val)
|
||||
case []uint64:
|
||||
return k.Uint64s(val...)
|
||||
case *uint64:
|
||||
return k.Uint64p(val)
|
||||
case float32:
|
||||
return k.Float32(val)
|
||||
case []float32:
|
||||
return k.Float32s(val...)
|
||||
case *float32:
|
||||
return k.Float32p(val)
|
||||
case float64:
|
||||
return k.Float64(val)
|
||||
case []float64:
|
||||
return k.Float64s(val...)
|
||||
case *float64:
|
||||
return k.Float64p(val)
|
||||
case complex64:
|
||||
return k.Complex64(val)
|
||||
case []complex64:
|
||||
return k.Complex64s(val...)
|
||||
case *complex64:
|
||||
return k.Complex64p(val)
|
||||
case uintptr:
|
||||
return k.Uintptr(val)
|
||||
case []uintptr:
|
||||
return k.Uintptrs(val...)
|
||||
case *uintptr:
|
||||
return k.Uintptrp(val)
|
||||
case []byte:
|
||||
return k.Bytes(val)
|
||||
case time.Duration:
|
||||
return k.Dureation(val)
|
||||
case []time.Duration:
|
||||
return k.Dureations(val)
|
||||
case *time.Duration:
|
||||
return k.Dureationp(val)
|
||||
case time.Time:
|
||||
return k.Time(val)
|
||||
case []time.Time:
|
||||
return k.Times(val...)
|
||||
case *time.Time:
|
||||
return k.Timep(val)
|
||||
case error:
|
||||
return k.Error(val)
|
||||
case []error:
|
||||
return k.Errors(val...)
|
||||
}
|
||||
|
||||
return Field{
|
||||
key: k,
|
||||
value: Value{
|
||||
value: value,
|
||||
vtype: TypeAny,
|
||||
numeric: 0,
|
||||
stringly: "",
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) String(value string) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: stringValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Strings(value ...string) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: stringsValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Stringp(value *string) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: stringpValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Bool(value bool) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: boolValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Bools(value ...bool) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: boolsValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Boolp(value *bool) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: boolpValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Int(value int) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: intValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Ints(value ...int) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: intsValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Intp(value *int) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: intpValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Int8(value int8) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: int8Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Int8s(value ...int8) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: int8sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Int8p(value *int8) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: int8pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Int16(value int16) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: int16Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Int16s(value ...int16) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: int16sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Int16p(value *int16) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: int16pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Int32(value int32) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: int32Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Int32s(value ...int32) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: int32sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Int32p(value *int32) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: int32pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Int64(value int64) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: int64Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Int64s(value ...int64) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: int64sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Int64p(value *int64) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: int64pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uint(value uint) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uintValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uints(value ...uint) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uintsValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uintp(value *uint) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uintpValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uint8(value uint8) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uint8Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uint8s(value ...uint8) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uint8sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uint8p(value *uint8) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uint8pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uint16(value uint16) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uint16Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uint16s(value ...uint16) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uint16sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uint16p(value *uint16) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uint16pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uint32(value uint32) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uint32Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uint32s(value ...uint32) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uint32sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uint32p(value *uint32) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uint32pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uint64(value uint64) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uint64Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uint64s(value ...uint64) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uint64sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uint64p(value *uint64) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uint64pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Float32(value float32) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: float32Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Float32s(value ...float32) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: float32sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Float32p(value *float32) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: float32pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Float64(value float64) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: float64Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Float64s(value ...float64) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: float64sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Float64p(value *float64) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: float64pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Complex64(value complex64) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: complex64Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Complex64s(value ...complex64) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: complex64sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Complex64p(value *complex64) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: complex64pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Complex128(value complex128) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: complex128Value(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Complex128s(value []complex128) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: complex128sValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Complex128p(value *complex128) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: complex128pValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uintptr(value uintptr) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uintptrValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uintptrs(value ...uintptr) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uintptrsValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Uintptrp(value *uintptr) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: uintptrpValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Bytes(value []byte) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: bytesValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Dureation(value time.Duration) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: durationValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Dureations(value []time.Duration) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: durationsValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Dureationp(value *time.Duration) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: durationpValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Time(value time.Time) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: timeValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Times(value ...time.Time) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: timesValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Timep(value *time.Time) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: timepValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) FormatTime(format string, value time.Time) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: formatTimeValue(format, value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) FormatTimes(format string, value ...time.Time) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: formatTimesValue(format, value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) FormatTimep(format string, value *time.Time) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: formatTimepValue(format, value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Error(value error) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: errorValue(value),
|
||||
}
|
||||
}
|
||||
|
||||
func (k Key) Errors(value ...error) Field {
|
||||
return Field{
|
||||
key: k,
|
||||
value: errorsValue(value),
|
||||
}
|
||||
}
|
||||
24
field/kind.go
Normal file
24
field/kind.go
Normal file
@@ -0,0 +1,24 @@
|
||||
package field
|
||||
|
||||
//go:generate stringer -type=Kind -linecomment -output=kind_string.go
|
||||
|
||||
type Kind int
|
||||
|
||||
const (
|
||||
KindAny Kind = iota // any
|
||||
KindArray // array
|
||||
KindNil // nil
|
||||
KindString // string
|
||||
KindBool // bool
|
||||
KindInt64 // int64
|
||||
KindUint64 // uint64
|
||||
KindFloat32 // float32
|
||||
KindFloat64 // float64
|
||||
KindComplex128 // complex128
|
||||
KindBinary // bytes
|
||||
KindDuration // duration
|
||||
KindTime // time
|
||||
KindError // error
|
||||
KindGroup // group
|
||||
KindClosure // closure
|
||||
)
|
||||
38
field/kind_string.go
Normal file
38
field/kind_string.go
Normal file
@@ -0,0 +1,38 @@
|
||||
// Code generated by "stringer -type=Kind -linecomment -output=kind_string.go"; DO NOT EDIT.
|
||||
|
||||
package field
|
||||
|
||||
import "strconv"
|
||||
|
||||
func _() {
|
||||
// An "invalid array index" compiler error signifies that the constant values have changed.
|
||||
// Re-run the stringer command to generate them again.
|
||||
var x [1]struct{}
|
||||
_ = x[KindAny-0]
|
||||
_ = x[KindArray-1]
|
||||
_ = x[KindNil-2]
|
||||
_ = x[KindString-3]
|
||||
_ = x[KindBool-4]
|
||||
_ = x[KindInt64-5]
|
||||
_ = x[KindUint64-6]
|
||||
_ = x[KindFloat32-7]
|
||||
_ = x[KindFloat64-8]
|
||||
_ = x[KindComplex128-9]
|
||||
_ = x[KindBinary-10]
|
||||
_ = x[KindDuration-11]
|
||||
_ = x[KindTime-12]
|
||||
_ = x[KindError-13]
|
||||
_ = x[KindGroup-14]
|
||||
_ = x[KindClosure-15]
|
||||
}
|
||||
|
||||
const _Kind_name = "anyarraynilstringboolint64uint64float32float64complex128bytesdurationtimeerrorgroupclosure"
|
||||
|
||||
var _Kind_index = [...]uint8{0, 3, 8, 11, 17, 21, 26, 32, 39, 46, 56, 61, 69, 73, 78, 83, 90}
|
||||
|
||||
func (i Kind) String() string {
|
||||
if i < 0 || i >= Kind(len(_Kind_index)-1) {
|
||||
return "Kind(" + strconv.FormatInt(int64(i), 10) + ")"
|
||||
}
|
||||
return _Kind_name[_Kind_index[i]:_Kind_index[i+1]]
|
||||
}
|
||||
11
field/log_valuer.go
Normal file
11
field/log_valuer.go
Normal file
@@ -0,0 +1,11 @@
|
||||
package field
|
||||
|
||||
type LogValuer interface {
|
||||
LogValue() any
|
||||
}
|
||||
|
||||
type ClosureFn func() any
|
||||
|
||||
func (v ClosureFn) LogValue() any {
|
||||
return v()
|
||||
}
|
||||
112
field/safe_set.go
Normal file
112
field/safe_set.go
Normal file
@@ -0,0 +1,112 @@
|
||||
package field
|
||||
|
||||
import "unicode/utf8"
|
||||
|
||||
// Copied from encoding/json/tables.go.
|
||||
//
|
||||
// safeSet holds the value true if the ASCII character with the given array
|
||||
// position can be represented inside a JSON string without any further
|
||||
// escaping.
|
||||
//
|
||||
// All values are true except for the ASCII control characters (0-31), the
|
||||
// double quote ("), and the backslash character ("\").
|
||||
//
|
||||
//nolint:gochecknoglobals
|
||||
var safeSet = [utf8.RuneSelf]bool{
|
||||
' ': true,
|
||||
'!': true,
|
||||
'"': false,
|
||||
'#': true,
|
||||
'$': true,
|
||||
'%': true,
|
||||
'&': true,
|
||||
'\'': true,
|
||||
'(': true,
|
||||
')': true,
|
||||
'*': true,
|
||||
'+': true,
|
||||
',': true,
|
||||
'-': true,
|
||||
'.': true,
|
||||
'/': true,
|
||||
'0': true,
|
||||
'1': true,
|
||||
'2': true,
|
||||
'3': true,
|
||||
'4': true,
|
||||
'5': true,
|
||||
'6': true,
|
||||
'7': true,
|
||||
'8': true,
|
||||
'9': true,
|
||||
':': true,
|
||||
';': true,
|
||||
'<': true,
|
||||
'=': true,
|
||||
'>': true,
|
||||
'?': true,
|
||||
'@': true,
|
||||
'A': true,
|
||||
'B': true,
|
||||
'C': true,
|
||||
'D': true,
|
||||
'E': true,
|
||||
'F': true,
|
||||
'G': true,
|
||||
'H': true,
|
||||
'I': true,
|
||||
'J': true,
|
||||
'K': true,
|
||||
'L': true,
|
||||
'M': true,
|
||||
'N': true,
|
||||
'O': true,
|
||||
'P': true,
|
||||
'Q': true,
|
||||
'R': true,
|
||||
'S': true,
|
||||
'T': true,
|
||||
'U': true,
|
||||
'V': true,
|
||||
'W': true,
|
||||
'X': true,
|
||||
'Y': true,
|
||||
'Z': true,
|
||||
'[': true,
|
||||
'\\': false,
|
||||
']': true,
|
||||
'^': true,
|
||||
'_': true,
|
||||
'`': true,
|
||||
'a': true,
|
||||
'b': true,
|
||||
'c': true,
|
||||
'd': true,
|
||||
'e': true,
|
||||
'f': true,
|
||||
'g': true,
|
||||
'h': true,
|
||||
'i': true,
|
||||
'j': true,
|
||||
'k': true,
|
||||
'l': true,
|
||||
'm': true,
|
||||
'n': true,
|
||||
'o': true,
|
||||
'p': true,
|
||||
'q': true,
|
||||
'r': true,
|
||||
's': true,
|
||||
't': true,
|
||||
'u': true,
|
||||
'v': true,
|
||||
'w': true,
|
||||
'x': true,
|
||||
'y': true,
|
||||
'z': true,
|
||||
'{': true,
|
||||
'|': true,
|
||||
'}': true,
|
||||
'~': true,
|
||||
'\u007f': true,
|
||||
}
|
||||
126
field/type.go
126
field/type.go
@@ -1,126 +0,0 @@
|
||||
package field
|
||||
|
||||
type Type uint32
|
||||
|
||||
const (
|
||||
TypeAny Type = 1 << iota // any
|
||||
TypeArray // array
|
||||
TypeNil // nil
|
||||
TypeString // string
|
||||
TypeBool // bool
|
||||
TypeInt // int
|
||||
TypeInt8 // int8
|
||||
TypeInt16 // int16
|
||||
TypeInt32 // int32
|
||||
TypeInt64 // int64
|
||||
TypeUint // uint
|
||||
TypeUint8 // uint8
|
||||
TypeUint16 // uint16
|
||||
TypeUint32 // uint32
|
||||
TypeUint64 // uint64
|
||||
TypeFloat32 // float32
|
||||
TypeFloat64 // float64
|
||||
TypeComplex64 // complex64
|
||||
TypeComplex128 // complex128
|
||||
TypeUintptr // uintptr
|
||||
TypeBinary // bytes
|
||||
TypeDuration // duration
|
||||
TypeTime // time
|
||||
TypeError // error
|
||||
)
|
||||
|
||||
func (t Type) IsAny() bool {
|
||||
return t&TypeAny > 0
|
||||
}
|
||||
|
||||
func (t Type) IsArray() bool {
|
||||
return t&TypeArray > 0
|
||||
}
|
||||
|
||||
func (t Type) IsNil() bool {
|
||||
return t&TypeNil > 0
|
||||
}
|
||||
|
||||
func (t Type) IsBool() bool {
|
||||
return t&TypeBool > 0
|
||||
}
|
||||
|
||||
func (t Type) IsString() bool {
|
||||
return t&TypeString > 0
|
||||
}
|
||||
|
||||
func (t Type) IsInt() bool {
|
||||
return t&TypeInt > 0
|
||||
}
|
||||
|
||||
func (t Type) IsInt8() bool {
|
||||
return t&TypeInt8 > 0
|
||||
}
|
||||
|
||||
func (t Type) IsInt16() bool {
|
||||
return t&TypeInt16 > 0
|
||||
}
|
||||
|
||||
func (t Type) IsInt32() bool {
|
||||
return t&TypeInt32 > 0
|
||||
}
|
||||
|
||||
func (t Type) IsInt64() bool {
|
||||
return t&TypeInt64 > 0
|
||||
}
|
||||
|
||||
func (t Type) IsUint() bool {
|
||||
return t&TypeUint > 0
|
||||
}
|
||||
|
||||
func (t Type) IsUint8() bool {
|
||||
return t&TypeUint8 > 0
|
||||
}
|
||||
|
||||
func (t Type) IsUint16() bool {
|
||||
return t&TypeUint16 > 0
|
||||
}
|
||||
|
||||
func (t Type) IsUint32() bool {
|
||||
return t&TypeUint32 > 0
|
||||
}
|
||||
|
||||
func (t Type) IsUint64() bool {
|
||||
return t&TypeUint64 > 0
|
||||
}
|
||||
|
||||
func (t Type) IsFloat32() bool {
|
||||
return t&TypeFloat32 > 0
|
||||
}
|
||||
|
||||
func (t Type) IsFloat64() bool {
|
||||
return t&TypeFloat64 > 0
|
||||
}
|
||||
|
||||
func (t Type) IsComplex64() bool {
|
||||
return t&TypeComplex64 > 0
|
||||
}
|
||||
|
||||
func (t Type) IsComplex128() bool {
|
||||
return t&TypeComplex128 > 0
|
||||
}
|
||||
|
||||
func (t Type) IsUintptr() bool {
|
||||
return t&TypeUintptr > 0
|
||||
}
|
||||
|
||||
func (t Type) IsBinary() bool {
|
||||
return t&TypeBinary > 0
|
||||
}
|
||||
|
||||
func (t Type) IsDuration() bool {
|
||||
return t&TypeDuration > 0
|
||||
}
|
||||
|
||||
func (t Type) IsTime() bool {
|
||||
return t&TypeTime > 0
|
||||
}
|
||||
|
||||
func (t Type) IsError() bool {
|
||||
return t&TypeError > 0
|
||||
}
|
||||
1297
field/value.go
1297
field/value.go
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user