minsev: Update to use sdk/log.FilterProcessor

processors/minsev/example_test.go

@@ -1,7 +1,7 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
-package minsev // import "go.opentelemetry.io/contrib/processors/minsev"
+package minsev_test
 
 import (
 	"context"
@@ -10,39 +10,52 @@ import (
 	"strings"
 	"sync"
 
-	"go.opentelemetry.io/otel/log"
+	"go.opentelemetry.io/contrib/processors/minsev"
+	logapi "go.opentelemetry.io/otel/log"
+	"go.opentelemetry.io/otel/sdk/log"
 )
 
 const key = "OTEL_LOG_LEVEL"
 
-var getSeverity = sync.OnceValue(func() log.Severity {
-	conv := map[string]log.Severity{
-		"":      log.SeverityInfo, // Default to SeverityInfo for unset.
-		"debug": log.SeverityDebug,
-		"info":  log.SeverityInfo,
-		"warn":  log.SeverityWarn,
-		"error": log.SeverityError,
+var getSeverity = sync.OnceValue(func() logapi.Severity {
+	conv := map[string]logapi.Severity{
+		"":      logapi.SeverityInfo, // Default to SeverityInfo for unset.
+		"debug": logapi.SeverityDebug,
+		"info":  logapi.SeverityInfo,
+		"warn":  logapi.SeverityWarn,
+		"error": logapi.SeverityError,
 	}
 	// log.SeverityUndefined for unknown values.
 	return conv[strings.ToLower(os.Getenv(key))]
 })
 
 type EnvSeverity struct{}
 
-func (EnvSeverity) Severity() log.Severity { return getSeverity() }
+func (EnvSeverity) Severity() logapi.Severity { return getSeverity() }
 
 func ExampleSeveritier() {
-	// Mock an environment variable setup that would be done externally.
+	// Mock an environmental variable setup that would be done externally.
 	_ = os.Setenv(key, "error")
 
-	p := NewLogProcessor(&processor{}, EnvSeverity{})
+	// Existing processor that emits telemetry.
+	var processor log.Processor = log.NewBatchProcessor(nil)
+
+	// Wrap the processor so that it filters by severity level defined
+	// via environmental variable.
+	processor = minsev.NewLogProcessor(processor, EnvSeverity{})
+	lp := log.NewLoggerProvider(
+		log.WithProcessor(processor),
+	)
+
+	// Show that Logs API respects the minimum severity level processor.
+	l := lp.Logger("ExampleSeveritier")
 
 	ctx := context.Background()
-	params := log.EnabledParameters{Severity: log.SeverityDebug}
-	fmt.Println(p.Enabled(ctx, params))
+	params := logapi.EnabledParameters{Severity: logapi.SeverityDebug}
+	fmt.Println(l.Enabled(ctx, params))
 
-	params.Severity = log.SeverityError
-	fmt.Println(p.Enabled(ctx, params))
+	params.Severity = logapi.SeverityError
+	fmt.Println(l.Enabled(ctx, params))
 
 	// Output:
 	// false

processors/minsev/go.mod

@@ -4,8 +4,8 @@ go 1.22.0
 
 require (
 	github.com/stretchr/testify v1.10.0
-	go.opentelemetry.io/otel/log v0.10.0
-	go.opentelemetry.io/otel/sdk/log v0.10.0
+	go.opentelemetry.io/otel/log v0.10.1-0.20250224125506-8f4a5c69cefc
+	go.opentelemetry.io/otel/sdk/log v0.10.1-0.20250224125506-8f4a5c69cefc
 )
 
 require (

processors/minsev/go.sum

@@ -5,8 +5,8 @@ github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
 github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
@@ -23,14 +23,14 @@ go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJyS
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
 go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY=
 go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI=
-go.opentelemetry.io/otel/log v0.10.0 h1:1CXmspaRITvFcjA4kyVszuG4HjA61fPDxMb7q3BuyF0=
-go.opentelemetry.io/otel/log v0.10.0/go.mod h1:PbVdm9bXKku/gL0oFfUF4wwsQsOPlpo4VEqjvxih+FM=
+go.opentelemetry.io/otel/log v0.10.1-0.20250224125506-8f4a5c69cefc h1:vIGFFRXNhebgQQBIw7c2w4K93npz67/xmQhhing8CsU=
+go.opentelemetry.io/otel/log v0.10.1-0.20250224125506-8f4a5c69cefc/go.mod h1:PbVdm9bXKku/gL0oFfUF4wwsQsOPlpo4VEqjvxih+FM=
 go.opentelemetry.io/otel/metric v1.34.0 h1:+eTR3U0MyfWjRDhmFMxe2SsW64QrZ84AOhvqS7Y+PoQ=
 go.opentelemetry.io/otel/metric v1.34.0/go.mod h1:CEDrp0fy2D0MvkXE+dPV7cMi8tWZwX3dmaIhwPOaqHE=
 go.opentelemetry.io/otel/sdk v1.34.0 h1:95zS4k/2GOy069d321O8jWgYsW3MzVV+KuSPKp7Wr1A=
 go.opentelemetry.io/otel/sdk v1.34.0/go.mod h1:0e/pNiaMAqaykJGKbi+tSjWfNNHMTxoC9qANsCzbyxU=
-go.opentelemetry.io/otel/sdk/log v0.10.0 h1:lR4teQGWfeDVGoute6l0Ou+RpFqQ9vaPdrNJlST0bvw=
-go.opentelemetry.io/otel/sdk/log v0.10.0/go.mod h1:A+V1UTWREhWAittaQEG4bYm4gAZa6xnvVu+xKrIRkzo=
+go.opentelemetry.io/otel/sdk/log v0.10.1-0.20250224125506-8f4a5c69cefc h1:m0gido5erFeG6rw0oeHG+q6phCt2zJoITOb9Ep8utfA=
+go.opentelemetry.io/otel/sdk/log v0.10.1-0.20250224125506-8f4a5c69cefc/go.mod h1:OgBCX0YiEQebWDdNSNyuu2Ls494YylU4nGBLKScoyrY=
 go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k=
 go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE=
 golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=

processors/minsev/minsev.go

@@ -8,7 +8,6 @@ package minsev // import "go.opentelemetry.io/contrib/processors/minsev"
 import (
 	"context"
 
-	api "go.opentelemetry.io/otel/log"
 	"go.opentelemetry.io/otel/sdk/log"
 )
 
@@ -31,18 +30,12 @@ func NewLogProcessor(downstream log.Processor, severity Severitier) *LogProcesso
 		severity = SeverityInfo
 	}
 	p := &LogProcessor{Processor: downstream, sev: severity}
-	if fp, ok := downstream.(filterProcessor); ok {
+	if fp, ok := downstream.(log.FilterProcessor); ok {
 		p.filter = fp
 	}
 	return p
 }
 
-// filterProcessor is the experimental optional interface a Processor can
-// implement (go.opentelemetry.io/otel/sdk/log/internal/x).
-type filterProcessor interface {
-	Enabled(ctx context.Context, param api.EnabledParameters) bool
-}
-
 // LogProcessor is an [log.Processor] implementation that wraps another
 // [log.Processor]. It will pass-through calls to OnEmit and Enabled for
 // records with severity greater than or equal to a minimum. All other method
@@ -54,12 +47,15 @@ type filterProcessor interface {
 type LogProcessor struct {
 	log.Processor
 
-	filter filterProcessor
+	filter log.FilterProcessor
 	sev    Severitier
 }
 
-// Compile time assertion that LogProcessor implements log.Processor.
-var _ log.Processor = (*LogProcessor)(nil)
+// Compile time assertion that LogProcessor implements log.Processor and log.FilterProcessor.
+var (
+	_ log.Processor       = (*LogProcessor)(nil)
+	_ log.FilterProcessor = (*LogProcessor)(nil)
+)
 
 // OnEmit passes ctx and r to the [log.Processor] that p wraps if the severity
 // of record is greater than or equal to p.Minimum. Otherwise, record is
@@ -74,7 +70,7 @@ func (p *LogProcessor) OnEmit(ctx context.Context, record *log.Record) error {
 // Enabled returns if the [log.Processor] that p wraps is enabled if the
 // severity of param is greater than or equal to p.Minimum. Otherwise false is
 // returned.
-func (p *LogProcessor) Enabled(ctx context.Context, param api.EnabledParameters) bool {
+func (p *LogProcessor) Enabled(ctx context.Context, param log.EnabledParameters) bool {
 	sev := param.Severity
 	if p.filter != nil {
 		return sev >= p.sev.Severity() &&
@@ -88,6 +84,6 @@ var defaultProcessor = noopProcessor{}
 type noopProcessor struct{}
 
 func (p noopProcessor) OnEmit(context.Context, *log.Record) error           { return nil }
-func (p noopProcessor) Enabled(context.Context, api.EnabledParameters) bool { return false }
+func (p noopProcessor) Enabled(context.Context, log.EnabledParameters) bool { return false }
 func (p noopProcessor) Shutdown(context.Context) error                      { return nil }
 func (p noopProcessor) ForceFlush(context.Context) error                    { return nil }

processors/minsev/minsev_test.go

@@ -33,7 +33,7 @@ type emitArgs struct {
 
 type enabledArgs struct {
 	Ctx   context.Context
-	Param api.EnabledParameters
+	Param log.EnabledParameters
 }
 
 type processor struct {
@@ -45,12 +45,18 @@ type processor struct {
 	ShutdownCalls   []context.Context
 }
 
+// Compile time assertion that processor implements log.Processor and log.FilterProcessor.
+var (
+	_ log.Processor       = (*processor)(nil)
+	_ log.FilterProcessor = (*processor)(nil)
+)
+
 func (p *processor) OnEmit(ctx context.Context, r *log.Record) error {
 	p.OnEmitCalls = append(p.OnEmitCalls, emitArgs{ctx, r})
 	return p.ReturnErr
 }
 
-func (p *processor) Enabled(ctx context.Context, param api.EnabledParameters) bool {
+func (p *processor) Enabled(ctx context.Context, param log.EnabledParameters) bool {
 	p.EnabledCalls = append(p.EnabledCalls, enabledArgs{ctx, param})
 	return true
 }
@@ -78,19 +84,19 @@ func TestLogProcessorDynamicSeverity(t *testing.T) {
 	p := NewLogProcessor(wrapped, sev)
 
 	ctx := context.Background()
-	params := &api.EnabledParameters{Severity: api.SeverityDebug}
-	assert.False(t, p.Enabled(ctx, *params), api.SeverityDebug.String())
+	params := log.EnabledParameters{Severity: api.SeverityDebug}
+	assert.False(t, p.Enabled(ctx, params), api.SeverityDebug.String())
 
 	params.Severity = api.SeverityInfo
-	assert.True(t, p.Enabled(ctx, *params), api.SeverityInfo.String())
+	assert.True(t, p.Enabled(ctx, params), api.SeverityInfo.String())
 
 	sev.Set(SeverityError)
 
 	params.Severity = api.SeverityInfo
-	assert.False(t, p.Enabled(ctx, *params), api.SeverityInfo.String())
+	assert.False(t, p.Enabled(ctx, params), api.SeverityInfo.String())
 
 	params.Severity = api.SeverityError
-	assert.True(t, p.Enabled(ctx, *params), api.SeverityError.String())
+	assert.True(t, p.Enabled(ctx, params), api.SeverityError.String())
 }
 
 func TestLogProcessorOnEmit(t *testing.T) {
@@ -135,7 +141,7 @@ func TestLogProcessorEnabled(t *testing.T) {
 
 		p := NewLogProcessor(wrapped, SeverityTrace1)
 		ctx := context.Background()
-		param := api.EnabledParameters{}
+		param := log.EnabledParameters{}
 		for _, sev := range severities {
 			param.Severity = sev
 			assert.True(t, p.Enabled(ctx, param), sev.String())
@@ -153,7 +159,7 @@ func TestLogProcessorEnabled(t *testing.T) {
 
 		p := NewLogProcessor(wrapped, apiSev(api.SeverityFatal4+1))
 		ctx := context.Background()
-		param := api.EnabledParameters{}
+		param := log.EnabledParameters{}
 		for _, sev := range severities {
 			param.Severity = sev
 			assert.False(t, p.Enabled(ctx, param), sev.String())
@@ -170,16 +176,16 @@ func TestLogProcessorEnabled(t *testing.T) {
 		pruned := struct{ log.Processor }{wrapped} // Remove the Enabled method.
 		p := NewLogProcessor(pruned, SeverityInfo)
 		ctx := context.Background()
-		params := &api.EnabledParameters{}
+		params := log.EnabledParameters{}
 
 		params.Severity = api.SeverityDebug
-		assert.False(t, p.Enabled(ctx, *params))
+		assert.False(t, p.Enabled(ctx, params))
 
 		params.Severity = api.SeverityInfo
-		assert.True(t, p.Enabled(ctx, *params))
+		assert.True(t, p.Enabled(ctx, params))
 
 		params.Severity = api.SeverityError
-		assert.True(t, p.Enabled(ctx, *params))
+		assert.True(t, p.Enabled(ctx, params))
 
 		assert.Empty(t, wrapped.EnabledCalls)
 	})
@@ -213,7 +219,7 @@ func TestLogProcessorNilDownstream(t *testing.T) {
 	ctx := context.Background()
 	r := new(log.Record)
 	r.SetSeverity(api.SeverityTrace1)
-	param := api.EnabledParameters{Severity: api.SeverityTrace1}
+	param := log.EnabledParameters{Severity: api.SeverityTrace1}
 	assert.NotPanics(t, func() {
 		assert.NoError(t, p.OnEmit(ctx, r))
 		assert.False(t, p.Enabled(ctx, param))
@@ -225,12 +231,12 @@ func TestLogProcessorNilDownstream(t *testing.T) {
 func BenchmarkLogProcessor(b *testing.B) {
 	r := new(log.Record)
 	r.SetSeverity(api.SeverityTrace)
-	param := api.EnabledParameters{Severity: api.SeverityTrace}
+	param := log.EnabledParameters{Severity: api.SeverityTrace}
 	ctx := context.Background()
 
 	type combo interface {
 		log.Processor
-		filterProcessor
+		log.FilterProcessor
 	}
 
 	run := func(p combo) func(b *testing.B) {

processors/minsev/severity_test.go

@@ -1,7 +1,7 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
-package minsev // import "go.opentelemetry.io/contrib/processors/minsev"
+package minsev
 
 import (
 	"sync"