Ensure loadbalancing child exporters use the OTLP type so backend creation succeeds (open-telemetry#43960)

#### Description

<!-- Issue number (e.g. open-telemetry#1234) or full URL to issue, if applicable. -->
#### Link to tracking issue
Fixes open-telemetry#43950

<!--Describe what testing was performed and which tests were added.-->
#### Testing
Tested with config:
```yaml
exporters:
  loadbalancing:
    retry_on_failure:
      enabled: true
      initial_interval: 5s
      max_interval: 30s
      max_elapsed_time: 60s
    sending_queue:
      enabled: true
      num_consumers: 10
      queue_size: 10000
      block_on_overflow: false
      sizer: items
    protocol:
      otlp:
        timeout: 1s
        tls:
          insecure: true
    resolver:
      dns:
        hostname: otel-receivers.test
        port: '4317'
        interval: 5s
        timeout: 1s
```

Signed-off-by: Israel Blancas <[email protected]>

Author: iblancasa

.chloggen/43950.yaml

@@ -0,0 +1,27 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: bug_fix
+
+# The name of the component, or a single word describing the area of concern, (e.g. receiver/filelog)
+component: exporter/loadbalancing
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Ensure loadbalancing child exporters use the OTLP type so backend creation succeeds
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [43950]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
+
+# If your change doesn't affect end users or the exported elements of any package,
+# you should instead start your pull request title with [chore] or use the "Skip Changelog" label.
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: [user]

exporter/loadbalancingexporter/factory.go

@@ -13,6 +13,8 @@ import (
 	"go.opentelemetry.io/collector/exporter"
 	"go.opentelemetry.io/collector/exporter/exporterhelper"
 	"go.opentelemetry.io/collector/exporter/otlpexporter"
+	metricnoop "go.opentelemetry.io/otel/metric/noop"
+	tracenoop "go.opentelemetry.io/otel/trace/noop"
 	"go.uber.org/zap"
 
 	"github.com/open-telemetry/opentelemetry-collector-contrib/exporter/loadbalancingexporter/internal/metadata"
@@ -54,8 +56,18 @@ func buildExporterConfig(cfg *Config, endpoint string) otlpexporter.Config {
 	return oCfg
 }
 
-func buildExporterSettings(params exporter.Settings, endpoint string) exporter.Settings {
+func buildExporterSettings(typ component.Type, params exporter.Settings, endpoint string) exporter.Settings {
+	if name := params.ID.Name(); name != "" {
+		params.ID = component.NewIDWithName(typ, name)
+	} else {
+		params.ID = component.NewID(typ)
+	}
+	telemetry := params.TelemetrySettings
+	telemetry.MeterProvider = metricnoop.NewMeterProvider()
+	telemetry.TracerProvider = tracenoop.NewTracerProvider()
 	params.Logger = params.Logger.With(zap.String(zapEndpointKey, endpoint))
+	telemetry.Logger = params.Logger
+	params.TelemetrySettings = telemetry
 	return params
 }
 

exporter/loadbalancingexporter/factory_test.go

@@ -4,18 +4,22 @@
 package loadbalancingexporter
 
 import (
+	"context"
 	"path/filepath"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.opentelemetry.io/collector/component"
+	"go.opentelemetry.io/collector/component/componenttest"
 	"go.opentelemetry.io/collector/config/configoptional"
 	"go.opentelemetry.io/collector/config/configretry"
 	"go.opentelemetry.io/collector/exporter/exporterhelper"
 	"go.opentelemetry.io/collector/exporter/exportertest"
 	"go.opentelemetry.io/collector/exporter/otlpexporter"
 	"go.opentelemetry.io/collector/otelcol/otelcoltest"
+	metricnoop "go.opentelemetry.io/otel/metric/noop"
+	tracenoop "go.opentelemetry.io/otel/trace/noop"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zaptest/observer"
 
@@ -98,24 +102,75 @@ func TestBuildExporterConfig(t *testing.T) {
 }
 
 func TestBuildExporterSettings(t *testing.T) {
-	// prepare
-	creationParams := exportertest.NewNopSettings(metadata.Type)
-	testEndpoint := "the-endpoint"
-	observedZapCore, observedLogs := observer.New(zap.InfoLevel)
-	creationParams.Logger = zap.New(observedZapCore)
-
-	// test
-	exporterParams := buildExporterSettings(creationParams, testEndpoint)
-	exporterParams.Logger.Info("test")
-
-	assert.Equal(t, creationParams.ID, exporterParams.ID)
+	otlpType := otlpexporter.NewFactory().Type()
+
+	t.Run("without exporter name", func(t *testing.T) {
+		ctx := context.Background() //nolint:usetesting // Context must outlive test for cleanup
+		creationParams := exportertest.NewNopSettings(metadata.Type)
+		creationParams.ID = component.NewID(metadata.Type)
+		telemetry := componenttest.NewTelemetry()
+		t.Cleanup(func() {
+			require.NoError(t, telemetry.Shutdown(ctx))
+		})
+		creationParams.TelemetrySettings = telemetry.NewTelemetrySettings()
+		originalTelemetry := creationParams.TelemetrySettings
+		testEndpoint := "the-endpoint"
+		observedZapCore, observedLogs := observer.New(zap.InfoLevel)
+		creationParams.Logger = zap.New(observedZapCore)
+		originalLogger := creationParams.Logger
+
+		exporterParams := buildExporterSettings(otlpType, creationParams, testEndpoint)
+		exporterParams.Logger.Info("test")
+
+		assert.Equal(t, component.NewID(otlpType), exporterParams.ID)
+		assert.IsType(t, metricnoop.NewMeterProvider(), exporterParams.MeterProvider)
+		assert.IsType(t, tracenoop.NewTracerProvider(), exporterParams.TracerProvider)
+
+		assert.Same(t, originalTelemetry.MeterProvider, creationParams.MeterProvider)
+		assert.Same(t, originalTelemetry.TracerProvider, creationParams.TracerProvider)
+		assert.Same(t, originalLogger, creationParams.Logger)
+
+		allLogs := observedLogs.All()
+		require.Equal(t, 1, observedLogs.Len())
+		assert.Contains(t,
+			allLogs[0].Context,
+			zap.String(zapEndpointKey, testEndpoint),
+		)
+	})
 
-	allLogs := observedLogs.All()
-	require.Equal(t, 1, observedLogs.Len())
-	assert.Contains(t,
-		allLogs[0].Context,
-		zap.String(zapEndpointKey, testEndpoint),
-	)
+	t.Run("with exporter name", func(t *testing.T) {
+		ctx := context.Background() //nolint:usetesting // Context must outlive test for cleanup
+		creationParams := exportertest.NewNopSettings(metadata.Type)
+		creationParams.ID = component.NewIDWithName(metadata.Type, "custom")
+		telemetry := componenttest.NewTelemetry()
+		t.Cleanup(func() {
+			require.NoError(t, telemetry.Shutdown(ctx))
+		})
+		creationParams.TelemetrySettings = telemetry.NewTelemetrySettings()
+		originalTelemetry := creationParams.TelemetrySettings
+		testEndpoint := "the-endpoint"
+		observedZapCore, observedLogs := observer.New(zap.InfoLevel)
+		creationParams.Logger = zap.New(observedZapCore)
+		originalLogger := creationParams.Logger
+
+		exporterParams := buildExporterSettings(otlpType, creationParams, testEndpoint)
+		exporterParams.Logger.Info("test")
+
+		assert.Equal(t, component.NewIDWithName(otlpType, "custom"), exporterParams.ID)
+		assert.IsType(t, metricnoop.NewMeterProvider(), exporterParams.MeterProvider)
+		assert.IsType(t, tracenoop.NewTracerProvider(), exporterParams.TracerProvider)
+
+		assert.Same(t, originalTelemetry.MeterProvider, creationParams.MeterProvider)
+		assert.Same(t, originalTelemetry.TracerProvider, creationParams.TracerProvider)
+		assert.Same(t, originalLogger, creationParams.Logger)
+
+		allLogs := observedLogs.All()
+		require.Equal(t, 1, observedLogs.Len())
+		assert.Contains(t,
+			allLogs[0].Context,
+			zap.String(zapEndpointKey, testEndpoint),
+		)
+	})
 }
 
 func TestWrappedExporterHasEndpointAttribute(t *testing.T) {

exporter/loadbalancingexporter/log_exporter.go

@@ -43,7 +43,7 @@ func newLogsExporter(params exporter.Settings, cfg component.Config) (*logExport
 	exporterFactory := otlpexporter.NewFactory()
 	cfFunc := func(ctx context.Context, endpoint string) (component.Component, error) {
 		oCfg := buildExporterConfig(cfg.(*Config), endpoint)
-		oParams := buildExporterSettings(params, endpoint)
+		oParams := buildExporterSettings(exporterFactory.Type(), params, endpoint)
 
 		return exporterFactory.CreateLogs(ctx, oParams, &oCfg)
 	}

exporter/loadbalancingexporter/log_exporter_test.go

@@ -21,9 +21,15 @@ import (
 	"go.opentelemetry.io/collector/consumer"
 	"go.opentelemetry.io/collector/consumer/consumertest"
 	"go.opentelemetry.io/collector/exporter"
+	"go.opentelemetry.io/collector/exporter/exporterhelper"
 	"go.opentelemetry.io/collector/exporter/exportertest"
+	"go.opentelemetry.io/collector/exporter/otlpexporter"
 	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.opentelemetry.io/collector/pdata/plog"
+	"go.opentelemetry.io/otel/attribute"
+	metricnoop "go.opentelemetry.io/otel/metric/noop"
+	"go.opentelemetry.io/otel/sdk/metric/metricdata"
+	tracenoop "go.opentelemetry.io/otel/trace/noop"
 	"go.uber.org/zap"
 
 	"github.com/open-telemetry/opentelemetry-collector-contrib/exporter/loadbalancingexporter/internal/metadata"
@@ -155,6 +161,95 @@ func TestConsumeLogs(t *testing.T) {
 	assert.NoError(t, res)
 }
 
+func TestConsumeLogsEmitsOnlyParentExporterMetrics(t *testing.T) {
+	ctx := t.Context()
+	shutdownCtx := context.Background() //nolint:usetesting // Context must outlive test for cleanup
+	telemetry := componenttest.NewTelemetry()
+	t.Cleanup(func() {
+		require.NoError(t, telemetry.Shutdown(shutdownCtx))
+	})
+
+	parentParams := exportertest.NewNopSettings(metadata.Type)
+	parentParams.TelemetrySettings = telemetry.NewTelemetrySettings()
+
+	cfg := simpleConfig()
+	logsExporter, err := newLogsExporter(parentParams, cfg)
+	require.NoError(t, err)
+
+	otlpFactory := otlpexporter.NewFactory()
+	var childSettings []exporter.Settings
+	logsExporter.loadBalancer.componentFactory = func(createCtx context.Context, endpoint string) (component.Component, error) {
+		childCfg := buildExporterConfig(cfg, endpoint)
+		childParams := buildExporterSettings(otlpFactory.Type(), parentParams, endpoint)
+		childSettings = append(childSettings, childParams)
+
+		return exporterhelper.NewLogs(createCtx, childParams, &childCfg, func(context.Context, plog.Logs) error {
+			return nil
+		})
+	}
+	wrappedExporter, err := exporterhelper.NewLogs(
+		ctx,
+		parentParams,
+		cfg,
+		logsExporter.ConsumeLogs,
+		exporterhelper.WithStart(logsExporter.Start),
+		exporterhelper.WithShutdown(logsExporter.Shutdown),
+		exporterhelper.WithCapabilities(logsExporter.Capabilities()),
+	)
+	require.NoError(t, err)
+
+	require.NoError(t, wrappedExporter.Start(ctx, componenttest.NewNopHost()))
+	t.Cleanup(func() {
+		require.NoError(t, wrappedExporter.Shutdown(ctx))
+	})
+
+	logs := generateSingleLogRecord()
+	require.NoError(t, wrappedExporter.ConsumeLogs(ctx, logs))
+
+	metric, err := telemetry.GetMetric("otelcol_exporter_sent_log_records")
+	require.NoError(t, err)
+	sum, ok := metric.Data.(metricdata.Sum[int64])
+	require.True(t, ok)
+
+	exporterKey := attribute.Key("exporter")
+	var loadbalancingTotal int64
+	for _, dp := range sum.DataPoints {
+		attr, found := dp.Attributes.Value(exporterKey)
+		require.True(t, found, "exporter attribute must be present")
+		if attr.AsString() != parentParams.ID.String() {
+			assert.Failf(t, "unexpected exporter attribute", "got %s", attr.AsString())
+			continue
+		}
+		loadbalancingTotal += dp.Value
+	}
+
+	assert.Equal(t, int64(logs.LogRecordCount()), loadbalancingTotal)
+
+	loadbalancerMetric, err := telemetry.GetMetric("otelcol_loadbalancer_backend_outcome")
+	require.NoError(t, err)
+	lbSum, ok := loadbalancerMetric.Data.(metricdata.Sum[int64])
+	require.True(t, ok)
+	var totalBackendOutcome int64
+	for _, dp := range lbSum.DataPoints {
+		totalBackendOutcome += dp.Value
+	}
+	assert.Equal(t, int64(1), totalBackendOutcome)
+
+	require.Len(t, childSettings, 1)
+	assert.IsType(t, metricnoop.NewMeterProvider(), childSettings[0].MeterProvider)
+	assert.IsType(t, tracenoop.NewTracerProvider(), childSettings[0].TracerProvider)
+}
+
+func generateSingleLogRecord() plog.Logs {
+	logs := plog.NewLogs()
+	rl := logs.ResourceLogs().AppendEmpty()
+	sl := rl.ScopeLogs().AppendEmpty()
+	logRecord := sl.LogRecords().AppendEmpty()
+	logRecord.Body().SetStr("test log")
+	logRecord.SetTimestamp(pcommon.Timestamp(123))
+	return logs
+}
+
 func TestConsumeLogsUnexpectedExporterType(t *testing.T) {
 	componentFactory := func(_ context.Context, _ string) (component.Component, error) {
 		return newNopMockExporter(), nil

exporter/loadbalancingexporter/metrics_exporter.go

@@ -46,7 +46,7 @@ func newMetricsExporter(params exporter.Settings, cfg component.Config) (*metric
 	exporterFactory := otlpexporter.NewFactory()
 	cfFunc := func(ctx context.Context, endpoint string) (component.Component, error) {
 		oCfg := buildExporterConfig(cfg.(*Config), endpoint)
-		oParams := buildExporterSettings(params, endpoint)
+		oParams := buildExporterSettings(exporterFactory.Type(), params, endpoint)
 
 		return exporterFactory.CreateMetrics(ctx, oParams, &oCfg)
 	}

exporter/loadbalancingexporter/trace_exporter.go

@@ -54,7 +54,7 @@ func newTracesExporter(params exporter.Settings, cfg component.Config) (*traceEx
 	exporterFactory := otlpexporter.NewFactory()
 	cfFunc := func(ctx context.Context, endpoint string) (component.Component, error) {
 		oCfg := buildExporterConfig(cfg.(*Config), endpoint)
-		oParams := buildExporterSettings(params, endpoint)
+		oParams := buildExporterSettings(exporterFactory.Type(), params, endpoint)
 
 		return exporterFactory.CreateTraces(ctx, oParams, &oCfg)
 	}