Improve service Config types name (#6787)

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

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

exporter/exporter.go

@@ -18,6 +18,8 @@ import (
 	"context"
 	"fmt"
 
+	"go.uber.org/zap"
+
 	"go.opentelemetry.io/collector/component"
 )
 
@@ -170,3 +172,77 @@ func MakeFactoryMap(factories ...Factory) (map[component.Type]Factory, error) {
 	}
 	return fMap, nil
 }
+
+// Builder exporter is a helper struct that given a set of Configs and Factories helps with creating exporters.
+type Builder struct {
+	cfgs      map[component.ID]component.Config
+	factories map[component.Type]Factory
+}
+
+// NewBuilder creates a new exporter.Builder to help with creating components form a set of configs and factories.
+func NewBuilder(cfgs map[component.ID]component.Config, factories map[component.Type]Factory) *Builder {
+	return &Builder{cfgs: cfgs, factories: factories}
+}
+
+// CreateTraces creates a Traces exporter based on the settings and config.
+func (b *Builder) CreateTraces(ctx context.Context, set CreateSettings) (Traces, error) {
+	cfg, existsCfg := b.cfgs[set.ID]
+	if !existsCfg {
+		return nil, fmt.Errorf("exporter %q is not configured", set.ID)
+	}
+
+	f, existsFactory := b.factories[set.ID.Type()]
+	if !existsFactory {
+		return nil, fmt.Errorf("exporter factory not available for: %q", set.ID)
+	}
+
+	logStabilityLevel(set.Logger, f.TracesExporterStability())
+	return f.CreateTracesExporter(ctx, set, cfg)
+}
+
+// CreateMetrics creates a Metrics exporter based on the settings and config.
+func (b *Builder) CreateMetrics(ctx context.Context, set CreateSettings) (Metrics, error) {
+	cfg, existsCfg := b.cfgs[set.ID]
+	if !existsCfg {
+		return nil, fmt.Errorf("exporter %q is not configured", set.ID)
+	}
+
+	f, existsFactory := b.factories[set.ID.Type()]
+	if !existsFactory {
+		return nil, fmt.Errorf("exporter factory not available for: %q", set.ID)
+	}
+
+	logStabilityLevel(set.Logger, f.MetricsExporterStability())
+	return f.CreateMetricsExporter(ctx, set, cfg)
+}
+
+// CreateLogs creates a Logs exporter based on the settings and config.
+func (b *Builder) CreateLogs(ctx context.Context, set CreateSettings) (Logs, error) {
+	cfg, existsCfg := b.cfgs[set.ID]
+	if !existsCfg {
+		return nil, fmt.Errorf("exporter %q is not configured", set.ID)
+	}
+
+	f, existsFactory := b.factories[set.ID.Type()]
+	if !existsFactory {
+		return nil, fmt.Errorf("exporter factory not available for: %q", set.ID)
+	}
+
+	logStabilityLevel(set.Logger, f.LogsExporterStability())
+	return f.CreateLogsExporter(ctx, set, cfg)
+}
+
+func (b *Builder) Factory(componentType component.Type) component.Factory {
+	return b.factories[componentType]
+}
+
+// logStabilityLevel logs the stability level of a component. The log level is set to info for
+// undefined, unmaintained, deprecated and development. The log level is set to debug
+// for alpha, beta and stable.
+func logStabilityLevel(logger *zap.Logger, sl component.StabilityLevel) {
+	if sl >= component.StabilityLevelAlpha {
+		logger.Debug(sl.LogMessage())
+	} else {
+		logger.Info(sl.LogMessage())
+	}
+}

exporter/exportertest/nop_exporter.go

@@ -20,6 +20,8 @@ import (
 	"go.opentelemetry.io/collector/exporter"
 )
 
+const typeStr = "nop"
+
 // NewNopCreateSettings returns a new nop settings for Create*Exporter functions.
 func NewNopCreateSettings() exporter.CreateSettings {
 	return exporter.CreateSettings{
@@ -30,3 +32,11 @@ func NewNopCreateSettings() exporter.CreateSettings {
 
 // NewNopFactory returns an exporter.Factory that constructs nop exporters.
 var NewNopFactory = componenttest.NewNopExporterFactory //nolint:staticcheck
+
+// NewNopBuilder returns a exporter.Builder that constructs nop receivers.
+func NewNopBuilder() *exporter.Builder {
+	nopFactory := NewNopFactory()
+	return exporter.NewBuilder(
+		map[component.ID]component.Config{component.NewID(typeStr): nopFactory.CreateDefaultConfig()},
+		map[component.Type]exporter.Factory{typeStr: nopFactory})
+}

exporter/exportertest/nop_exporter_test.go

@@ -53,3 +53,31 @@ func TestNewNopFactory(t *testing.T) {
 	assert.NoError(t, logs.ConsumeLogs(context.Background(), plog.NewLogs()))
 	assert.NoError(t, logs.Shutdown(context.Background()))
 }
+
+func TestNewNopBuilder(t *testing.T) {
+	builder := NewNopBuilder()
+	require.NotNil(t, builder)
+
+	factory := NewNopFactory()
+	cfg := factory.CreateDefaultConfig()
+	set := NewNopCreateSettings()
+	set.ID = component.NewID(typeStr)
+
+	traces, err := factory.CreateTracesExporter(context.Background(), set, cfg)
+	require.NoError(t, err)
+	bTraces, err := builder.CreateTraces(context.Background(), set)
+	require.NoError(t, err)
+	assert.IsType(t, traces, bTraces)
+
+	metrics, err := factory.CreateMetricsExporter(context.Background(), set, cfg)
+	require.NoError(t, err)
+	bMetrics, err := builder.CreateMetrics(context.Background(), set)
+	require.NoError(t, err)
+	assert.IsType(t, metrics, bMetrics)
+
+	logs, err := factory.CreateLogsExporter(context.Background(), set, cfg)
+	require.NoError(t, err)
+	bLogs, err := builder.CreateLogs(context.Background(), set)
+	require.NoError(t, err)
+	assert.IsType(t, logs, bLogs)
+}

extension/extension.go

@@ -106,3 +106,39 @@ func MakeFactoryMap(factories ...Factory) (map[component.Type]Factory, error) {
 	}
 	return fMap, nil
 }
+
+// Builder extension is a helper struct that given a set of Configs and Factories helps with creating extensions.
+type Builder struct {
+	cfgs      map[component.ID]component.Config
+	factories map[component.Type]Factory
+}
+
+// NewBuilder creates a new extension.Builder to help with creating components form a set of configs and factories.
+func NewBuilder(cfgs map[component.ID]component.Config, factories map[component.Type]Factory) *Builder {
+	return &Builder{cfgs: cfgs, factories: factories}
+}
+
+// Create creates an extension based on the settings and configs available.
+func (b *Builder) Create(ctx context.Context, set CreateSettings) (Extension, error) {
+	cfg, existsCfg := b.cfgs[set.ID]
+	if !existsCfg {
+		return nil, fmt.Errorf("extension %q is not configured", set.ID)
+	}
+
+	f, existsFactory := b.factories[set.ID.Type()]
+	if !existsFactory {
+		return nil, fmt.Errorf("extension factory not available for: %q", set.ID)
+	}
+
+	sl := f.ExtensionStability()
+	if sl >= component.StabilityLevelAlpha {
+		set.Logger.Debug(sl.LogMessage())
+	} else {
+		set.Logger.Info(sl.LogMessage())
+	}
+	return f.CreateExtension(ctx, set, cfg)
+}
+
+func (b *Builder) Factory(componentType component.Type) component.Factory {
+	return b.factories[componentType]
+}

extension/extensiontest/nop_extension.go

@@ -20,6 +20,8 @@ import (
 	"go.opentelemetry.io/collector/extension"
 )
 
+const typeStr = "nop"
+
 // NewNopCreateSettings returns a new nop settings for extension.Factory Create* functions.
 func NewNopCreateSettings() extension.CreateSettings {
 	return extension.CreateSettings{
@@ -30,3 +32,11 @@ func NewNopCreateSettings() extension.CreateSettings {
 
 // NewNopFactory returns an extension.Factory that constructs nop extensions.
 var NewNopFactory = componenttest.NewNopExtensionFactory //nolint:staticcheck
+
+// NewNopBuilder returns a extension.Builder that constructs nop receivers.
+func NewNopBuilder() *extension.Builder {
+	nopFactory := NewNopFactory()
+	return extension.NewBuilder(
+		map[component.ID]component.Config{component.NewID(typeStr): nopFactory.CreateDefaultConfig()},
+		map[component.Type]extension.Factory{typeStr: nopFactory})
+}

extension/extensiontest/nop_extension_test.go

@@ -37,3 +37,19 @@ func TestNewNopFactory(t *testing.T) {
 	assert.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost()))
 	assert.NoError(t, traces.Shutdown(context.Background()))
 }
+
+func TestNewNopBuilder(t *testing.T) {
+	builder := NewNopBuilder()
+	require.NotNil(t, builder)
+
+	factory := NewNopFactory()
+	cfg := factory.CreateDefaultConfig()
+	set := NewNopCreateSettings()
+	set.ID = component.NewID(typeStr)
+
+	ext, err := factory.CreateExtension(context.Background(), set, cfg)
+	require.NoError(t, err)
+	bExt, err := builder.Create(context.Background(), set)
+	require.NoError(t, err)
+	assert.IsType(t, ext, bExt)
+}

otelcol/collector.go

@@ -30,6 +30,7 @@ import (
 
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/otelcol/internal/grpclog"
+	"go.opentelemetry.io/collector/receiver"
 	"go.opentelemetry.io/collector/service"
 )
 
@@ -158,8 +159,7 @@ func (col *Collector) setupConfigurationComponents(ctx context.Context) error {
 
 	col.service, err = service.New(ctx, service.Settings{
 		BuildInfo:          col.set.BuildInfo,
-		ReceiverFactories:  col.set.Factories.Receivers,
-		ReceiverConfigs:    cfg.Receivers,
+		Receivers:          receiver.NewBuilder(cfg.Receivers, col.set.Factories.Receivers),
 		ProcessorFactories: col.set.Factories.Processors,
 		ProcessorConfigs:   cfg.Processors,
 		ExporterFactories:  col.set.Factories.Exporters,

processor/processor.go

@@ -15,7 +15,13 @@
 package processor // import "go.opentelemetry.io/collector/processor"
 
 import (
+	"context"
+	"fmt"
+
+	"go.uber.org/zap"
+
 	"go.opentelemetry.io/collector/component"
+	"go.opentelemetry.io/collector/consumer"
 )
 
 // Traces is a processor that can consume traces.
@@ -63,3 +69,77 @@ var NewFactory = component.NewProcessorFactory //nolint:staticcheck
 // MakeFactoryMap takes a list of factories and returns a map with Factory type as keys.
 // It returns a non-nil error when there are factories with duplicate type.
 var MakeFactoryMap = component.MakeProcessorFactoryMap //nolint:staticcheck
+
+// Builder processor is a helper struct that given a set of Configs and Factories helps with creating processors.
+type Builder struct {
+	cfgs      map[component.ID]component.Config
+	factories map[component.Type]Factory
+}
+
+// NewBuilder creates a new processor.Builder to help with creating components form a set of configs and factories.
+func NewBuilder(cfgs map[component.ID]component.Config, factories map[component.Type]Factory) *Builder {
+	return &Builder{cfgs: cfgs, factories: factories}
+}
+
+// CreateTraces creates a Traces processor based on the settings and config.
+func (b *Builder) CreateTraces(ctx context.Context, set CreateSettings, next consumer.Traces) (Traces, error) {
+	cfg, existsCfg := b.cfgs[set.ID]
+	if !existsCfg {
+		return nil, fmt.Errorf("processor %q is not configured", set.ID)
+	}
+
+	f, existsFactory := b.factories[set.ID.Type()]
+	if !existsFactory {
+		return nil, fmt.Errorf("processor factory not available for: %q", set.ID)
+	}
+
+	logStabilityLevel(set.Logger, f.TracesProcessorStability())
+	return f.CreateTracesProcessor(ctx, set, cfg, next)
+}
+
+// CreateMetrics creates a Metrics processor based on the settings and config.
+func (b *Builder) CreateMetrics(ctx context.Context, set CreateSettings, next consumer.Metrics) (Metrics, error) {
+	cfg, existsCfg := b.cfgs[set.ID]
+	if !existsCfg {
+		return nil, fmt.Errorf("processor %q is not configured", set.ID)
+	}
+
+	f, existsFactory := b.factories[set.ID.Type()]
+	if !existsFactory {
+		return nil, fmt.Errorf("processor factory not available for: %q", set.ID)
+	}
+
+	logStabilityLevel(set.Logger, f.MetricsProcessorStability())
+	return f.CreateMetricsProcessor(ctx, set, cfg, next)
+}
+
+// CreateLogs creates a Logs processor based on the settings and config.
+func (b *Builder) CreateLogs(ctx context.Context, set CreateSettings, next consumer.Logs) (Logs, error) {
+	cfg, existsCfg := b.cfgs[set.ID]
+	if !existsCfg {
+		return nil, fmt.Errorf("processor %q is not configured", set.ID)
+	}
+
+	f, existsFactory := b.factories[set.ID.Type()]
+	if !existsFactory {
+		return nil, fmt.Errorf("processor factory not available for: %q", set.ID)
+	}
+
+	logStabilityLevel(set.Logger, f.LogsProcessorStability())
+	return f.CreateLogsProcessor(ctx, set, cfg, next)
+}
+
+func (b *Builder) Factory(componentType component.Type) component.Factory {
+	return b.factories[componentType]
+}
+
+// logStabilityLevel logs the stability level of a component. The log level is set to info for
+// undefined, unmaintained, deprecated and development. The log level is set to debug
+// for alpha, beta and stable.
+func logStabilityLevel(logger *zap.Logger, sl component.StabilityLevel) {
+	if sl >= component.StabilityLevelAlpha {
+		logger.Debug(sl.LogMessage())
+	} else {
+		logger.Info(sl.LogMessage())
+	}
+}

processor/processortest/nop_processor.go

@@ -15,11 +15,23 @@
 package processortest // import "go.opentelemetry.io/collector/processor/processortest"
 
 import (
+	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/component/componenttest"
+	"go.opentelemetry.io/collector/processor"
 )
 
+const typeStr = "nop"
+
 // NewNopCreateSettings returns a new nop settings for Create* functions.
 var NewNopCreateSettings = componenttest.NewNopProcessorCreateSettings //nolint:staticcheck
 
 // NewNopFactory returns a component.ProcessorFactory that constructs nop processors.
 var NewNopFactory = componenttest.NewNopProcessorFactory //nolint:staticcheck
+
+// NewNopBuilder returns a processor.Builder that constructs nop receivers.
+func NewNopBuilder() *processor.Builder {
+	nopFactory := NewNopFactory()
+	return processor.NewBuilder(
+		map[component.ID]component.Config{component.NewID(typeStr): nopFactory.CreateDefaultConfig()},
+		map[component.Type]processor.Factory{typeStr: nopFactory})
+}

processor/processortest/nop_processor_test.go

@@ -58,3 +58,31 @@ func TestNewNopFactory(t *testing.T) {
 	assert.NoError(t, logs.ConsumeLogs(context.Background(), plog.NewLogs()))
 	assert.NoError(t, logs.Shutdown(context.Background()))
 }
+
+func TestNewNopBuilder(t *testing.T) {
+	builder := NewNopBuilder()
+	require.NotNil(t, builder)
+
+	factory := NewNopFactory()
+	cfg := factory.CreateDefaultConfig()
+	set := NewNopCreateSettings()
+	set.ID = component.NewID(typeStr)
+
+	traces, err := factory.CreateTracesProcessor(context.Background(), set, cfg, consumertest.NewNop())
+	require.NoError(t, err)
+	bTraces, err := builder.CreateTraces(context.Background(), set, consumertest.NewNop())
+	require.NoError(t, err)
+	assert.IsType(t, traces, bTraces)
+
+	metrics, err := factory.CreateMetricsProcessor(context.Background(), set, cfg, consumertest.NewNop())
+	require.NoError(t, err)
+	bMetrics, err := builder.CreateMetrics(context.Background(), set, consumertest.NewNop())
+	require.NoError(t, err)
+	assert.IsType(t, metrics, bMetrics)
+
+	logs, err := factory.CreateLogsProcessor(context.Background(), set, cfg, consumertest.NewNop())
+	require.NoError(t, err)
+	bLogs, err := builder.CreateLogs(context.Background(), set, consumertest.NewNop())
+	require.NoError(t, err)
+	assert.IsType(t, logs, bLogs)
+}