[reflect] sdk/log/xlog: Add FilterProcessor and EnabledParameters

CHANGELOG.md

@@ -25,6 +25,13 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - The `go.opentelemetry.io/otel/semconv/v1.30.0` package.
   The package contains semantic conventions from the `v1.30.0` version of the OpenTelemetry Semantic Conventions.
   See the [migration documentation](./semconv/v1.30.0/MIGRATION.md) for information on how to upgrade from `go.opentelemetry.io/otel/semconv/v1.28.0`(#6240)
+- Make the initial release of `go.opentelemetry.io/otel/sdk/log/xlog`.
+  This new module contains experimental features of the OpenTelemetry Logs SDK.
+  It replaces `go.opentelemetry.io/otel/sdk/log/internal/x`.
+  This module is unstable and breaking changes may be introduced.
+  See our [versioning policy](VERSIONING.md) for more information about these stability guarantees. (#6286)
+- Add `FilterProcessor` and `EnabledParameters` in `go.opentelemetry.io/otel/sdk/log/xlog` .
+  Compared to previous version it additionally gives the possibility to filter by resource and instrumentation scope. (#6286)
 
 ### Changed
 

exporters/otlp/otlplog/otlploggrpc/go.mod

@@ -44,3 +44,5 @@ replace go.opentelemetry.io/otel/log => ../../../../log
 replace go.opentelemetry.io/otel/trace => ../../../../trace
 
 replace go.opentelemetry.io/otel/metric => ../../../../metric
+
+replace go.opentelemetry.io/otel/sdk/log/xlog => ../../../../sdk/log/xlog

exporters/otlp/otlplog/otlploghttp/go.mod

@@ -44,3 +44,5 @@ replace go.opentelemetry.io/otel/sdk => ../../../../sdk
 replace go.opentelemetry.io/otel/metric => ../../../../metric
 
 replace go.opentelemetry.io/otel/log => ../../../../log
+
+replace go.opentelemetry.io/otel/sdk/log/xlog => ../../../../sdk/log/xlog

exporters/stdout/stdoutlog/go.mod

@@ -34,3 +34,5 @@ replace go.opentelemetry.io/otel/trace => ../../../trace
 replace go.opentelemetry.io/otel/sdk => ../../../sdk
 
 replace go.opentelemetry.io/otel/metric => ../../../metric
+
+replace go.opentelemetry.io/otel/sdk/log/xlog => ../../../sdk/log/xlog

log/logger.go

@@ -33,9 +33,13 @@ type Logger interface {
 	// Enabled returns whether the Logger emits for the given context and
 	// param.
 	//
-	// The passed param is likely to be a partial record with only the
-	// bridge-relevant information being provided (e.g a param with only the
-	// Severity set). If a Logger needs more information than is provided, it
+	// This is useful for users that want to know if a [Record]
+	// will be processed or dropped before they perform complex operations to
+	// construct the [Record].
+	//
+	// The passed param is likely to be a partial record information being
+	// provided (e.g a param with only the Severity set).
+	// If a Logger 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 Logger will emit for the
@@ -46,7 +50,7 @@ type Logger interface {
 	// exist (e.g. performance, correctness).
 	//
 	// The param should not be held by the implementation. A copy should be
-	// made if the record needs to be held after the call returns.
+	// made if the param needs to be held after the call returns.
 	//
 	// Implementations of this method need to be safe for a user to call
 	// concurrently.

sdk/log/doc.go

@@ -33,7 +33,7 @@ at a single endpoint their origin is decipherable.
 See [go.opentelemetry.io/otel/log] for more information about
 the OpenTelemetry Logs Bridge API.
 
-See [go.opentelemetry.io/otel/sdk/log/internal/x] for information about the
+See [go.opentelemetry.io/otel/sdk/log/xlog] for information about the
 experimental features.
 */
 package log // import "go.opentelemetry.io/otel/sdk/log"

sdk/log/example_test.go

@@ -12,6 +12,7 @@ import (
 	logapi "go.opentelemetry.io/otel/log"
 	"go.opentelemetry.io/otel/log/global"
 	"go.opentelemetry.io/otel/sdk/log"
+	"go.opentelemetry.io/otel/sdk/log/xlog"
 )
 
 // Initialize OpenTelemetry Logs SDK and setup logging using a log bridge.
@@ -52,6 +53,7 @@ func Example() {
 }
 
 // Use a processor that filters out records based on the provided context.
+// It also demonstrates the use of experimental [xlog.FilterProcessor].
 func ExampleProcessor_filtering() {
 	// Existing processor that emits telemetry.
 	var processor log.Processor = log.NewBatchProcessor(nil)
@@ -84,14 +86,12 @@ type ContextFilterProcessor struct {
 	log.Processor
 
 	lazyFilter sync.Once
-	// Use the experimental FilterProcessor interface
-	// (go.opentelemetry.io/otel/sdk/log/internal/x).
-	filter filter
+	// Support the experimental FilterProcessor interface for the embedded processor.
+	filter xlog.FilterProcessor
 }
 
-type filter interface {
-	Enabled(ctx context.Context, param logapi.EnabledParameters) bool
-}
+// Compile time check.
+var _ xlog.FilterProcessor = (*ContextFilterProcessor)(nil)
 
 func (p *ContextFilterProcessor) OnEmit(ctx context.Context, record *log.Record) error {
 	if ignoreLogs(ctx) {
@@ -100,9 +100,9 @@ func (p *ContextFilterProcessor) OnEmit(ctx context.Context, record *log.Record)
 	return p.Processor.OnEmit(ctx, record)
 }
 
-func (p *ContextFilterProcessor) Enabled(ctx context.Context, param logapi.EnabledParameters) bool {
+func (p *ContextFilterProcessor) Enabled(ctx context.Context, param xlog.EnabledParameters) bool {
 	p.lazyFilter.Do(func() {
-		if f, ok := p.Processor.(filter); ok {
+		if f, ok := p.Processor.(xlog.FilterProcessor); ok {
 			p.filter = f
 		}
 	})

sdk/log/filter_processor.go

@@ -0,0 +1,88 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package log // import "go.opentelemetry.io/otel/sdk/log"
+
+import (
+	"context"
+	"reflect"
+
+	"go.opentelemetry.io/otel/log"
+	"go.opentelemetry.io/otel/sdk/instrumentation"
+	"go.opentelemetry.io/otel/sdk/resource"
+)
+
+// filterProcessor uses reflect to support [go.opentelemetry.io/otel/sdk/log/xlog.FilterProcessor]
+// via duck typing.
+type filterProcessor struct {
+	enabledFn reflect.Value
+	paramType reflect.Type
+}
+
+func asFilterProccessor(p any) (filterProcessor, bool) {
+	fp := reflect.ValueOf(p)
+	m := fp.MethodByName("Enabled")
+	if m == (reflect.Value{}) {
+		// No Enabled method.
+		return filterProcessor{}, false
+	}
+	mty := m.Type()
+	if mty.NumOut() != 1 {
+		// Should return one output parameter.
+		return filterProcessor{}, false
+	}
+	if reflect.Bool != mty.Out(0).Kind() {
+		// Should return bool.
+		return filterProcessor{}, false
+	}
+	if mty.NumIn() != 2 {
+		// Should have two input parameters.
+		return filterProcessor{}, false
+	}
+	if mty.In(0) != reflect.TypeFor[context.Context]() {
+		// Should have context.Context as first input parameter.
+		return filterProcessor{}, false
+	}
+	// Duck typing of EnabledParameters
+	pt := mty.In(1)
+	if res, ok := pt.FieldByName("Resource"); !ok || res.Type != reflect.TypeFor[resource.Resource]() {
+		// The second parameter should have Resource resource.Resource field.
+		return filterProcessor{}, false
+	}
+	if res, ok := pt.FieldByName("InstrumentationScope"); !ok || res.Type != reflect.TypeFor[instrumentation.Scope]() {
+		// The second parameter should have InstrumentationScope instrumentation.Scope field.
+		return filterProcessor{}, false
+	}
+	if res, ok := pt.FieldByName("Severity"); !ok || res.Type != reflect.TypeFor[log.Severity]() {
+		// The second parameter should have Severity log.Severity field.
+		return filterProcessor{}, false
+	}
+
+	return filterProcessor{
+		enabledFn: m,
+		paramType: pt,
+	}, true
+}
+
+func (f filterProcessor) Enabled(ctx context.Context, param enabledParameters) bool {
+	p := reflect.New(f.paramType).Elem()
+	p.FieldByName("Resource").Set(reflect.ValueOf(param.Resource))
+	p.FieldByName("InstrumentationScope").Set(reflect.ValueOf(param.InstrumentationScope))
+	p.FieldByName("Severity").Set(reflect.ValueOf(param.Severity))
+
+	ctxV := reflect.ValueOf(ctx)
+	if ctxV == (reflect.Value{}) {
+		// In order to not get panic: reflect: Call using zero Value argument.
+		ctxV = reflect.Zero(reflect.TypeFor[context.Context]())
+	}
+
+	ret := f.enabledFn.Call([]reflect.Value{ctxV, p})
+	return ret[0].Bool()
+}
+
+// enabledParameters represents payload for Enabled method.
+type enabledParameters struct {
+	Resource             resource.Resource
+	InstrumentationScope instrumentation.Scope
+	Severity             log.Severity
+}

sdk/log/go.mod

@@ -10,6 +10,7 @@ require (
 	go.opentelemetry.io/otel v1.34.0
 	go.opentelemetry.io/otel/log v0.10.0
 	go.opentelemetry.io/otel/sdk v1.34.0
+	go.opentelemetry.io/otel/sdk/log/xlog v0.0.0-00010101000000-000000000000
 	go.opentelemetry.io/otel/trace v1.34.0
 )
 
@@ -29,6 +30,8 @@ replace go.opentelemetry.io/otel/trace => ../../trace
 
 replace go.opentelemetry.io/otel/sdk => ../
 
+replace go.opentelemetry.io/otel/sdk/log/xlog => ./xlog
+
 replace go.opentelemetry.io/otel/log => ../../log
 
 replace go.opentelemetry.io/otel => ../..

sdk/log/logger.go

@@ -11,7 +11,6 @@ import (
 	"go.opentelemetry.io/otel/log"
 	"go.opentelemetry.io/otel/log/embedded"
 	"go.opentelemetry.io/otel/sdk/instrumentation"
-	"go.opentelemetry.io/otel/sdk/log/internal/x"
 	"go.opentelemetry.io/otel/trace"
 )
 
@@ -50,14 +49,22 @@ func (l *logger) Emit(ctx context.Context, r log.Record) {
 // 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 {
-	// If there are more Processors than FilterProcessors we cannot be sure
-	// that all Processors will drop the record. Therefore, return true.
+	p := enabledParameters{
+		Resource:             *l.provider.resource,
+		InstrumentationScope: l.instrumentationScope,
+		Severity:             param.Severity,
+	}
+
+	// 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, param, l.provider.fltrProcessors)
+	return len(l.provider.processors) > len(l.provider.fltrProcessors) || anyEnabled(ctx, p, l.provider.fltrProcessors)
 }
 
-func anyEnabled(ctx context.Context, param log.EnabledParameters, fltrs []x.FilterProcessor) bool {
+func anyEnabled(ctx context.Context, param enabledParameters, fltrs []filterProcessor) bool {
 	for _, f := range fltrs {
 		if f.Enabled(ctx, param) {
 			// At least one Processor will process the Record.