funk/assert/util.go at v2 · pubgo/funk · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package assert

import (
	"fmt"
	"log/slog"
	"reflect"
	"runtime/debug"
	"sync"

	"github.com/k0kubun/pp/v3"
	"github.com/samber/lo"

	"github.com/pubgo/funk/v2/debugs"
	"github.com/pubgo/funk/v2/log/logfields"
	"github.com/pubgo/funk/v2/stack"
)

func messageFromMsgAndArgs(msgAndArgs ...any) string {
	if len(msgAndArgs) == 0 {
		return ""
	}

	if len(msgAndArgs) == 1 {
		if msgAsStr, ok := msgAndArgs[0].(string); ok {
			return msgAsStr
		}
	}

	return pretty().Sprint(msgAndArgs...)
}

var assetFile = stack.Caller(0)

func logErr(err error, message string, attrs ...slog.Attr) {
	if err == nil {
		return
	}

	traces := lo.Filter(stack.Trace(), func(item *stack.Frame, index int) bool {
		return !item.IsRuntime() && item.Pkg != assetFile.Pkg
	})
	attrs = append(attrs,
		slog.String(logfields.Module, Name),
		slog.String(logfields.Error, err.Error()),
		slog.Any(logfields.ErrorStack, lo.Map(traces, func(item *stack.Frame, index int) string { return item.String() })),
		slog.String(logfields.ErrorDetail, fmt.Sprintf("%v", err)),
	)
	slog.Error(message, lo.ToAnySlice(attrs)...)
}

func must(err error, messageArgs ...any) {
	if err == nil {
		return
	}

	attrs := []slog.Attr{slog.Bool("panic", true)}
	if v, ok := lo.ErrorsAs[interface {
		ID() string
		Error() string
	}](err); ok && v != nil {
		attrs = append(attrs, slog.String(logfields.ErrorID, v.ID()))
	}

	message := messageFromMsgAndArgs(messageArgs...)
	if message == "" {
		message = fmt.Sprintf("%s: %v", err.Error(), err)
	} else {
		message = fmt.Sprintf("msg:%v err:%s", message, err.Error())
	}

	logErr(err, message, attrs...)

	if debugs.Enabled.Value() {
		_, _ = pp.Println(err)
		debug.PrintStack()
	}

	panic(err)
}

var pretty = sync.OnceValue(func() *pp.PrettyPrinter {
	printer := pp.New()
	printer.SetColoringEnabled(false)
	printer.SetExportedOnly(false)
	printer.SetOmitEmpty(true)
	printer.SetMaxDepth(5)
	return printer
})

func try(fn func() error) (gErr error) {
	if fn == nil {
		gErr = fmt.Errorf("assert: [fn] is nil")
		logErr(gErr, gErr.Error())
		debug.PrintStack()
		return gErr
	}

	defer func() {
		if err := recover(); err != nil {
			gErr = fmt.Errorf("%v", err)
			logErr(gErr, gErr.Error())
			debug.PrintStack()
		}

		if gErr != nil {
			gErr = fmt.Errorf("stack:%s, err:%w", reflect.TypeOf(fn).String(), gErr)
		}
	}()

	gErr = fn()
	return gErr
}