Fix: log context (#20)

errors/z_code_test.go

@@ -4,13 +4,22 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/rs/xid"
-
 	"github.com/pubgo/funk/errors"
 	"github.com/pubgo/funk/proto/errorpb"
 	"github.com/pubgo/funk/version"
+	"github.com/rs/xid"
+	"github.com/stretchr/testify/assert"
 )
 
+func TestWrapCaller(t *testing.T) {
+	err := fmt.Errorf("test")
+	var ff = func() error {
+		return errors.WrapCaller(err, 1)
+	}
+
+	assert.Contains(t, fmt.Sprint(ff()), "z_code_test.go:21 TestWrapCaller")
+}
+
 func TestCodeErr(t *testing.T) {
 	err := errors.NewCodeErr(&errorpb.ErrCode{
 		StatusCode: errorpb.Code_Aborted,

log/aaa.go

@@ -6,12 +6,16 @@ import (
 	"github.com/rs/zerolog"
 )
 
+const (
+	ModuleName = "module"
+)
+
 type (
 	Map           = map[string]any
 	Hook          = zerolog.Hook
 	Event         = zerolog.Event
 	Level         = zerolog.Level
-	EnableChecker = func(ctx context.Context, lvl Level, name string, fields Map) bool
+	EnableChecker = func(ctx context.Context, lvl Level, nameOrMessage string, fields Map) bool
 )
 
 type Logger interface {

log/global.go

@@ -16,10 +16,21 @@ import (
 )
 
 var (
-	logEnableChecker      = func(context.Context, Level, string, Map) bool { return true }
+	logEnableChecker      = func(ctx context.Context, lvl Level, nameOrMessage string, fields Map) bool { return true }
 	zErrMarshalFunc       = zerolog.ErrorMarshalFunc
 	zInterfaceMarshalFunc = zerolog.InterfaceMarshalFunc
-	_                     = generic.Init(func() {
+	logGlobalHook         = zerolog.HookFunc(func(e *zerolog.Event, level zerolog.Level, message string) {
+		if logEnableChecker == nil {
+			return
+		}
+
+		if logEnableChecker(e.GetCtx(), level, message, nil) {
+			return
+		}
+
+		e.Discard()
+	})
+	_ = generic.Init(func() {
 		zerolog.SetGlobalLevel(zerolog.DebugLevel)
 		zerolog.ErrorMarshalFunc = func(err error) interface{} {
 			if err == nil {
@@ -59,12 +70,14 @@ var (
 
 	// stdZeroLog default zerolog for debug
 	stdZeroLog = generic.Ptr(
-		zerolog.New(os.Stderr).Level(zerolog.DebugLevel).
-			With().Timestamp().Caller().Logger().
+		zerolog.New(os.Stderr).
+			Level(zerolog.DebugLevel).
+			With().Timestamp().
+			Caller().Logger().
 			Output(zerolog.NewConsoleWriter(func(w *zerolog.ConsoleWriter) {
 				w.Out = os.Stderr
 				w.TimeFormat = time.RFC3339
-			})).Hook(new(hookImpl)),
+			})).Hook(new(hookImpl), logGlobalHook),
 	)
 
 	_ = generic.Init(func() {
@@ -83,6 +96,9 @@ func GetLogger(name string) Logger {
 // SetLogger set global log
 func SetLogger(log *zerolog.Logger) {
 	assert.If(log == nil, "[log] should not be nil")
+
+	log = generic.Ptr(log.Hook(logGlobalHook))
+
 	stdZeroLog = log
 	zlog.Logger = *log
 }

log/impl.log.go

@@ -4,7 +4,9 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"strings"
 
+	"github.com/pubgo/funk/stack"
 	"github.com/rs/zerolog"
 )
 
@@ -47,11 +49,18 @@ func (l *loggerImpl) WithCallerSkip(skip int) Logger {
 }
 
 func (l *loggerImpl) WithName(name string) Logger {
+	name = strings.TrimSpace(name)
 	if name == "" {
 		return l
 	}
 
 	log := l.copy()
+	if log.fields == nil {
+		log.fields = Map{ModuleName: stack.Caller(1).Pkg}
+	} else {
+		log.fields[ModuleName] = stack.Caller(1).Pkg
+	}
+
 	if log.name == "" {
 		log.name = name
 	} else {

result/result.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 
+	"github.com/pubgo/funk/errors"
 	"github.com/pubgo/funk/generic"
 	"github.com/pubgo/funk/stack"
 )
@@ -35,15 +36,15 @@ func OK[T any](v T) Result[T] {
 }
 
 func Err[T any](err error) Result[T] {
-	return Result[T]{e: err}
+	return Result[T]{e: errors.WrapCaller(err, 1)}
 }
 
 func Wrap[T any](v T, err error) Result[T] {
-	return Result[T]{v: &v, e: err}
+	return Result[T]{v: &v, e: errors.WrapCaller(err, 1)}
 }
 
 func Of[T any](v T, err error) Result[T] {
-	return Result[T]{v: &v, e: err}
+	return Result[T]{v: &v, e: errors.WrapCaller(err, 1)}
 }
 
 type Result[T any] struct {
@@ -52,7 +53,7 @@ type Result[T any] struct {
 }
 
 func (r Result[T]) WithErr(err error) Result[T] {
-	return Err[T](err)
+	return Result[T]{e: errors.WrapCaller(err, 1)}
 }
 
 func (r Result[T]) WithVal(v T) Result[T] {
@@ -61,7 +62,7 @@ func (r Result[T]) WithVal(v T) Result[T] {
 
 func (r Result[T]) ValueTo(v *T) error {
 	if r.IsErr() {
-		return r.e
+		return errors.WrapCaller(r.e)
 	}
 
 	*v = generic.FromPtr(r.v)
@@ -73,7 +74,7 @@ func (r Result[T]) OnValue(fn func(t T) error) error {
 		return r.e
 	}
 
-	return fn(generic.FromPtr(r.v))
+	return errors.WrapCaller(fn(generic.FromPtr(r.v)), 1)
 }
 
 func (r Result[T]) Err(check ...func(err error) error) error {
@@ -82,10 +83,10 @@ func (r Result[T]) Err(check ...func(err error) error) error {
 	}
 
 	if len(check) > 0 && check[0] != nil {
-		return check[0](r.e)
+		return errors.WrapCaller(check[0](r.e))
 	}
 
-	return r.e
+	return errors.WrapCaller(r.e)
 }
 
 func (r Result[T]) IsErr() bool {
@@ -124,15 +125,15 @@ func (r Result[T]) Expect(format string, args ...any) T {
 
 func (r Result[T]) String() string {
 	if !r.IsErr() {
-		return fmt.Sprintf("%v", *r.v)
+		return fmt.Sprintf("%v", generic.FromPtr(r.v))
 	}
 
-	return r.e.Error()
+	return fmt.Sprint(errors.WrapCaller(r.e, 1))
 }
 
 func (r Result[T]) MarshalJSON() ([]byte, error) {
 	if r.IsErr() {
-		return nil, r.e
+		return nil, errors.WrapCaller(r.e, 1)
 	}
 
 	return json.Marshal(generic.FromPtr(r.v))