refactor

log/zap/filter_core.go

@@ -7,8 +7,8 @@ import (
 
 type FilterFunc func(entry zapcore.Entry, fields []zapcore.Field) bool
 
-func FilterField(field zapcore.Field) FilterFunc {
-	return func(entry zapcore.Entry, fields []zapcore.Field) bool {
+func HasField(field zapcore.Field) FilterFunc {
+	return func(_ zapcore.Entry, fields []zapcore.Field) bool {
 		for _, f := range fields {
 			if f.Equals(field) {
 				return true
@@ -18,24 +18,52 @@ func FilterField(field zapcore.Field) FilterFunc {
 	}
 }
 
+func Or(filters ...FilterFunc) FilterFunc {
+	return func(entry zapcore.Entry, fields []zapcore.Field) bool {
+		for _, filter := range filters {
+			if filter(entry, fields) {
+				return true
+			}
+		}
+		return false
+	}
+}
+
+func And(filters ...FilterFunc) FilterFunc {
+	return func(entry zapcore.Entry, fields []zapcore.Field) bool {
+		for _, filter := range filters {
+			if !filter(entry, fields) {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+func Not(filter FilterFunc) FilterFunc {
+	return func(entry zapcore.Entry, fields []zapcore.Field) bool {
+		return !filter(entry, fields)
+	}
+}
+
 type filterCore struct {
 	zapcore.Core
 
-	filters []FilterFunc
+	filter FilterFunc
 	fields []zap.Field
 }
 
-func RegisterFilters(core zapcore.Core, filters ...FilterFunc) zapcore.Core {
+func RegisterFilters(core zapcore.Core, filter FilterFunc) zapcore.Core {
 	return &filterCore{
 		Core:   core,
-		filters: filters,
+		filter: filter,
 	}
 }
 
 func (core *filterCore) With(fields []zapcore.Field) zapcore.Core {
 	return &filterCore{
 		Core:   core.Core.With(fields),
-		filters: core.filters,
+		filter: core.filter,
 		fields: append(core.fields, fields...),
 	}
 }
@@ -48,15 +76,13 @@ func (core *filterCore) Check(entry zapcore.Entry, checkedEntry *zapcore.Checked
 }
 
 func (core *filterCore) Write(entry zapcore.Entry, fields []zapcore.Field) error {
-	if len(core.filters) > 0 {
+	if len(core.fields) > 0 {
 		fields = append(core.fields, fields...)
 	}
 
-	for _, filter := range core.filters {
-		if !filter(entry, fields) {
+	if !core.filter(entry, fields) {
 		return nil
 	}
-	}
 
 	return core.Core.Write(entry, fields)
 }

log/zap/filter_core_test.go

@@ -11,7 +11,7 @@ import (
 
 func TestFilterCore_Write(t *testing.T) {
 	core, logs := observer.New(zapcore.InfoLevel)
-	core = RegisterFilters(core, FilterField(zap.Bool("check", true)))
+	core = RegisterFilters(core, HasField(zap.Bool("check", true)))
 
 	err := core.With([]zapcore.Field{zap.Bool("check", true)}).Write(zapcore.Entry{Message: "msg"}, nil)
 	require.NoError(t, err)
@@ -24,3 +24,64 @@ func TestFilterCore_Write(t *testing.T) {
 
 	require.Equal(t, 2, logs.Len())
 }
+
+func TestAnd(t *testing.T) {
+	core, logs := observer.New(zapcore.InfoLevel)
+	core = RegisterFilters(core, And(
+		HasField(zap.Int("a", 1)),
+		HasField(zap.Int("b", 2)),
+	))
+
+	err := core.Write(zapcore.Entry{Message: "msg"}, []zapcore.Field{
+		zap.Int("a", 1),
+		zap.Int("b", 2),
+	})
+	require.NoError(t, err)
+
+	err = core.Write(zapcore.Entry{Message: "msg"}, []zapcore.Field{
+		zap.Int("a", 1),
+		zap.Int("b", 3),
+	})
+	require.NoError(t, err)
+
+	require.Equal(t, 1, logs.Len())
+}
+
+func TestOr(t *testing.T) {
+	core, logs := observer.New(zapcore.InfoLevel)
+	core = RegisterFilters(core, Or(
+		HasField(zap.Int("a", 1)),
+		HasField(zap.Int("b", 2)),
+	))
+
+	err := core.Write(zapcore.Entry{Message: "msg"}, []zapcore.Field{
+		zap.Int("a", 1),
+		zap.Int("b", 3),
+	})
+	require.NoError(t, err)
+
+	err = core.Write(zapcore.Entry{Message: "msg"}, []zapcore.Field{
+		zap.Int("a", 3),
+		zap.Int("b", 2),
+	})
+	require.NoError(t, err)
+
+	require.Equal(t, 2, logs.Len())
+}
+
+func TestNot(t *testing.T) {
+	core, logs := observer.New(zapcore.InfoLevel)
+	core = RegisterFilters(core, Not(HasField(zap.Int("a", 1))))
+
+	err := core.Write(zapcore.Entry{Message: "msg"}, []zapcore.Field{
+		zap.Int("a", 1),
+	})
+	require.NoError(t, err)
+
+	err = core.Write(zapcore.Entry{Message: "msg"}, []zapcore.Field{
+		zap.Int("a", 2),
+	})
+	require.NoError(t, err)
+
+	require.Equal(t, 1, logs.Len())
+}