suyono/wingmate
1
0
Fork 0
Code Issues 2 Pull Requests Packages Projects 1 Releases 2 Wiki Activity

wip: log

Browse Source
This commit is contained in:
Suyono 2023-09-11 12:28:53 +10:00
parent 277e8feba1
commit d406fe698f
2 changed files with 98 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
log/file.go
View File

@ -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)
}

146
log/log.go
View File

@ -3,10 +3,11 @@ package log
import (
"errors"
"fmt"
"github.com/rs/zerolog"
"io"
"os"
"reflect"
"github.com/rs/zerolog"
)
type Level zerolog.Level
@ -45,14 +46,14 @@ const (
)
var (
globalLevel Level = Error
logger zerolog.Logger
onLogWriterError zerolog.Logger
writer *Writer
DefaultOutlet io.Writer
errType reflect.Type
invalidTypeError error = errors.New("invalid type")
noValidFieldError error = errors.New("no valid field")
globalLevel Level = Error
logger zerolog.Logger
onLogWriterError zerolog.Logger
writer *Writer
DefaultOutlet io.Writer
errType reflect.Type
errInvalidType error = errors.New("invalid type")
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,22 +174,17 @@ func (p *Payload) Send(ws ...io.Writer) {
}
func (p *Payload) unhandledField(key string, v any) *zerolog.Event {
var (
event *zerolog.Event
)
event = (*zerolog.Event)(p)
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
err error
vlen int
i int
rval *zerolog.Array
event *zerolog.Event
err error
)
vlen = val.Len()
@ -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.Str(val.String())
rval = rval.Str(val.String())
case reflect.Struct:
event, err = p.structType(val)
if err == nil {
rval.Dict(event)
outlen++
if event, err = p.structType(val); 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.Str(fmt.Sprintf("[unhandled data type / invalid] %+v", val.Interface()))
rval = rval.Str(fmt.Sprintf("[unhandled data type / invalid] %+v", val.Interface()))
}
}
return nil, nil //TODO: placeholder, FIX ME!
return rval, nil
}
func (p *Payload) pointer(val reflect.Value) (*Payload, error) {
// 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, invalidTypeError
return nil, errInvalidType
}
event, err := p.structType(val)
if err != nil {
return nil, err
}
return payload(event), nil
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