github.com/saferwall/pe@v1.5.2/log/filter.go (about)

     1  package log
     2  
     3  // FilterOption is filter option.
     4  type FilterOption func(*Filter)
     5  
     6  const fuzzyStr = "***"
     7  
     8  // FilterLevel with filter level.
     9  func FilterLevel(level Level) FilterOption {
    10  	return func(opts *Filter) {
    11  		opts.level = level
    12  	}
    13  }
    14  
    15  // FilterKey with filter key.
    16  func FilterKey(key ...string) FilterOption {
    17  	return func(o *Filter) {
    18  		for _, v := range key {
    19  			o.key[v] = struct{}{}
    20  		}
    21  	}
    22  }
    23  
    24  // FilterValue with filter value.
    25  func FilterValue(value ...string) FilterOption {
    26  	return func(o *Filter) {
    27  		for _, v := range value {
    28  			o.value[v] = struct{}{}
    29  		}
    30  	}
    31  }
    32  
    33  // FilterFunc with filter func.
    34  func FilterFunc(f func(level Level, keyvals ...interface{}) bool) FilterOption {
    35  	return func(o *Filter) {
    36  		o.filter = f
    37  	}
    38  }
    39  
    40  // Filter is a logger filter.
    41  type Filter struct {
    42  	logger Logger
    43  	level  Level
    44  	key    map[interface{}]struct{}
    45  	value  map[interface{}]struct{}
    46  	filter func(level Level, keyvals ...interface{}) bool
    47  }
    48  
    49  // NewFilter new a logger filter.
    50  func NewFilter(logger Logger, opts ...FilterOption) *Filter {
    51  	options := Filter{
    52  		logger: logger,
    53  		key:    make(map[interface{}]struct{}),
    54  		value:  make(map[interface{}]struct{}),
    55  	}
    56  	for _, o := range opts {
    57  		o(&options)
    58  	}
    59  	return &options
    60  }
    61  
    62  // Log Print log by level and keyvals.
    63  func (f *Filter) Log(level Level, keyvals ...interface{}) error {
    64  	if level < f.level {
    65  		return nil
    66  	}
    67  	// fkv is used to provide a slice to contains both logger.prefix and keyvals for filter
    68  	var fkv []interface{}
    69  	if l, ok := f.logger.(*logger); ok {
    70  		if len(l.prefix) > 0 {
    71  			fkv = make([]interface{}, 0, len(l.prefix)+len(keyvals))
    72  			fkv = append(fkv, l.prefix...)
    73  			fkv = append(fkv, keyvals...)
    74  		}
    75  	} else {
    76  		fkv = keyvals
    77  	}
    78  	if f.filter != nil && f.filter(level, fkv...) {
    79  		return nil
    80  	}
    81  	if len(f.key) > 0 || len(f.value) > 0 {
    82  		for i := 0; i < len(keyvals); i += 2 {
    83  			v := i + 1
    84  			if v >= len(keyvals) {
    85  				continue
    86  			}
    87  			if _, ok := f.key[keyvals[i]]; ok {
    88  				keyvals[v] = fuzzyStr
    89  			}
    90  			if _, ok := f.value[keyvals[v]]; ok {
    91  				keyvals[v] = fuzzyStr
    92  			}
    93  		}
    94  	}
    95  	return f.logger.Log(level, keyvals...)
    96  }