fix(log): fix error handling in field encoder

Author: lvan100

log/field.go

@@ -22,18 +22,18 @@ import (
 
 const MsgKey = "msg"
 
-// Field represents a log entry field with a key and a corresponding value.
+// Field represents a structured log field with a key and a value.
 type Field struct {
-	Key string // The name of the log field.
-	Val Value  // The value of the log field.
+	Key string // The name of the field.
+	Val Value  // The value of the field.
 }
 
-// Msg creates a Field with the key "msg" and a string message value.
+// Msg creates a string Field with the "msg" key.
 func Msg(msg string) Field {
 	return String(MsgKey, msg)
 }
 
-// Msgf formats the message using fmt.Sprintf and returns a Field with key "msg".
+// Msgf formats a message using fmt.Sprintf and creates a string Field with "msg" key.
 func Msgf(format string, args ...any) Field {
 	return String(MsgKey, fmt.Sprintf(format, args...))
 }
@@ -43,186 +43,186 @@ func Reflect(key string, val interface{}) Field {
 	return Field{Key: key, Val: ReflectValue{Val: val}}
 }
 
-// Nil creates a Field for a given key with a nil value.
+// Nil creates a Field with a nil value.
 func Nil(key string) Field {
 	return Reflect(key, nil)
 }
 
-// Bool creates a boolean Field.
+// Bool creates a Field for a boolean value.
 func Bool(key string, val bool) Field {
 	return Field{Key: key, Val: BoolValue(val)}
 }
 
-// BoolPtr creates a boolean Field from a pointer; returns Nil if pointer is nil.
+// BoolPtr creates a Field from a *bool, or a nil Field if the pointer is nil.
 func BoolPtr(key string, val *bool) Field {
 	if val == nil {
 		return Nil(key)
 	}
 	return Bool(key, *val)
 }
 
-// Int creates an integer Field.
+// Int creates a Field for an int value.
 func Int(key string, val int) Field {
 	return Field{Key: key, Val: Int64Value(val)}
 }
 
-// IntPtr creates an integer Field from a pointer; returns Nil if pointer is nil.
+// IntPtr creates a Field from a *int, or returns Nil if pointer is nil.
 func IntPtr(key string, val *int) Field {
 	if val == nil {
 		return Nil(key)
 	}
 	return Int(key, *val)
 }
 
-// Int8 creates an int8 Field.
+// Int8 creates a Field for an int8 value.
 func Int8(key string, val int8) Field {
 	return Field{Key: key, Val: Int64Value(val)}
 }
 
-// Int8Ptr creates an int8 Field from a pointer; returns Nil if pointer is nil.
+// Int8Ptr creates a Field from a *int8, or returns Nil if pointer is nil.
 func Int8Ptr(key string, val *int8) Field {
 	if val == nil {
 		return Nil(key)
 	}
 	return Int8(key, *val)
 }
 
-// Int16 creates an int16 Field.
+// Int16 creates a Field for an int16 value.
 func Int16(key string, val int16) Field {
 	return Field{Key: key, Val: Int64Value(val)}
 }
 
-// Int16Ptr creates an int16 Field from a pointer; returns Nil if pointer is nil.
+// Int16Ptr creates a Field from a *int16, or returns Nil if pointer is nil.
 func Int16Ptr(key string, val *int16) Field {
 	if val == nil {
 		return Nil(key)
 	}
 	return Int16(key, *val)
 }
 
-// Int32 creates an int32 Field.
+// Int32 creates a Field for an int32 value.
 func Int32(key string, val int32) Field {
 	return Field{Key: key, Val: Int64Value(val)}
 }
 
-// Int32Ptr creates an int32 Field from a pointer; returns Nil if pointer is nil.
+// Int32Ptr creates a Field from a *int32, or returns Nil if pointer is nil.
 func Int32Ptr(key string, val *int32) Field {
 	if val == nil {
 		return Nil(key)
 	}
 	return Int32(key, *val)
 }
 
-// Int64 creates an int64 Field.
+// Int64 creates a Field for an int64 value.
 func Int64(key string, val int64) Field {
 	return Field{Key: key, Val: Int64Value(val)}
 }
 
-// Int64Ptr creates an int64 Field from a pointer; returns Nil if pointer is nil.
+// Int64Ptr creates a Field from a *int64, or returns Nil if pointer is nil.
 func Int64Ptr(key string, val *int64) Field {
 	if val == nil {
 		return Nil(key)
 	}
 	return Int64(key, *val)
 }
 
-// Uint creates a uint Field.
+// Uint creates a Field for an uint value.
 func Uint(key string, val uint) Field {
 	return Field{Key: key, Val: Uint64Value(val)}
 }
 
-// UintPtr creates an uint Field from a pointer; returns Nil if pointer is nil.
+// UintPtr creates a Field from a *uint, or returns Nil if pointer is nil.
 func UintPtr(key string, val *uint) Field {
 	if val == nil {
 		return Nil(key)
 	}
 	return Uint(key, *val)
 }
 
-// Uint8 creates a uint8 Field.
+// Uint8 creates a Field for an uint8 value.
 func Uint8(key string, val uint8) Field {
 	return Field{Key: key, Val: Uint64Value(val)}
 }
 
-// Uint8Ptr creates an uint8 Field from a pointer; returns Nil if pointer is nil.
+// Uint8Ptr creates a Field from a *uint8, or returns Nil if pointer is nil.
 func Uint8Ptr(key string, val *uint8) Field {
 	if val == nil {
 		return Nil(key)
 	}
 	return Uint8(key, *val)
 }
 
-// Uint16 creates a uint16 Field.
+// Uint16 creates a Field for an uint16 value.
 func Uint16(key string, val uint16) Field {
 	return Field{Key: key, Val: Uint64Value(val)}
 }
 
-// Uint16Ptr creates an uint16 Field from a pointer; returns Nil if pointer is nil.
+// Uint16Ptr creates a Field from a *uint16, or returns Nil if pointer is nil.
 func Uint16Ptr(key string, val *uint16) Field {
 	if val == nil {
 		return Nil(key)
 	}
 	return Uint16(key, *val)
 }
 
-// Uint32 creates a uint32 Field.
+// Uint32 creates a Field for an uint32 value.
 func Uint32(key string, val uint32) Field {
 	return Field{Key: key, Val: Uint64Value(val)}
 }
 
-// Uint32Ptr creates an uint32 Field from a pointer; returns Nil if pointer is nil.
+// Uint32Ptr creates a Field from a *uint32, or returns Nil if pointer is nil.
 func Uint32Ptr(key string, val *uint32) Field {
 	if val == nil {
 		return Nil(key)
 	}
 	return Uint32(key, *val)
 }
 
-// Uint64 creates a uint64 Field.
+// Uint64 creates a Field for an uint64 value.
 func Uint64(key string, val uint64) Field {
 	return Field{Key: key, Val: Uint64Value(val)}
 }
 
-// Uint64Ptr creates an uint64 Field from a pointer; returns Nil if pointer is nil.
+// Uint64Ptr creates a Field from a *uint64, or returns Nil if pointer is nil.
 func Uint64Ptr(key string, val *uint64) Field {
 	if val == nil {
 		return Nil(key)
 	}
 	return Uint64(key, *val)
 }
 
-// Float32 creates a float32 Field.
+// Float32 creates a Field for a float32 value.
 func Float32(key string, val float32) Field {
 	return Field{Key: key, Val: Float64Value(val)}
 }
 
-// Float32Ptr creates a float32 Field from a pointer; returns Nil if pointer is nil.
+// Float32Ptr creates a Field from a *float32, or returns Nil if pointer is nil.
 func Float32Ptr(key string, val *float32) Field {
 	if val == nil {
 		return Nil(key)
 	}
 	return Float32(key, *val)
 }
 
-// Float64 creates a float64 Field.
+// Float64 creates a Field for a float64 value.
 func Float64(key string, val float64) Field {
 	return Field{Key: key, Val: Float64Value(val)}
 }
 
-// Float64Ptr creates a float64 Field from a pointer; returns Nil if pointer is nil.
+// Float64Ptr creates a Field from a *float64, or returns Nil if pointer is nil.
 func Float64Ptr(key string, val *float64) Field {
 	if val == nil {
 		return Nil(key)
 	}
 	return Float64(key, *val)
 }
 
-// String creates a string Field.
+// String creates a Field for a string value.
 func String(key string, val string) Field {
 	return Field{Key: key, Val: StringValue(val)}
 }
 
-// StringPtr creates a string Field from a pointer; returns Nil if pointer is nil.
+// StringPtr creates a Field from a *string, or returns Nil if pointer is nil.
 func StringPtr(key string, val *string) Field {
 	if val == nil {
 		return Nil(key)
@@ -240,72 +240,72 @@ func Object(key string, fields ...Field) Field {
 	return Field{Key: key, Val: ObjectValue(fields)}
 }
 
-// Bools creates a Field containing a slice of boolean values.
+// Bools creates a Field with a slice of booleans.
 func Bools(key string, val []bool) Field {
 	return Field{Key: key, Val: BoolsValue(val)}
 }
 
-// Ints creates a Field containing a slice of int values.
+// Ints creates a Field with a slice of integers.
 func Ints(key string, val []int) Field {
 	return Field{Key: key, Val: IntsValue(val)}
 }
 
-// Int8s creates a Field containing a slice of int8 values.
+// Int8s creates a Field with a slice of int8 values.
 func Int8s(key string, val []int8) Field {
 	return Field{Key: key, Val: Int8sValue(val)}
 }
 
-// Int16s creates a Field containing a slice of int16 values.
+// Int16s creates a Field with a slice of int16 values.
 func Int16s(key string, val []int16) Field {
 	return Field{Key: key, Val: Int16sValue(val)}
 }
 
-// Int32s creates a Field containing a slice of int32 values.
+// Int32s creates a Field with a slice of int32 values.
 func Int32s(key string, val []int32) Field {
 	return Field{Key: key, Val: Int32sValue(val)}
 }
 
-// Int64s creates a Field containing a slice of int64 values.
+// Int64s creates a Field with a slice of int64 values.
 func Int64s(key string, val []int64) Field {
 	return Field{Key: key, Val: Int64sValue(val)}
 }
 
-// Uints creates a Field containing a slice of uint values.
+// Uints creates a Field with a slice of unsigned integers.
 func Uints(key string, val []uint) Field {
 	return Field{Key: key, Val: UintsValue(val)}
 }
 
-// Uint8s creates a Field containing a slice of uint8 values.
+// Uint8s creates a Field with a slice of uint8 values.
 func Uint8s(key string, val []uint8) Field {
 	return Field{Key: key, Val: Uint8sValue(val)}
 }
 
-// Uint16s creates a Field containing a slice of uint16 values.
+// Uint16s creates a Field with a slice of uint16 values.
 func Uint16s(key string, val []uint16) Field {
 	return Field{Key: key, Val: Uint16sValue(val)}
 }
 
-// Uint32s creates a Field containing a slice of uint32 values.
+// Uint32s creates a Field with a slice of uint32 values.
 func Uint32s(key string, val []uint32) Field {
 	return Field{Key: key, Val: Uint32sValue(val)}
 }
 
-// Uint64s creates a Field containing a slice of uint64 values.
+// Uint64s creates a Field with a slice of uint64 values.
 func Uint64s(key string, val []uint64) Field {
 	return Field{Key: key, Val: Uint64sValue(val)}
 }
 
-// Float32s creates a Field containing a slice of float32 values.
+// Float32s creates a Field with a slice of float32 values.
 func Float32s(key string, val []float32) Field {
 	return Field{Key: key, Val: Float32sValue(val)}
 }
 
-// Float64s creates a Field containing a slice of float64 values.
+// Float64s creates a Field with a slice of float64 values.
 func Float64s(key string, val []float64) Field {
 	return Field{Key: key, Val: Float64sValue(val)}
 }
 
-// Strings creates a Field containing a slice of string values.
+// Strings creates a Field with a slice of strings.
 func Strings(key string, val []string) Field {
 	return Field{Key: key, Val: StringsValue(val)}
 }