Change filter interface to be compatible with ottl (#16443)

Signed-off-by: Bogdan Drutu <[email protected]>

Signed-off-by: Bogdan Drutu <[email protected]>

.chloggen/ottlfilter.yaml

@@ -0,0 +1,11 @@
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: internal/filter
+
+# A brief description of the change. Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Change filter interface to be compatible with ottl
+
+# One or more tracking issues related to the change
+issues: [16443]

cmd/configschema/go.mod

@@ -536,7 +536,7 @@ require (
  github.com/signalfx/golib/v3 v3.3.46 // indirect
  github.com/signalfx/sapm-proto v0.12.0 // indirect
  github.com/signalfx/signalfx-agent/pkg/apm v0.0.0-20220920175102-539ae8d8ba8e // indirect
- github.com/sijms/go-ora/v2 v2.5.8 // indirect
+ github.com/sijms/go-ora/v2 v2.5.10 // indirect
  github.com/sirupsen/logrus v1.9.0 // indirect
  github.com/snowflakedb/gosnowflake v1.6.15 // indirect
  github.com/soheilhy/cmux v0.1.5 // indirect

go.mod

@@ -545,7 +545,7 @@ require (
  github.com/signalfx/golib/v3 v3.3.46 // indirect
  github.com/signalfx/sapm-proto v0.12.0 // indirect
  github.com/signalfx/signalfx-agent/pkg/apm v0.0.0-20220920175102-539ae8d8ba8e // indirect
- github.com/sijms/go-ora/v2 v2.5.8 // indirect
+ github.com/sijms/go-ora/v2 v2.5.10 // indirect
  github.com/sirupsen/logrus v1.9.0 // indirect
  github.com/snowflakedb/gosnowflake v1.6.15 // indirect
  github.com/soheilhy/cmux v0.1.5 // indirect

internal/filter/expr/matcher.go

@@ -0,0 +1,58 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http:https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package expr // import "github.com/open-telemetry/opentelemetry-collector-contrib/internal/filter/expr"
+
+import (
+ "context"
+)
+
+// BoolExpr is an interface that allows matching a context K against a configuration of a match.
+type BoolExpr[K any] interface {
+ Eval(ctx context.Context, tCtx K) (bool, error)
+}
+
+type notMatcher[K any] struct {
+ matcher BoolExpr[K]
+}
+
+func (nm notMatcher[K]) Eval(ctx context.Context, tCtx K) (bool, error) {
+ ret, err := nm.matcher.Eval(ctx, tCtx)
+ return !ret, err
+}
+
+func Not[K any](matcher BoolExpr[K]) BoolExpr[K] {
+ return notMatcher[K]{matcher: matcher}
+}
+
+type orMatcher[K any] struct {
+ matchers []BoolExpr[K]
+}
+
+func (om orMatcher[K]) Eval(ctx context.Context, tCtx K) (bool, error) {
+ for i := range om.matchers {
+ ret, err := om.matchers[i].Eval(ctx, tCtx)
+ if err != nil {
+ return false, err
+ }
+ if ret {
+ return true, nil
+ }
+ }
+ return false, nil
+}
+
+func Or[K any](matchers ...BoolExpr[K]) BoolExpr[K] {
+ return orMatcher[K]{matchers: matchers}
+}

internal/filter/filterlog/filterlog.go

@@ -15,23 +15,38 @@
 package filterlog // import "github.com/open-telemetry/opentelemetry-collector-contrib/internal/filter/filterlog"
 
 import (
+ "context"
  "fmt"
 
  "go.opentelemetry.io/collector/pdata/pcommon"
- "go.opentelemetry.io/collector/pdata/plog"
 
+ "github.com/open-telemetry/opentelemetry-collector-contrib/internal/filter/expr"
  "github.com/open-telemetry/opentelemetry-collector-contrib/internal/filter/filterconfig"
  "github.com/open-telemetry/opentelemetry-collector-contrib/internal/filter/filtermatcher"
  "github.com/open-telemetry/opentelemetry-collector-contrib/internal/filter/filterset"
+ "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/contexts/ottllog"
 )
 
-// Matcher is an interface that allows matching a log record against a
-// configuration of a match.
-// TODO: Modify Matcher to invoke both the include and exclude properties so
-//
-// calling processors will always have the same logic.
-type Matcher interface {
- MatchLogRecord(lr plog.LogRecord, resource pcommon.Resource, library pcommon.InstrumentationScope) bool
+// NewSkipExpr creates a BoolExpr that on evaluation returns true if a log should NOT be processed or kept.
+// The logic determining if a log should be processed is based on include and exclude settings.
+// Include properties are checked before exclude settings are checked.
+func NewSkipExpr(mp *filterconfig.MatchConfig) (expr.BoolExpr[ottllog.TransformContext], error) {
+ var matchers []expr.BoolExpr[ottllog.TransformContext]
+ inclExpr, err := newExpr(mp.Include)
+ if err != nil {
+ return nil, err
+ }
+ if inclExpr != nil {
+ matchers = append(matchers, expr.Not(inclExpr))
+ }
+ exclExpr, err := newExpr(mp.Exclude)
+ if err != nil {
+ return nil, err
+ }
+ if exclExpr != nil {
+ matchers = append(matchers, exclExpr)
+ }
+ return expr.Or(matchers...), nil
 }
 
 // propertiesMatcher allows matching a log record against various log record properties.
@@ -45,11 +60,11 @@ type propertiesMatcher struct {
  severityTextFilters filterset.FilterSet
 
  // matcher for severity number
- severityNumberMatcher Matcher
+ severityNumberMatcher *severityNumberMatcher
 }
 
 // NewMatcher creates a LogRecord Matcher that matches based on the given MatchProperties.
-func NewMatcher(mp *filterconfig.MatchProperties) (Matcher, error) {
+func newExpr(mp *filterconfig.MatchProperties) (expr.BoolExpr[ottllog.TransformContext], error) {
  if mp == nil {
  return nil, nil
  }
@@ -78,37 +93,38 @@ func NewMatcher(mp *filterconfig.MatchProperties) (Matcher, error) {
  }
  }
 
- var severityNumberMatcher Matcher
+ pm := &propertiesMatcher{
+ PropertiesMatcher: rm,
+ bodyFilters: bodyFS,
+ severityTextFilters: severitytextFS,
+ }
+
  if mp.LogSeverityNumber != nil {
- severityNumberMatcher = newSeverityNumberMatcher(mp.LogSeverityNumber.Min, mp.LogSeverityNumber.MatchUndefined)
+ pm.severityNumberMatcher = newSeverityNumberMatcher(mp.LogSeverityNumber.Min, mp.LogSeverityNumber.MatchUndefined)
  }
 
- return &propertiesMatcher{
- PropertiesMatcher: rm,
- bodyFilters: bodyFS,
- severityTextFilters: severitytextFS,
- severityNumberMatcher: severityNumberMatcher,
- }, nil
+ return pm, nil
 }
 
-// MatchLogRecord matches a log record to a set of properties.
+// Eval matches a log record to a set of properties.
 // There are 3 sets of properties to match against.
 // The log record names are matched, if specified.
 // The log record bodies are matched, if specified.
 // The attributes are then checked, if specified.
 // At least one of log record names or attributes must be specified. It is
 // supported to have more than one of these specified, and all specified must
 // evaluate to true for a match to occur.
-func (mp *propertiesMatcher) MatchLogRecord(lr plog.LogRecord, resource pcommon.Resource, library pcommon.InstrumentationScope) bool {
+func (mp *propertiesMatcher) Eval(_ context.Context, tCtx ottllog.TransformContext) (bool, error) {
+ lr := tCtx.GetLogRecord()
  if lr.Body().Type() == pcommon.ValueTypeStr && mp.bodyFilters != nil && !mp.bodyFilters.Matches(lr.Body().Str()) {
- return false
+ return false, nil
  }
  if mp.severityTextFilters != nil && !mp.severityTextFilters.Matches(lr.SeverityText()) {
- return false
+ return false, nil
  }
- if mp.severityNumberMatcher != nil && !mp.severityNumberMatcher.MatchLogRecord(lr, resource, library) {
- return false
+ if mp.severityNumberMatcher != nil && !mp.severityNumberMatcher.match(lr) {
+ return false, nil
  }
 
- return mp.PropertiesMatcher.Match(lr.Attributes(), resource, library)
+ return mp.PropertiesMatcher.Match(lr.Attributes(), tCtx.GetResource(), tCtx.GetInstrumentationScope()), nil
 }

internal/filter/filterlog/filterlog_test.go

@@ -15,6 +15,7 @@
 package filterlog
 
 import (
+ "context"
  "testing"
 
  "github.com/stretchr/testify/assert"
@@ -24,6 +25,7 @@ import (
 
  "github.com/open-telemetry/opentelemetry-collector-contrib/internal/filter/filterconfig"
  "github.com/open-telemetry/opentelemetry-collector-contrib/internal/filter/filterset"
+ "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/contexts/ottllog"
 )
 
 func createConfig(matchType filterset.MatchType) *filterset.Config {
@@ -84,8 +86,8 @@ func TestLogRecord_validateMatchesConfiguration_InvalidConfig(t *testing.T) {
  }
  for _, tc := range testcases {
  t.Run(tc.name, func(t *testing.T) {
- output, err := NewMatcher(&tc.property)
- assert.Nil(t, output)
+ expr, err := newExpr(&tc.property)
+ assert.Nil(t, expr)
  require.NotNil(t, err)
  println(tc.name)
  assert.Equal(t, tc.errorString, err.Error())
@@ -140,11 +142,13 @@ func TestLogRecord_Matching_False(t *testing.T) {
 
  for _, tc := range testcases {
  t.Run(tc.name, func(t *testing.T) {
- matcher, err := NewMatcher(tc.properties)
+ expr, err := newExpr(tc.properties)
  assert.Nil(t, err)
- require.NotNil(t, matcher)
+ require.NotNil(t, expr)
 
- assert.False(t, matcher.MatchLogRecord(lr, pcommon.Resource{}, pcommon.InstrumentationScope{}))
+ val, err := expr.Eval(context.Background(), ottllog.NewTransformContext(lr, pcommon.NewInstrumentationScope(), pcommon.NewResource()))
+ require.NoError(t, err)
+ assert.False(t, val)
  })
  }
 }
@@ -203,12 +207,14 @@ func TestLogRecord_Matching_True(t *testing.T) {
 
  for _, tc := range testcases {
  t.Run(tc.name, func(t *testing.T) {
- mp, err := NewMatcher(tc.properties)
+ expr, err := newExpr(tc.properties)
  assert.NoError(t, err)
- require.NotNil(t, mp)
+ require.NotNil(t, expr)
 
  assert.NotNil(t, lr)
- assert.True(t, mp.MatchLogRecord(lr, pcommon.Resource{}, pcommon.InstrumentationScope{}))
+ val, err := expr.Eval(context.Background(), ottllog.NewTransformContext(lr, pcommon.NewInstrumentationScope(), pcommon.NewResource()))
+ require.NoError(t, err)
+ assert.True(t, val)
  })
  }
 }

internal/filter/filterlog/severity_matcher.go

@@ -15,7 +15,6 @@
 package filterlog // import "github.com/open-telemetry/opentelemetry-collector-contrib/internal/filter/filterlog"
 
 import (
- "go.opentelemetry.io/collector/pdata/pcommon"
  "go.opentelemetry.io/collector/pdata/plog"
 )
 
@@ -26,14 +25,14 @@ type severityNumberMatcher struct {
  minSeverityNumber plog.SeverityNumber
 }
 
-func newSeverityNumberMatcher(minSeverity plog.SeverityNumber, matchUndefined bool) severityNumberMatcher {
- return severityNumberMatcher{
+func newSeverityNumberMatcher(minSeverity plog.SeverityNumber, matchUndefined bool) *severityNumberMatcher {
+ return &severityNumberMatcher{
  minSeverityNumber: minSeverity,
  matchUndefined: matchUndefined,
  }
 }
 
-func (snm severityNumberMatcher) MatchLogRecord(lr plog.LogRecord, _ pcommon.Resource, _ pcommon.InstrumentationScope) bool {
+func (snm severityNumberMatcher) match(lr plog.LogRecord) bool {
  // behavior on SeverityNumberUNDEFINED is explicitly defined by matchUndefined
  if lr.SeverityNumber() == plog.SeverityNumberUnspecified {
  return snm.matchUndefined

internal/filter/filterlog/severity_matcher_test.go

@@ -18,7 +18,6 @@ import (
  "testing"
 
  "github.com/stretchr/testify/require"
- "go.opentelemetry.io/collector/pdata/pcommon"
  "go.opentelemetry.io/collector/pdata/plog"
 )
 
@@ -85,12 +84,10 @@ func TestSeverityMatcher_MatchLogRecord(t *testing.T) {
  t.Run(tc.name, func(t *testing.T) {
  matcher := newSeverityNumberMatcher(tc.minSeverity, tc.matchUndefined)
 
- r := pcommon.NewResource()
- i := pcommon.NewInstrumentationScope()
  lr := plog.NewLogRecord()
  lr.SetSeverityNumber(tc.inputSeverity)
 
- require.Equal(t, tc.matches, matcher.MatchLogRecord(lr, r, i))
+ require.Equal(t, tc.matches, matcher.match(lr))
  })
  }
 }

internal/filter/filtermetric/config.go

@@ -68,24 +68,3 @@ func CreateMatchPropertiesFromDefault(properties *filterconfig.MatchProperties)
  ResourceAttributes: properties.Resources,
  }
 }
-
-// ChecksMetrics returns whether the check should iterate through all the metrics
-func (mp *MatchProperties) ChecksMetrics() bool {
- if mp == nil {
- return false
- }
-
- if mp.MatchType == Expr {
- return len(mp.Expressions) > 0
- }
- return len(mp.MetricNames) > 0
-}
-
-// ChecksResourceAtributes returns whether or not it checks the resource_attributes
-func (mp *MatchProperties) ChecksResourceAtributes() bool {
- if mp == nil {
- return false
- }
-
- return len(mp.ResourceAttributes) > 0
-}