probabilisticsampler: add filterspan config

processor/probabilisticsamplerprocessor/config.go

@@ -16,12 +16,16 @@ package probabilisticsamplerprocessor // import "github.com/open-telemetry/opent
 
 import (
 	"go.opentelemetry.io/collector/config"
+
+	"github.com/open-telemetry/opentelemetry-collector-contrib/internal/coreinternal/processor/filterconfig"
 )
 
 // Config has the configuration guiding the trace sampler processor.
 type Config struct {
 	config.ProcessorSettings `mapstructure:",squash"` // squash ensures fields are correctly decoded in embedded struct
 
+	filterconfig.MatchConfig `mapstructure:",squash"`
+
 	// SamplingPercentage is the percentage rate at which traces are going to be sampled. Defaults to zero, i.e.: no sample.
 	// Values greater or equal 100 are treated as "sample all traces".
 	SamplingPercentage float32 `mapstructure:"sampling_percentage"`

processor/probabilisticsamplerprocessor/probabilisticsampler.go

@@ -22,6 +22,8 @@ import (
 	"go.opentelemetry.io/collector/consumer"
 	"go.opentelemetry.io/collector/model/pdata"
 	"go.opentelemetry.io/collector/processor/processorhelper"
+
+	"github.com/open-telemetry/opentelemetry-collector-contrib/internal/coreinternal/processor/filterspan"
 )
 
 // samplingPriority has the semantic result of parsing the "sampling.priority"
@@ -51,15 +53,28 @@ const (
 type tracesamplerprocessor struct {
 	scaledSamplingRate uint32
 	hashSeed           uint32
+	include            filterspan.Matcher
+	exclude            filterspan.Matcher
 }
 
 // newTracesProcessor returns a processor.TracesProcessor that will perform head sampling according to the given
 // configuration.
 func newTracesProcessor(nextConsumer consumer.Traces, cfg *Config) (component.TracesProcessor, error) {
+	include, err := filterspan.NewMatcher(cfg.Include)
+	if err != nil {
+		return nil, err
+	}
+	exclude, err := filterspan.NewMatcher(cfg.Exclude)
+	if err != nil {
+		return nil, err
+	}
+
 	tsp := &tracesamplerprocessor{
 		// Adjust sampling percentage on private so recalculations are avoided.
 		scaledSamplingRate: uint32(cfg.SamplingPercentage * percentageScaleFactor),
 		hashSeed:           cfg.HashSeed,
+		include:            include,
+		exclude:            exclude,
 	}
 
 	return processorhelper.NewTracesProcessor(
@@ -73,6 +88,9 @@ func (tsp *tracesamplerprocessor) processTraces(_ context.Context, td pdata.Trac
 	td.ResourceSpans().RemoveIf(func(rs pdata.ResourceSpans) bool {
 		rs.InstrumentationLibrarySpans().RemoveIf(func(ils pdata.InstrumentationLibrarySpans) bool {
 			ils.Spans().RemoveIf(func(s pdata.Span) bool {
+				if filterspan.SkipSpan(tsp.include, tsp.exclude, s, rs.Resource(), ils.InstrumentationLibrary()) {
+					return false
+				}
 				sp := parseSpanSamplingPriority(s)
 				if sp == doNotSampleSpan {
 					// The OpenTelemetry mentions this as a "hint" we take a stronger