-
Notifications
You must be signed in to change notification settings - Fork 0
/
filter.go
97 lines (85 loc) · 2 KB
/
filter.go
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
package logs
const fuzzyStr = "***"
// FilterOption is filter option.
type FilterOption func(*Filter)
// Filter is a logger filter.
type Filter struct {
logger Logger
level Level
key map[interface{}]struct{}
value map[interface{}]struct{}
filter func(level Level, kvs ...interface{}) bool
}
// NewFilter new a logger filter.
func NewFilter(l Logger, opts ...FilterOption) *Filter {
f := &Filter{}
f.Init()
f.logger = l
for _, o := range opts {
o(f)
}
return f
}
// Log Print log by level and key values.
func (f *Filter) Log(level Level, kvs ...interface{}) error {
if level < f.level {
return nil
}
// prefixkv contains the slice of arguments defined as prefixes during the log initialization
var prefixkv []interface{}
l, ok := f.logger.(*logger)
if ok && len(l.prefix) > 0 {
prefixkv = make([]interface{}, 0, len(l.prefix))
prefixkv = append(prefixkv, l.prefix...)
}
if f.filter != nil && (f.filter(level, prefixkv...) || f.filter(level, kvs...)) {
return nil
}
if len(f.key) > 0 || len(f.value) > 0 {
for i := 0; i < len(kvs); i += 2 {
v := i + 1
if v >= len(kvs) {
continue
}
if _, ok := f.key[kvs[i]]; ok {
kvs[v] = fuzzyStr
}
if _, ok := f.value[kvs[v]]; ok {
kvs[v] = fuzzyStr
}
}
}
return f.logger.Log(level, kvs...)
}
func (f *Filter) Init() {
f.key = make(map[interface{}]struct{})
f.value = make(map[interface{}]struct{})
}
// FilterLevel with filter level.
func FilterLevel(level Level) FilterOption {
return func(opts *Filter) {
opts.level = level
}
}
// FilterKey with filter key.
func FilterKey(key ...string) FilterOption {
return func(o *Filter) {
for _, v := range key {
o.key[v] = struct{}{}
}
}
}
// FilterValue with filter value.
func FilterValue(value ...string) FilterOption {
return func(o *Filter) {
for _, v := range value {
o.value[v] = struct{}{}
}
}
}
// FilterFunc with filter func.
func FilterFunc(f func(level Level, kvs ...interface{}) bool) FilterOption {
return func(o *Filter) {
o.filter = f
}
}