wip: log

log/file.go

@@ -37,8 +37,7 @@ func NewLogFile(configKey string) (*File, error) {
 }
 
 func (f *File) Write(b []byte) (int, error) {
-	var file *os.File
+	file := (*os.File)(f)
-	file = (*os.File)(f)
 	return file.Write(b)
 }
 

log/log.go

@@ -3,10 +3,11 @@ package log
 import (
 	"errors"
 	"fmt"
-	"github.com/rs/zerolog"
 	"io"
 	"os"
 	"reflect"
+
+	"github.com/rs/zerolog"
 )
 
 type Level zerolog.Level
@@ -51,8 +52,8 @@ var (
 	writer           *Writer
 	DefaultOutlet    io.Writer
 	errType          reflect.Type
-	invalidTypeError  error = errors.New("invalid type")
+	errInvalidType   error = errors.New("invalid type")
-	noValidFieldError error = errors.New("no valid field")
+	errNoValidField  error = errors.New("no valid field")
 )
 
 func init() {
@@ -84,9 +85,12 @@ func (p *Payload) HandleFields(a ...any) FieldsHandler {
 func (p *Payload) Fields(a ...any) *Payload {
 	var (
 		event *zerolog.Event
+		sub   *zerolog.Event
 		key   string
 		val   reflect.Value
 		typ   reflect.Type
+		arr   *zerolog.Array
+		err   error
 	)
 
 	event = (*zerolog.Event)(p)
@@ -99,9 +103,50 @@ func (p *Payload) Fields(a ...any) *Payload {
 			switch typ.Kind() {
 			case reflect.String:
 				event = event.Str(key, val.String())
-			case reflect.Slice:
+			case reflect.Slice, reflect.Array:
+				if arr, err = p.slice(val); err != nil {
+					event = payload(event).unhandledField(key, part)
+				} else {
+					event = event.Array(key, arr)
+				}
+			case reflect.Bool:
+				event = event.Bool(key, val.Bool())
+			case reflect.Struct:
+				if sub, err = p.structType(val); err != nil {
+					event = payload(event).unhandledField(key, part)
+				} else {
+					event = event.Dict(key, sub)
+				}
 			case reflect.Pointer:
-
+				if sub, err = p.pointer(val); err != nil {
+					event = payload(event).unhandledField(key, part)
+				} else {
+					event = event.Dict(key, sub)
+				}
+			case reflect.Int:
+				event = event.Int(key, int(val.Int()))
+			case reflect.Int8:
+				event = event.Int8(key, int8(val.Int()))
+			case reflect.Int16:
+				event = event.Int16(key, int16(val.Int()))
+			case reflect.Int32:
+				event = event.Int32(key, int32(val.Int()))
+			case reflect.Int64:
+				event = event.Int64(key, val.Int())
+			case reflect.Float32:
+				event = event.Float32(key, float32(val.Float()))
+			case reflect.Float64:
+				event = event.Float64(key, val.Float())
+			case reflect.Uint:
+				event = event.Uint(key, uint(val.Uint()))
+			case reflect.Uint8:
+				event = event.Uint8(key, uint8(val.Uint()))
+			case reflect.Uint16:
+				event = event.Uint16(key, uint16(val.Uint()))
+			case reflect.Uint32:
+				event = event.Uint32(key, uint32(val.Uint()))
+			case reflect.Uint64:
+				event = event.Uint64(key, val.Uint())
 			default:
 				if typ.Implements(errType) {
 
@@ -109,16 +154,6 @@ func (p *Payload) Fields(a ...any) *Payload {
 					event = payload(event).unhandledField(key, part)
 				}
 			}
-
-			//switch v := part.(type) {
-			//case string:
-			//	event = event.Str(key, v)
-			//case error:
-			//	event = event.Err(v)
-			//
-			//default:
-			//	event = event.Str(key, fmt.Sprintf("[no data type handle] %v", v))
-			//}
 		}
 	}
 	return (*Payload)(event)
@@ -139,18 +174,13 @@ func (p *Payload) Send(ws ...io.Writer) {
 }
 
 func (p *Payload) unhandledField(key string, v any) *zerolog.Event {
-	var (
+	event := (*zerolog.Event)(p)
-		event *zerolog.Event
-	)
-
-	event = (*zerolog.Event)(p)
 	return event.Str(key, fmt.Sprintf("[unhandled data type / invalid] %+v", v))
 }
 
 func (p *Payload) slice(val reflect.Value) (*zerolog.Array, error) {
 	var (
 		vlen  int
-		outlen int
 		i     int
 		rval  *zerolog.Array
 		event *zerolog.Event
@@ -163,33 +193,51 @@ func (p *Payload) slice(val reflect.Value) (*zerolog.Array, error) {
 		switch val.Index(i).Kind() {
 		//TODO: handle more cases
 		case reflect.String:
-			outlen++
+			rval = rval.Str(val.String())
-			rval.Str(val.String())
 		case reflect.Struct:
-			event, err = p.structType(val)
+			if event, err = p.structType(val); err != nil {
-			if err == nil {
-				rval.Dict(event)
-				outlen++
-			}
-		default:
-			rval.Str(fmt.Sprintf("[unhandled data type / invalid] %+v", val.Interface()))
-		}
-	}
-	return nil, nil //TODO: placeholder, FIX ME!
-}
-
-func (p *Payload) pointer(val reflect.Value) (*Payload, error) {
-	val = val.Elem()
-	if val.Kind() != reflect.Struct {
-		return nil, invalidTypeError
-	}
-
-	event, err := p.structType(val)
-	if err != nil {
 				return nil, err
 			}
+			rval = rval.Dict(event)
+		case reflect.Int:
+			rval = rval.Int(int(val.Int()))
+		case reflect.Int8:
+			rval = rval.Int8(int8(val.Int()))
+		case reflect.Int16:
+			rval = rval.Int16(int16(val.Int()))
+		case reflect.Int32:
+			rval = rval.Int32(int32(val.Int()))
+		case reflect.Int64:
+			rval = rval.Int64(val.Int())
+		case reflect.Float32:
+			rval = rval.Float32(float32(val.Float()))
+		case reflect.Float64:
+			rval = rval.Float64(val.Float())
+		case reflect.Uint:
+			rval = rval.Uint(uint(val.Uint()))
+		case reflect.Uint8:
+			rval = rval.Uint8(uint8(val.Uint()))
+		case reflect.Uint16:
+			rval = rval.Uint16(uint16(val.Uint()))
+		case reflect.Uint32:
+			rval = rval.Uint32(uint32(val.Uint()))
+		case reflect.Uint64:
+			rval = rval.Uint64(val.Uint())
+		default:
+			rval = rval.Str(fmt.Sprintf("[unhandled data type / invalid] %+v", val.Interface()))
+		}
+	}
+	return rval, nil
+}
 
-	return payload(event), nil
+// pointer only supports pointer to a struct
+func (p *Payload) pointer(val reflect.Value) (*zerolog.Event, error) {
+	val = val.Elem()
+	if val.Kind() != reflect.Struct {
+		return nil, errInvalidType
+	}
+
+	return p.structType(val)
 }
 
 func (p *Payload) structType(val reflect.Value) (*zerolog.Event, error) {
@@ -209,7 +257,7 @@ func (p *Payload) structType(val reflect.Value) (*zerolog.Event, error) {
 	}
 
 	if event == nil {
-		return nil, noValidFieldError
+		return nil, errNoValidField
 	}
 
 	return event, nil