Move everything from receiverhelper to component.

Updates open-telemetry#4681

Signed-off-by: Bogdan Drutu <bogdandrutu@gmail.com>

CHANGELOG.md

@@ -12,6 +12,12 @@
   - Deprecated `extensionhelper.CreateDefaultConfig` in favour of `component.ExtensionDefaultConfigFunc`
   - Deprecated `extensionhelper.CreateServiceExtension` in favour of `component.CreateExtensionFunc`
   - Deprecated `extensionhelper.NewFactory` in favour of `component.NewExtensionFactory`
+- Move helpers from receiverhelper to component (#4891)
+  - Deprecated `receiverhelper.CreateDefaultConfig` in favour of `component.ReceiverDefaultConfigFunc`
+  - Deprecated `receiverhelper.WithTraces` in favour of `component.WithTracesReceiver`
+  - Deprecated `receiverhelper.WithMetrics` in favour of `component.WithMetricsReceiver`
+  - Deprecated `receiverhelper.WithLogs` in favour of `component.WithLogsReceiver`
+  - Deprecated `receiverhelper.NewFactory` in favour of `component.NewReceiverFactory`
 
 ### 💡 Enhancements 💡
 

component/componenttest/nop_receiver.go

@@ -20,7 +20,6 @@ import (
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/config"
 	"go.opentelemetry.io/collector/consumer"
-	"go.opentelemetry.io/collector/internal/internalinterface"
 )
 
 // NewNopReceiverCreateSettings returns a new nop settings for Create*Receiver functions.
@@ -35,57 +34,31 @@ type nopReceiverConfig struct {
 	config.ReceiverSettings `mapstructure:",squash"` // squash ensures fields are correctly decoded in embedded struct
 }
 
-// nopReceiverFactory is factory for nopReceiver.
-type nopReceiverFactory struct {
-	internalinterface.BaseInternal
-}
-
-var nopReceiverFactoryInstance = &nopReceiverFactory{}
+var nopReceiverFactory = component.NewReceiverFactory(
+	"nop",
+	func() config.Receiver {
+		return &nopReceiverConfig{
+			ReceiverSettings: config.NewReceiverSettings(config.NewComponentID("nop")),
+		}
+	},
+	component.WithTracesReceiver(createTracesReceiver),
+	component.WithMetricsReceiver(createMetricsReceiver),
+	component.WithLogsReceiver(createLogsReceiver))
 
 // NewNopReceiverFactory returns a component.ReceiverFactory that constructs nop receivers.
 func NewNopReceiverFactory() component.ReceiverFactory {
-	return nopReceiverFactoryInstance
-}
-
-// Type gets the type of the Receiver config created by this factory.
-func (f *nopReceiverFactory) Type() config.Type {
-	return config.NewComponentID("nop").Type()
-}
-
-// CreateDefaultConfig creates the default configuration for the Receiver.
-func (f *nopReceiverFactory) CreateDefaultConfig() config.Receiver {
-	return &nopReceiverConfig{
-		ReceiverSettings: config.NewReceiverSettings(config.NewComponentID("nop")),
-	}
+	return nopReceiverFactory
 }
 
-// CreateTracesReceiver implements component.ReceiverFactory interface.
-func (f *nopReceiverFactory) CreateTracesReceiver(
-	_ context.Context,
-	_ component.ReceiverCreateSettings,
-	_ config.Receiver,
-	_ consumer.Traces,
-) (component.TracesReceiver, error) {
+func createTracesReceiver(context.Context, component.ReceiverCreateSettings, config.Receiver, consumer.Traces) (component.TracesReceiver, error) {
 	return nopReceiverInstance, nil
 }
 
-// CreateMetricsReceiver implements component.ReceiverFactory interface.
-func (f *nopReceiverFactory) CreateMetricsReceiver(
-	_ context.Context,
-	_ component.ReceiverCreateSettings,
-	_ config.Receiver,
-	_ consumer.Metrics,
-) (component.MetricsReceiver, error) {
+func createMetricsReceiver(context.Context, component.ReceiverCreateSettings, config.Receiver, consumer.Metrics) (component.MetricsReceiver, error) {
 	return nopReceiverInstance, nil
 }
 
-// CreateLogsReceiver implements component.ReceiverFactory interface.
-func (f *nopReceiverFactory) CreateLogsReceiver(
-	_ context.Context,
-	_ component.ReceiverCreateSettings,
-	_ config.Receiver,
-	_ consumer.Logs,
-) (component.LogsReceiver, error) {
+func createLogsReceiver(context.Context, component.ReceiverCreateSettings, config.Receiver, consumer.Logs) (component.LogsReceiver, error) {
 	return nopReceiverInstance, nil
 }
 

component/receiver.go

@@ -17,8 +17,10 @@ package component // import "go.opentelemetry.io/collector/component"
 import (
 	"context"
 
+	"go.opentelemetry.io/collector/component/componenterror"
 	"go.opentelemetry.io/collector/config"
 	"go.opentelemetry.io/collector/consumer"
+	"go.opentelemetry.io/collector/internal/internalinterface"
 )
 
 // Receiver allows the collector to receive metrics, traces and logs.
@@ -132,3 +134,108 @@ type ReceiverFactory interface {
 	CreateLogsReceiver(ctx context.Context, set ReceiverCreateSettings,
 		cfg config.Receiver, nextConsumer consumer.Logs) (LogsReceiver, error)
 }
+
+// ReceiverFactoryOption apply changes to ReceiverOptions.
+type ReceiverFactoryOption func(o *processorFactory)
+
+// ReceiverCreateDefaultConfigFunc is the equivalent of ReceiverFactory.CreateDefaultConfig()
+type ReceiverCreateDefaultConfigFunc func() config.Receiver
+
+// CreateDefaultConfig implements ExtensionFactory.CreateDefaultConfig()
+func (f ReceiverCreateDefaultConfigFunc) CreateDefaultConfig() config.Receiver {
+	return f()
+}
+
+// CreateTracesReceiverFunc is the equivalent of ReceiverFactory.CreateTracesReceiver()
+type CreateTracesReceiverFunc func(context.Context, ReceiverCreateSettings, config.Receiver, consumer.Traces) (TracesReceiver, error)
+
+// CreateTracesReceiver creates a TracesReceiver based on this config.
+func (f CreateTracesReceiverFunc) CreateTracesReceiver(
+	ctx context.Context,
+	set ReceiverCreateSettings,
+	cfg config.Receiver,
+	nextConsumer consumer.Traces) (TracesReceiver, error) {
+	if f == nil {
+		return nil, componenterror.ErrDataTypeIsNotSupported
+	}
+	return f(ctx, set, cfg, nextConsumer)
+}
+
+// CreateMetricsReceiverFunc is the equivalent of ReceiverFactory.CreateMetricsReceiver()
+type CreateMetricsReceiverFunc func(context.Context, ReceiverCreateSettings, config.Receiver, consumer.Metrics) (MetricsReceiver, error)
+
+// CreateMetricsReceiver creates a MetricsReceiver based on this config.
+func (f CreateMetricsReceiverFunc) CreateMetricsReceiver(
+	ctx context.Context,
+	set ReceiverCreateSettings,
+	cfg config.Receiver,
+	nextConsumer consumer.Metrics,
+) (MetricsReceiver, error) {
+	if f == nil {
+		return nil, componenterror.ErrDataTypeIsNotSupported
+	}
+	return f(ctx, set, cfg, nextConsumer)
+}
+
+// CreateLogsReceiverFunc is the equivalent of ReceiverFactory.CreateLogsReceiver()
+type CreateLogsReceiverFunc func(context.Context, ReceiverCreateSettings, config.Receiver, consumer.Logs) (LogsReceiver, error)
+
+// CreateLogsReceiver creates a LogsReceiver based on this config.
+func (f CreateLogsReceiverFunc) CreateLogsReceiver(
+	ctx context.Context,
+	set ReceiverCreateSettings,
+	cfg config.Receiver,
+	nextConsumer consumer.Logs,
+) (LogsReceiver, error) {
+	if f == nil {
+		return nil, componenterror.ErrDataTypeIsNotSupported
+	}
+	return f(ctx, set, cfg, nextConsumer)
+}
+
+type processorFactory struct {
+	internalinterface.BaseInternal
+	cfgType config.Type
+	ReceiverCreateDefaultConfigFunc
+	CreateTracesReceiverFunc
+	CreateMetricsReceiverFunc
+	CreateLogsReceiverFunc
+}
+
+// WithTracesReceiver overrides the default "error not supported" implementation for CreateTracesReceiver.
+func WithTracesReceiver(createTracesReceiver CreateTracesReceiverFunc) ReceiverFactoryOption {
+	return func(o *processorFactory) {
+		o.CreateTracesReceiverFunc = createTracesReceiver
+	}
+}
+
+// WithMetricsReceiver overrides the default "error not supported" implementation for CreateMetricsReceiver.
+func WithMetricsReceiver(createMetricsReceiver CreateMetricsReceiverFunc) ReceiverFactoryOption {
+	return func(o *processorFactory) {
+		o.CreateMetricsReceiverFunc = createMetricsReceiver
+	}
+}
+
+// WithLogsReceiver overrides the default "error not supported" implementation for CreateLogsReceiver.
+func WithLogsReceiver(createLogsReceiver CreateLogsReceiverFunc) ReceiverFactoryOption {
+	return func(o *processorFactory) {
+		o.CreateLogsReceiverFunc = createLogsReceiver
+	}
+}
+
+// NewReceiverFactory returns a ReceiverFactory.
+func NewReceiverFactory(cfgType config.Type, createDefaultConfig ReceiverCreateDefaultConfigFunc, options ...ReceiverFactoryOption) ReceiverFactory {
+	f := &processorFactory{
+		cfgType:                         cfgType,
+		ReceiverCreateDefaultConfigFunc: createDefaultConfig,
+	}
+	for _, opt := range options {
+		opt(f)
+	}
+	return f
+}
+
+// Type returns the type of the Receiver created by this ReceiverFactory.
+func (f *processorFactory) Type() config.Type {
+	return f.cfgType
+}

component/receiver_test.go

@@ -15,55 +15,101 @@
 package component
 
 import (
+	"context"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 
 	"go.opentelemetry.io/collector/config"
+	"go.opentelemetry.io/collector/consumer"
 )
 
-type TestReceiverFactory struct {
-	ReceiverFactory
-	name config.Type
-}
-
-// Type gets the type of the Receiver config created by this factory.
-func (f *TestReceiverFactory) Type() config.Type {
-	return f.name
-}
+// TODO: Move this TestMakeReceiverFactoryMap to factories_test after #4889 is merged.
 
-func TestBuildReceivers(t *testing.T) {
+func TestMakeReceiverFactoryMap(t *testing.T) {
 	type testCase struct {
-		in  []ReceiverFactory
-		out map[config.Type]ReceiverFactory
+		name string
+		in   []ReceiverFactory
+		out  map[config.Type]ReceiverFactory
 	}
 
+	p1 := NewReceiverFactory("p1", nil)
+	p2 := NewReceiverFactory("p2", nil)
 	testCases := []testCase{
 		{
-			in: []ReceiverFactory{
-				&TestReceiverFactory{name: "e1"},
-				&TestReceiverFactory{name: "e2"},
-			},
+			name: "different names",
+			in:   []ReceiverFactory{p1, p2},
 			out: map[config.Type]ReceiverFactory{
-				"e1": &TestReceiverFactory{name: "e1"},
-				"e2": &TestReceiverFactory{name: "e2"},
+				p1.Type(): p1,
+				p2.Type(): p2,
 			},
 		},
 		{
-			in: []ReceiverFactory{
-				&TestReceiverFactory{name: "e1"},
-				&TestReceiverFactory{name: "e1"},
-			},
+			name: "same name",
+			in:   []ReceiverFactory{p1, p2, NewReceiverFactory("p1", nil)},
 		},
 	}
 
-	for _, c := range testCases {
-		out, err := MakeReceiverFactoryMap(c.in...)
-		if c.out == nil {
-			assert.Error(t, err)
-			continue
-		}
-		assert.NoError(t, err)
-		assert.Equal(t, c.out, out)
+	for i := range testCases {
+		tt := testCases[i]
+		t.Run(tt.name, func(t *testing.T) {
+			out, err := MakeReceiverFactoryMap(tt.in...)
+			if tt.out == nil {
+				assert.Error(t, err)
+				return
+			}
+			assert.NoError(t, err)
+			assert.Equal(t, tt.out, out)
+		})
 	}
 }
+
+func TestNewReceiverFactory(t *testing.T) {
+	const typeStr = "test"
+	defaultCfg := config.NewReceiverSettings(config.NewComponentID(typeStr))
+	factory := NewReceiverFactory(
+		typeStr,
+		func() config.Receiver { return &defaultCfg })
+	assert.EqualValues(t, typeStr, factory.Type())
+	assert.EqualValues(t, &defaultCfg, factory.CreateDefaultConfig())
+	_, err := factory.CreateTracesReceiver(context.Background(), ReceiverCreateSettings{}, &defaultCfg, nil)
+	assert.Error(t, err)
+	_, err = factory.CreateMetricsReceiver(context.Background(), ReceiverCreateSettings{}, &defaultCfg, nil)
+	assert.Error(t, err)
+	_, err = factory.CreateLogsReceiver(context.Background(), ReceiverCreateSettings{}, &defaultCfg, nil)
+	assert.Error(t, err)
+}
+
+func TestNewReceiverFactory_WithOptions(t *testing.T) {
+	const typeStr = "test"
+	defaultCfg := config.NewReceiverSettings(config.NewComponentID(typeStr))
+	factory := NewReceiverFactory(
+		typeStr,
+		func() config.Receiver { return &defaultCfg },
+		WithTracesReceiver(createTracesReceiver),
+		WithMetricsReceiver(createMetricsReceiver),
+		WithLogsReceiver(createLogsReceiver))
+	assert.EqualValues(t, typeStr, factory.Type())
+	assert.EqualValues(t, &defaultCfg, factory.CreateDefaultConfig())
+
+	_, err := factory.CreateTracesReceiver(context.Background(), ReceiverCreateSettings{}, &defaultCfg, nil)
+	assert.NoError(t, err)
+
+	_, err = factory.CreateMetricsReceiver(context.Background(), ReceiverCreateSettings{}, &defaultCfg, nil)
+	assert.NoError(t, err)
+
+	_, err = factory.CreateLogsReceiver(context.Background(), ReceiverCreateSettings{}, &defaultCfg, nil)
+	assert.NoError(t, err)
+}
+
+func createTracesReceiver(context.Context, ReceiverCreateSettings, config.Receiver, consumer.Traces) (TracesReceiver, error) {
+	return nil, nil
+}
+
+func createMetricsReceiver(context.Context, ReceiverCreateSettings, config.Receiver, consumer.Metrics) (MetricsReceiver, error) {
+	return nil, nil
+}
+
+func createLogsReceiver(context.Context, ReceiverCreateSettings, config.Receiver, consumer.Logs) (LogsReceiver, error) {
+	return nil, nil
+}

internal/testcomponents/example_receiver.go

@@ -21,7 +21,6 @@ import (
 	"go.opentelemetry.io/collector/config"
 	"go.opentelemetry.io/collector/config/confignet"
 	"go.opentelemetry.io/collector/consumer"
-	"go.opentelemetry.io/collector/receiver/receiverhelper"
 )
 
 // ExampleReceiver is for testing purposes. We are defining an example config and factory
@@ -36,15 +35,15 @@ type ExampleReceiver struct {
 	ExtraListSetting []string          `mapstructure:"extra_list"`
 }
 
-var receiverType = config.Type("examplereceiver")
+const receiverType = config.Type("examplereceiver")
 
 // ExampleReceiverFactory is factory for ExampleReceiver.
-var ExampleReceiverFactory = receiverhelper.NewFactory(
+var ExampleReceiverFactory = component.NewReceiverFactory(
 	receiverType,
 	createReceiverDefaultConfig,
-	receiverhelper.WithTraces(createTracesReceiver),
-	receiverhelper.WithMetrics(createMetricsReceiver),
-	receiverhelper.WithLogs(createLogsReceiver))
+	component.WithTracesReceiver(createTracesReceiver),
+	component.WithMetricsReceiver(createMetricsReceiver),
+	component.WithLogsReceiver(createLogsReceiver))
 
 func createReceiverDefaultConfig() config.Receiver {
 	return &ExampleReceiver{

receiver/otlpreceiver/factory.go

@@ -24,7 +24,6 @@ import (
 	"go.opentelemetry.io/collector/config/confignet"
 	"go.opentelemetry.io/collector/consumer"
 	"go.opentelemetry.io/collector/internal/sharedcomponent"
-	"go.opentelemetry.io/collector/receiver/receiverhelper"
 )
 
 const (
@@ -37,12 +36,12 @@ const (
 
 // NewFactory creates a new OTLP receiver factory.
 func NewFactory() component.ReceiverFactory {
-	return receiverhelper.NewFactory(
+	return component.NewReceiverFactory(
 		typeStr,
 		createDefaultConfig,
-		receiverhelper.WithTraces(createTracesReceiver),
-		receiverhelper.WithMetrics(createMetricsReceiver),
-		receiverhelper.WithLogs(createLogReceiver))
+		component.WithTracesReceiver(createTracesReceiver),
+		component.WithMetricsReceiver(createMetricsReceiver),
+		component.WithLogsReceiver(createLogReceiver))
 }
 
 // createDefaultConfig creates the default configuration for receiver.