sdk/log: move Enabled method from FilterProcessor to Processor

CHANGELOG.md

@@ -24,6 +24,8 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - Add experimental observability metrics for manual reader in `go.opentelemetry.io/otel/sdk/metric`. (#7524)
 - Add experimental observability metrics for periodic reader in `go.opentelemetry.io/otel/sdk/metric`. (#7571)
 - Support `OTEL_EXPORTER_OTLP_LOGS_INSECURE` and `OTEL_EXPORTER_OTLP_INSECURE` environmental variables in `go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp`. (#7608)
+- Add `Enabled` method to the `Processor` interface in `go.opentelemetry.io/otel/sdk/log`.
+  All `Processor` implementations now include an `Enabled` method. (#7639)
 
 ### Fixed
 
@@ -40,6 +42,10 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 ### Removed
 
 - Drop support for [Go 1.23]. (#7274)
+- Remove the `FilterProcessor` interface in `go.opentelemetry.io/otel/sdk/log`.
+  The `Enabled` method has been added to the `Processor` interface instead.
+  All `Processor` implementations must now implement the `Enabled` method.
+  Custom processors that do not filter records can implement `Enabled` to return `true`. (#7639)
 
 ### Changed
 

sdk/log/batch.go

@@ -184,6 +184,11 @@ func (b *BatchProcessor) poll(interval time.Duration) (done chan struct{}) {
 	return done
 }
 
+// Enabled returns true, indicating this Processor will process all records.
+func (*BatchProcessor) Enabled(context.Context, EnabledParameters) bool {
+	return true
+}
+
 // OnEmit batches provided log record.
 func (b *BatchProcessor) OnEmit(_ context.Context, r *Record) error {
 	if b.stopped.Load() || b.q == nil {

sdk/log/batch_test.go

@@ -220,6 +220,13 @@ func TestBatchProcessor(t *testing.T) {
 		_ = b.Shutdown(ctx)
 	})
 
+	t.Run("Enabled", func(t *testing.T) {
+		e := newTestExporter(nil)
+		b := NewBatchProcessor(e)
+		enabled := b.Enabled(ctx, EnabledParameters{})
+		assert.True(t, enabled, "Enabled should return true")
+	})
+
 	t.Run("OnEmit", func(t *testing.T) {
 		const batch = 10
 		e := newTestExporter(nil)

sdk/log/bench_test.go

@@ -131,15 +131,15 @@ func BenchmarkProcessor(b *testing.B) {
 
 type timestampProcessor struct{}
 
+func (timestampProcessor) Enabled(context.Context, EnabledParameters) bool {
+	return true
+}
+
 func (timestampProcessor) OnEmit(_ context.Context, r *Record) error {
 	r.SetObservedTimestamp(time.Date(1988, time.November, 17, 0, 0, 0, 0, time.UTC))
 	return nil
 }
 
-func (timestampProcessor) Enabled(context.Context, Record) bool {
-	return true
-}
-
 func (timestampProcessor) Shutdown(context.Context) error {
 	return nil
 }
@@ -150,15 +150,15 @@ func (timestampProcessor) ForceFlush(context.Context) error {
 
 type attrAddProcessor struct{}
 
+func (attrAddProcessor) Enabled(context.Context, EnabledParameters) bool {
+	return true
+}
+
 func (attrAddProcessor) OnEmit(_ context.Context, r *Record) error {
 	r.AddAttributes(log.String("add", "me"))
 	return nil
 }
 
-func (attrAddProcessor) Enabled(context.Context, Record) bool {
-	return true
-}
-
 func (attrAddProcessor) Shutdown(context.Context) error {
 	return nil
 }
@@ -169,15 +169,15 @@ func (attrAddProcessor) ForceFlush(context.Context) error {
 
 type attrSetDecorator struct{}
 
+func (attrSetDecorator) Enabled(context.Context, EnabledParameters) bool {
+	return true
+}
+
 func (attrSetDecorator) OnEmit(_ context.Context, r *Record) error {
 	r.SetAttributes(log.String("replace", "me"))
 	return nil
 }
 
-func (attrSetDecorator) Enabled(context.Context, Record) bool {
-	return true
-}
-
 func (attrSetDecorator) Shutdown(context.Context) error {
 	return nil
 }

sdk/log/example_test.go

@@ -7,7 +7,6 @@ import (
 	"context"
 	"fmt"
 	"strings"
-	"sync"
 
 	logapi "go.opentelemetry.io/otel/log"
 	"go.opentelemetry.io/otel/log/global"
@@ -52,7 +51,7 @@ func Example() {
 }
 
 // Use a processor that filters out records based on the provided context.
-func ExampleFilterProcessor() {
+func ExampleProcessor_contextFilter() {
 	// Existing processor that emits telemetry.
 	var processor log.Processor = log.NewBatchProcessor(nil)
 
@@ -82,15 +81,8 @@ func WithIgnoreLogs(ctx context.Context) context.Context {
 // [WithIgnoreLogs] is passed to its methods.
 type ContextFilterProcessor struct {
 	log.Processor
-
-	lazyFilter sync.Once
-	// Support the FilterProcessor interface for the embedded processor.
-	filter log.FilterProcessor
 }
 
-// Compile time check.
-var _ log.FilterProcessor = (*ContextFilterProcessor)(nil)
-
 func (p *ContextFilterProcessor) OnEmit(ctx context.Context, record *log.Record) error {
 	if ignoreLogs(ctx) {
 		return nil
@@ -99,12 +91,7 @@ func (p *ContextFilterProcessor) OnEmit(ctx context.Context, record *log.Record)
 }
 
 func (p *ContextFilterProcessor) Enabled(ctx context.Context, param log.EnabledParameters) bool {
-	p.lazyFilter.Do(func() {
-		if f, ok := p.Processor.(log.FilterProcessor); ok {
-			p.filter = f
-		}
-	})
-	return !ignoreLogs(ctx) && (p.filter == nil || p.filter.Enabled(ctx, param))
+	return !ignoreLogs(ctx) && p.Processor.Enabled(ctx, param)
 }
 
 func ignoreLogs(ctx context.Context) bool {
@@ -138,6 +125,11 @@ func ExampleProcessor_eventName() {
 // but do support attributes.
 type EventNameProcessor struct{}
 
+// Enabled returns true, indicating this Processor will process all records.
+func (*EventNameProcessor) Enabled(context.Context, log.EnabledParameters) bool {
+	return true
+}
+
 // OnEmit sets the EventName on log records having an "otel.event.name" string attribute.
 // The original attribute is not removed.
 func (*EventNameProcessor) OnEmit(_ context.Context, record *log.Record) error {
@@ -181,6 +173,11 @@ func ExampleProcessor_redact() {
 // from attributes containing "token" in the key.
 type RedactTokensProcessor struct{}
 
+// Enabled returns true, indicating this Processor will process all records.
+func (*RedactTokensProcessor) Enabled(context.Context, log.EnabledParameters) bool {
+	return true
+}
+
 // OnEmit redacts values from attributes containing "token" in the key
 // by replacing them with a REDACTED value.
 func (*RedactTokensProcessor) OnEmit(_ context.Context, record *log.Record) error {

sdk/log/logger.go

@@ -54,9 +54,9 @@ func (l *logger) Emit(ctx context.Context, r log.Record) {
 }
 
 // Enabled returns true if at least one Processor held by the LoggerProvider
-// that created the logger will process param for the provided context and param.
+// that created the logger will process for the provided context and param.
 //
-// If it is not possible to definitively determine the param will be
+// If it is not possible to definitively determine the record will be
 // processed, true will be returned by default. A value of false will only be
 // returned if it can be positively verified that no Processor will process.
 func (l *logger) Enabled(ctx context.Context, param log.EnabledParameters) bool {
@@ -66,23 +66,13 @@ func (l *logger) Enabled(ctx context.Context, param log.EnabledParameters) bool
 		EventName:            param.EventName,
 	}
 
-	// If there are more Processors than FilterProcessors,
-	// which means not all Processors are FilterProcessors,
-	// we cannot be sure that all Processors will drop the record.
-	// Therefore, return true.
-	//
-	// If all Processors are FilterProcessors, check if any is enabled.
-	return len(l.provider.processors) > len(l.provider.fltrProcessors) || anyEnabled(ctx, p, l.provider.fltrProcessors)
-}
-
-func anyEnabled(ctx context.Context, param EnabledParameters, fltrs []FilterProcessor) bool {
-	for _, f := range fltrs {
-		if f.Enabled(ctx, param) {
+	for _, processor := range l.provider.processors {
+		if processor.Enabled(ctx, p) {
 			// At least one Processor will process the Record.
 			return true
 		}
 	}
-	// No Processor will process the record
+	// No Processor will process the record.
 	return false
 }
 

sdk/log/processor.go

@@ -5,16 +5,46 @@ package log // import "go.opentelemetry.io/otel/sdk/log"
 
 import (
 	"context"
+
+	"go.opentelemetry.io/otel/log"
+	"go.opentelemetry.io/otel/sdk/instrumentation"
 )
 
 // Processor handles the processing of log records.
 //
 // Any of the Processor's methods may be called concurrently with itself
 // or with other methods. It is the responsibility of the Processor to manage
 // this concurrency.
-//
-// See [FilterProcessor] for information about how a Processor can support filtering.
 type Processor interface {
+	// Enabled reports whether the Processor will process for the given context
+	// and param.
+	//
+	// The passed param is likely to be partial record information being
+	// provided (e.g. a param with only the Severity set).
+	// If a Processor needs more information than is provided, it
+	// is said to be in an indeterminate state (see below).
+	//
+	// The returned value will be true when the Processor will process for the
+	// provided context and param, and will be false if the Processor will not
+	// process. The returned value may be true or false in an indeterminate state.
+	// An implementation should default to returning true for an indeterminate
+	// state, but may return false if valid reasons in particular circumstances
+	// exist (e.g. performance, correctness).
+	//
+	// The param should not be held by the implementation. A copy should be
+	// made if the param needs to be held after the call returns.
+	//
+	// Processor implementations are expected to re-evaluate the [Record] passed
+	// to OnEmit. It is not expected that the caller to OnEmit will
+	// use the result from Enabled prior to calling OnEmit.
+	//
+	// The SDK's Logger.Enabled returns false if all the registered processors
+	// return false. Otherwise, it returns true.
+	//
+	// Implementations of this method need to be safe for a user to call
+	// concurrently.
+	Enabled(ctx context.Context, param EnabledParameters) bool
+
 	// OnEmit is called when a Record is emitted.
 	//
 	// OnEmit will be called independent of Enabled. Implementations need to
@@ -32,7 +62,8 @@ type Processor interface {
 	// they were registered using WithProcessor.
 	// Implementations may synchronously modify the record so that the changes
 	// are visible in the next registered processor.
-	// Notice that Record is not concurrent safe. Therefore, asynchronous
+	//
+	// Note that Record is not concurrent safe. Therefore, asynchronous
 	// processing may cause race conditions. Use Record.Clone
 	// to create a copy that shares no state with the original.
 	OnEmit(ctx context.Context, record *Record) error
@@ -54,3 +85,10 @@ type Processor interface {
 	// appropriate error should be returned in these situations.
 	ForceFlush(ctx context.Context) error
 }
+
+// EnabledParameters represents payload for [Processor]'s Enabled method.
+type EnabledParameters struct {
+	InstrumentationScope instrumentation.Scope
+	Severity             log.Severity
+	EventName            string
+}

sdk/log/provider.go

@@ -27,12 +27,11 @@ const (
 )
 
 type providerConfig struct {
-	resource       *resource.Resource
-	processors     []Processor
-	fltrProcessors []FilterProcessor
-	attrCntLim     setting[int]
-	attrValLenLim  setting[int]
-	allowDupKeys   setting[bool]
+	resource      *resource.Resource
+	processors    []Processor
+	attrCntLim    setting[int]
+	attrValLenLim setting[int]
+	allowDupKeys  setting[bool]
 }
 
 func newProviderConfig(opts []LoggerProviderOption) providerConfig {
@@ -65,7 +64,6 @@ type LoggerProvider struct {
 
 	resource                  *resource.Resource
 	processors                []Processor
-	fltrProcessors            []FilterProcessor
 	attributeCountLimit       int
 	attributeValueLengthLimit int
 	allowDupKeys              bool
@@ -92,7 +90,6 @@ func NewLoggerProvider(opts ...LoggerProviderOption) *LoggerProvider {
 	return &LoggerProvider{
 		resource:                  cfg.resource,
 		processors:                cfg.processors,
-		fltrProcessors:            cfg.fltrProcessors,
 		attributeCountLimit:       cfg.attrCntLim.Value,
 		attributeValueLengthLimit: cfg.attrValLenLim.Value,
 		allowDupKeys:              cfg.allowDupKeys.Value,
@@ -208,14 +205,9 @@ func WithResource(res *resource.Resource) LoggerProviderOption {
 //
 // For production, use [NewBatchProcessor] to batch log records before they are exported.
 // For testing and debugging, use [NewSimpleProcessor] to synchronously export log records.
-//
-// See [FilterProcessor] for information about how a Processor can support filtering.
 func WithProcessor(processor Processor) LoggerProviderOption {
 	return loggerProviderOptionFunc(func(cfg providerConfig) providerConfig {
 		cfg.processors = append(cfg.processors, processor)
-		if f, ok := processor.(FilterProcessor); ok {
-			cfg.fltrProcessors = append(cfg.fltrProcessors, f)
-		}
 		return cfg
 	})
 }