Fix core to see errors in contrib

open-telemetry · Sep 11, 2024 · 7c1f289 · 7c1f289
1 parent b55d1a3
commit 7c1f289
Show file tree

Hide file tree

Showing 40 changed files with 139 additions and 139 deletions.
diff --git a/cmd/mdatagen/internal/samplereceiver/generated_component_telemetry_test.go b/cmd/mdatagen/internal/samplereceiver/generated_component_telemetry_test.go
diff --git a/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics.go b/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics.go
diff --git a/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics_test.go b/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics_test.go
diff --git a/cmd/mdatagen/templates/component_telemetry_test.go.tmpl b/cmd/mdatagen/templates/component_telemetry_test.go.tmpl
@@ -30,8 +30,8 @@ type componentTestTelemetry struct {
 {{- if or isConnector isExporter isExtension isProcessor isReceiver }}
 func (tt *componentTestTelemetry) NewSettings() {{ .Status.Class }}.Settings {
 	settings := {{ .Status.Class }}test.NewNopSettings()
-	settings.MeterProvider = tt.meterProvider
-	settings.LeveledMeterProvider = func(_ configtelemetry.Level) metric.MeterProvider {
+	settings.TelemetrySettings.MeterProvider = tt.meterProvider
+	settings.TelemetrySettings.LeveledMeterProvider = func(_ configtelemetry.Level) metric.MeterProvider {
 		return tt.meterProvider
 	}
 	settings.ID = component.NewID(component.MustNewType("{{ .Type }}"))

diff --git a/cmd/mdatagen/templates/metrics.go.tmpl b/cmd/mdatagen/templates/metrics.go.tmpl
@@ -158,34 +158,34 @@ func NewMetricsBuilder(mbc MetricsBuilderConfig, settings receiver.Settings, opt
 	{{- range $name, $metric := .Metrics }}
 	{{- if $metric.Warnings.IfEnabled }}
 	if mbc.Metrics.{{ $name.Render }}.Enabled {
-		settings.Logger.Warn("[WARNING] `{{ $name }}` should not be enabled: {{ $metric.Warnings.IfEnabled }}")
+		settings.TelemetrySettings.Logger.Warn("[WARNING] `{{ $name }}` should not be enabled: {{ $metric.Warnings.IfEnabled }}")
 	}
 	{{- end }}
 	{{- if $metric.Warnings.IfEnabledNotSet }}
 	if !mbc.Metrics.{{ $name.Render }}.enabledSetByUser {
-		settings.Logger.Warn("[WARNING] Please set `enabled` field explicitly for `{{ $name }}`: {{ $metric.Warnings.IfEnabledNotSet }}")
+		settings.TelemetrySettings.Logger.Warn("[WARNING] Please set `enabled` field explicitly for `{{ $name }}`: {{ $metric.Warnings.IfEnabledNotSet }}")
 	}
 	{{- end }}
 	{{- if $metric.Warnings.IfConfigured }}
 	if mbc.Metrics.{{ $name.Render }}.enabledSetByUser {
-		settings.Logger.Warn("[WARNING] `{{ $name }}` should not be configured: {{ $metric.Warnings.IfConfigured }}")
+		settings.TelemetrySettings.Logger.Warn("[WARNING] `{{ $name }}` should not be configured: {{ $metric.Warnings.IfConfigured }}")
 	}
 	{{- end }}
 	{{- end }}
 	{{- range $name, $attr := .ResourceAttributes }}
 	{{- if $attr.Warnings.IfEnabled }}
 	if mbc.ResourceAttributes.{{ $name.Render }}.Enabled {
-		settings.Logger.Warn("[WARNING] `{{ $name }}` should not be enabled: {{ $attr.Warnings.IfEnabled }}")
+		settings.TelemetrySettings.Logger.Warn("[WARNING] `{{ $name }}` should not be enabled: {{ $attr.Warnings.IfEnabled }}")
 	}
 	{{- end }}
 	{{- if $attr.Warnings.IfEnabledNotSet }}
 	if !mbc.ResourceAttributes.{{ $name.Render }}.enabledSetByUser {
-		settings.Logger.Warn("[WARNING] Please set `enabled` field explicitly for `{{ $name }}`: {{ $attr.Warnings.IfEnabledNotSet }}")
+		settings.TelemetrySettings.Logger.Warn("[WARNING] Please set `enabled` field explicitly for `{{ $name }}`: {{ $attr.Warnings.IfEnabledNotSet }}")
 	}
 	{{- end }}
 	{{- if $attr.Warnings.IfConfigured }}
 	if mbc.ResourceAttributes.{{ $name.Render }}.enabledSetByUser || mbc.ResourceAttributes.{{ $name.Render }}.MetricsInclude != nil || mbc.ResourceAttributes.{{ $name.Render }}.MetricsExclude != nil {
-		settings.Logger.Warn("[WARNING] `{{ $name }}` should not be configured: {{ $attr.Warnings.IfConfigured }}")
+		settings.TelemetrySettings.Logger.Warn("[WARNING] `{{ $name }}` should not be configured: {{ $attr.Warnings.IfConfigured }}")
 	}
 	{{- end }}
 	{{- end }}

diff --git a/cmd/mdatagen/templates/metrics_test.go.tmpl b/cmd/mdatagen/templates/metrics_test.go.tmpl
@@ -61,7 +61,7 @@ func TestMetricsBuilder(t *testing.T) {
 			ts := pcommon.Timestamp(1_000_001_000)
 			observedZapCore, observedLogs := observer.New(zap.WarnLevel)
 			settings := receivertest.NewNopSettings()
-			settings.Logger = zap.New(observedZapCore)
+			settings.TelemetrySettings.Logger = zap.New(observedZapCore)
 			mb := NewMetricsBuilder(loadMetricsBuilderConfig(t, test.name), settings, WithStartTime(start))
 
 			expectedWarnings := 0

diff --git a/exporter/exporterhelper/batch_sender.go b/exporter/exporterhelper/batch_sender.go
@@ -50,7 +50,7 @@ func newBatchSender(cfg exporterbatcher.Config, set exporter.Settings,
 	bs := &batchSender{
 		activeBatch:        newEmptyBatch(),
 		cfg:                cfg,
-		logger:             set.Logger,
+		logger:             set.TelemetrySettings.Logger,
 		mergeFunc:          mf,
 		mergeSplitFunc:     msf,
 		shutdownCh:         nil,

diff --git a/exporter/exporterhelper/common.go b/exporter/exporterhelper/common.go
@@ -309,7 +309,7 @@ func newBaseExporter(set exporter.Settings, signal component.DataType, osf obsre
 func (be *baseExporter) send(ctx context.Context, req Request) error {
 	err := be.queueSender.send(ctx, req)
 	if err != nil {
-		be.set.Logger.Error("Exporting failed. Rejecting data."+be.exportFailureMessage,
+		be.set.TelemetrySettings.Logger.Error("Exporting failed. Rejecting data."+be.exportFailureMessage,
 			zap.Error(err), zap.Int("rejected_items", req.ItemsCount()))
 	}
 	return err

diff --git a/exporter/exporterhelper/common_test.go b/exporter/exporterhelper/common_test.go
@@ -86,7 +86,7 @@ func TestQueueOptionsWithRequestExporter(t *testing.T) {
 func TestBaseExporterLogging(t *testing.T) {
 	set := exportertest.NewNopSettings()
 	logger, observed := observer.New(zap.DebugLevel)
-	set.Logger = zap.New(logger)
+	set.TelemetrySettings.Logger = zap.New(logger)
 	rCfg := configretry.NewDefaultBackOffConfig()
 	rCfg.Enabled = false
 	bs, err := newBaseExporter(set, defaultDataType, newNoopObsrepSender, WithRetry(rCfg))

diff --git a/exporter/exporterhelper/generated_component_telemetry_test.go b/exporter/exporterhelper/generated_component_telemetry_test.go
diff --git a/exporter/exporterhelper/logs.go b/exporter/exporterhelper/logs.go
@@ -110,7 +110,7 @@ func NewLogsRequestExporter(
 	converter RequestFromLogsFunc,
 	options ...Option,
 ) (exporter.Logs, error) {
-	if set.Logger == nil {
+	if set.TelemetrySettings.Logger == nil {
 		return nil, errNilLogger
 	}
 
@@ -126,7 +126,7 @@ func NewLogsRequestExporter(
 	lc, err := consumer.NewLogs(func(ctx context.Context, ld plog.Logs) error {
 		req, cErr := converter(ctx, ld)
 		if cErr != nil {
-			set.Logger.Error("Failed to convert logs. Dropping data.",
+			set.TelemetrySettings.Logger.Error("Failed to convert logs. Dropping data.",
 				zap.Int("dropped_log_records", ld.LogRecordCount()),
 				zap.Error(err))
 			return consumererror.NewPermanent(cErr)

diff --git a/exporter/exporterhelper/logs_test.go b/exporter/exporterhelper/logs_test.go
@@ -275,55 +275,55 @@ func TestLogsExporter_WithRecordEnqueueFailedMetrics(t *testing.T) {
 func TestLogsExporter_WithSpan(t *testing.T) {
 	set := exportertest.NewNopSettings()
 	sr := new(tracetest.SpanRecorder)
-	set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
-	otel.SetTracerProvider(set.TracerProvider)
+	set.TelemetrySettings.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
+	otel.SetTracerProvider(set.TelemetrySettings.TracerProvider)
 	defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
 
 	le, err := NewLogsExporter(context.Background(), set, &fakeLogsExporterConfig, newPushLogsData(nil))
 	require.Nil(t, err)
 	require.NotNil(t, le)
-	checkWrapSpanForLogsExporter(t, sr, set.TracerProvider.Tracer("test"), le, nil, 1)
+	checkWrapSpanForLogsExporter(t, sr, set.TelemetrySettings.TracerProvider.Tracer("test"), le, nil, 1)
 }
 
 func TestLogsRequestExporter_WithSpan(t *testing.T) {
 	set := exportertest.NewNopSettings()
 	sr := new(tracetest.SpanRecorder)
-	set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
-	otel.SetTracerProvider(set.TracerProvider)
+	set.TelemetrySettings.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
+	otel.SetTracerProvider(set.TelemetrySettings.TracerProvider)
 	defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
 
 	le, err := NewLogsRequestExporter(context.Background(), set, (&fakeRequestConverter{}).requestFromLogsFunc)
 	require.Nil(t, err)
 	require.NotNil(t, le)
-	checkWrapSpanForLogsExporter(t, sr, set.TracerProvider.Tracer("test"), le, nil, 1)
+	checkWrapSpanForLogsExporter(t, sr, set.TelemetrySettings.TracerProvider.Tracer("test"), le, nil, 1)
 }
 
 func TestLogsExporter_WithSpan_ReturnError(t *testing.T) {
 	set := exportertest.NewNopSettings()
 	sr := new(tracetest.SpanRecorder)
-	set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
-	otel.SetTracerProvider(set.TracerProvider)
+	set.TelemetrySettings.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
+	otel.SetTracerProvider(set.TelemetrySettings.TracerProvider)
 	defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
 
 	want := errors.New("my_error")
 	le, err := NewLogsExporter(context.Background(), set, &fakeLogsExporterConfig, newPushLogsData(want))
 	require.Nil(t, err)
 	require.NotNil(t, le)
-	checkWrapSpanForLogsExporter(t, sr, set.TracerProvider.Tracer("test"), le, want, 1)
+	checkWrapSpanForLogsExporter(t, sr, set.TelemetrySettings.TracerProvider.Tracer("test"), le, want, 1)
 }
 
 func TestLogsRequestExporter_WithSpan_ReturnError(t *testing.T) {
 	set := exportertest.NewNopSettings()
 	sr := new(tracetest.SpanRecorder)
-	set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
-	otel.SetTracerProvider(set.TracerProvider)
+	set.TelemetrySettings.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
+	otel.SetTracerProvider(set.TelemetrySettings.TracerProvider)
 	defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
 
 	want := errors.New("my_error")
 	le, err := NewLogsRequestExporter(context.Background(), set, (&fakeRequestConverter{requestError: want}).requestFromLogsFunc)
 	require.Nil(t, err)
 	require.NotNil(t, le)
-	checkWrapSpanForLogsExporter(t, sr, set.TracerProvider.Tracer("test"), le, want, 1)
+	checkWrapSpanForLogsExporter(t, sr, set.TelemetrySettings.TracerProvider.Tracer("test"), le, want, 1)
 }
 
 func TestLogsExporter_WithShutdown(t *testing.T) {

diff --git a/exporter/exporterhelper/metrics.go b/exporter/exporterhelper/metrics.go
@@ -110,7 +110,7 @@ func NewMetricsRequestExporter(
 	converter RequestFromMetricsFunc,
 	options ...Option,
 ) (exporter.Metrics, error) {
-	if set.Logger == nil {
+	if set.TelemetrySettings.Logger == nil {
 		return nil, errNilLogger
 	}
 
@@ -126,7 +126,7 @@ func NewMetricsRequestExporter(
 	mc, err := consumer.NewMetrics(func(ctx context.Context, md pmetric.Metrics) error {
 		req, cErr := converter(ctx, md)
 		if cErr != nil {
-			set.Logger.Error("Failed to convert metrics. Dropping data.",
+			set.TelemetrySettings.Logger.Error("Failed to convert metrics. Dropping data.",
 				zap.Int("dropped_data_points", md.DataPointCount()),
 				zap.Error(err))
 			return consumererror.NewPermanent(cErr)

diff --git a/exporter/exporterhelper/metrics_test.go b/exporter/exporterhelper/metrics_test.go
@@ -277,55 +277,55 @@ func TestMetricsExporter_WithRecordEnqueueFailedMetrics(t *testing.T) {
 func TestMetricsExporter_WithSpan(t *testing.T) {
 	set := exportertest.NewNopSettings()
 	sr := new(tracetest.SpanRecorder)
-	set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
-	otel.SetTracerProvider(set.TracerProvider)
+	set.TelemetrySettings.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
+	otel.SetTracerProvider(set.TelemetrySettings.TracerProvider)
 	defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
 
 	me, err := NewMetricsExporter(context.Background(), set, &fakeMetricsExporterConfig, newPushMetricsData(nil))
 	require.NoError(t, err)
 	require.NotNil(t, me)
-	checkWrapSpanForMetricsExporter(t, sr, set.TracerProvider.Tracer("test"), me, nil, 2)
+	checkWrapSpanForMetricsExporter(t, sr, set.TelemetrySettings.TracerProvider.Tracer("test"), me, nil, 2)
 }
 
 func TestMetricsRequestExporter_WithSpan(t *testing.T) {
 	set := exportertest.NewNopSettings()
 	sr := new(tracetest.SpanRecorder)
-	set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
-	otel.SetTracerProvider(set.TracerProvider)
+	set.TelemetrySettings.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
+	otel.SetTracerProvider(set.TelemetrySettings.TracerProvider)
 	defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
 
 	me, err := NewMetricsRequestExporter(context.Background(), set, (&fakeRequestConverter{}).requestFromMetricsFunc)
 	require.NoError(t, err)
 	require.NotNil(t, me)
-	checkWrapSpanForMetricsExporter(t, sr, set.TracerProvider.Tracer("test"), me, nil, 2)
+	checkWrapSpanForMetricsExporter(t, sr, set.TelemetrySettings.TracerProvider.Tracer("test"), me, nil, 2)
 }
 
 func TestMetricsExporter_WithSpan_ReturnError(t *testing.T) {
 	set := exportertest.NewNopSettings()
 	sr := new(tracetest.SpanRecorder)
-	set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
-	otel.SetTracerProvider(set.TracerProvider)
+	set.TelemetrySettings.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
+	otel.SetTracerProvider(set.TelemetrySettings.TracerProvider)
 	defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
 
 	want := errors.New("my_error")
 	me, err := NewMetricsExporter(context.Background(), set, &fakeMetricsExporterConfig, newPushMetricsData(want))
 	require.NoError(t, err)
 	require.NotNil(t, me)
-	checkWrapSpanForMetricsExporter(t, sr, set.TracerProvider.Tracer("test"), me, want, 2)
+	checkWrapSpanForMetricsExporter(t, sr, set.TelemetrySettings.TracerProvider.Tracer("test"), me, want, 2)
 }
 
 func TestMetricsRequestExporter_WithSpan_ExportError(t *testing.T) {
 	set := exportertest.NewNopSettings()
 	sr := new(tracetest.SpanRecorder)
-	set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
-	otel.SetTracerProvider(set.TracerProvider)
+	set.TelemetrySettings.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
+	otel.SetTracerProvider(set.TelemetrySettings.TracerProvider)
 	defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
 
 	want := errors.New("my_error")
 	me, err := NewMetricsRequestExporter(context.Background(), set, (&fakeRequestConverter{requestError: want}).requestFromMetricsFunc)
 	require.NoError(t, err)
 	require.NotNil(t, me)
-	checkWrapSpanForMetricsExporter(t, sr, set.TracerProvider.Tracer("test"), me, want, 2)
+	checkWrapSpanForMetricsExporter(t, sr, set.TelemetrySettings.TracerProvider.Tracer("test"), me, want, 2)
 }
 
 func TestMetricsExporter_WithShutdown(t *testing.T) {

diff --git a/exporter/exporterhelper/obsexporter.go b/exporter/exporterhelper/obsexporter.go
@@ -42,7 +42,7 @@ func newExporter(cfg obsReportSettings) (*obsReport, error) {
 
 	return &obsReport{
 		spanNamePrefix: obsmetrics.ExporterPrefix + cfg.exporterID.String(),
-		tracer:         cfg.exporterCreateSettings.TracerProvider.Tracer(cfg.exporterID.String()),
+		tracer:         cfg.exporterCreateSettings.TelemetrySettings.TracerProvider.Tracer(cfg.exporterID.String()),
 		dataType:       cfg.dataType,
 		otelAttrs: []attribute.KeyValue{
 			attribute.String(obsmetrics.ExporterKey, cfg.exporterID.String()),

diff --git a/exporter/exporterhelper/queue_sender.go b/exporter/exporterhelper/queue_sender.go
@@ -89,7 +89,7 @@ func newQueueSender(q exporterqueue.Queue[Request], set exporter.Settings, numCo
 	consumeFunc := func(ctx context.Context, req Request) error {
 		err := qs.nextSender.send(ctx, req)
 		if err != nil {
-			set.Logger.Error("Exporting failed. Dropping data."+exportFailureMessage,
+			set.TelemetrySettings.Logger.Error("Exporting failed. Dropping data."+exportFailureMessage,
 				zap.Error(err), zap.Int("dropped_items", req.ItemsCount()))
 		}
 		return err