From 6de29ce169211b2e303625be8504724075476fce Mon Sep 17 00:00:00 2001 From: Chao Weng <19381524+sincejune@users.noreply.github.com> Date: Fri, 21 Feb 2025 19:17:45 +0800 Subject: [PATCH] Add `component.Type` parameter to `NewNopSettings` And deprecate `NewNopSettingsWithType` (#12452) #### Description Add `component.Type` parameter to `NewNopSettings` And deprecate `NewNopSettingsWithType` cc @mx-psi #### Link to tracking issue Relevant to #12305 #### Testing Updated #### Documentation Added --- .../deprecate-newnopsettingswithtype.yaml | 25 ++++++++++++ .../generated_component_test.go | 4 +- .../generated_component_test.go | 6 +-- .../metadata/generated_metrics_test.go | 2 +- .../metadatatest/generated_telemetrytest.go | 2 +- .../internal/samplereceiver/metrics_test.go | 2 +- .../samplescraper/generated_component_test.go | 6 +-- .../metadata/generated_metrics_test.go | 2 +- .../internal/templates/component_test.go.tmpl | 32 ++++++++-------- .../internal/templates/metrics_test.go.tmpl | 2 +- .../internal/templates/telemetrytest.go.tmpl | 2 +- connector/connectortest/connector.go | 12 ++++-- connector/connectortest/connector_test.go | 32 ++++++++-------- connector/forwardconnector/forward_test.go | 2 +- .../generated_component_test.go | 6 +-- exporter/debugexporter/exporter_test.go | 8 ++-- exporter/debugexporter/factory_test.go | 8 ++-- .../debugexporter/generated_component_test.go | 4 +- .../internal/base_exporter_test.go | 12 +++--- .../internal/batcher/disabled_batcher_test.go | 2 +- .../internal/queue_sender_test.go | 2 +- .../internal/retry_sender_test.go | 14 +++---- exporter/exporterhelper/logs_test.go | 38 +++++++++---------- exporter/exporterhelper/metrics_test.go | 38 +++++++++---------- exporter/exporterhelper/traces_test.go | 38 +++++++++---------- .../xexporterhelper/profiles_test.go | 38 +++++++++---------- .../exporterqueue/persistent_queue_test.go | 10 ++--- exporter/exportertest/contract_checker.go | 12 +++--- exporter/exportertest/nop_exporter.go | 12 ++++-- exporter/exportertest/nop_exporter_test.go | 8 ++-- .../nopexporter/generated_component_test.go | 4 +- exporter/nopexporter/nop_exporter_test.go | 6 +-- exporter/otlpexporter/factory_test.go | 8 ++-- .../otlpexporter/generated_component_test.go | 4 +- exporter/otlpexporter/otlp_test.go | 18 ++++----- exporter/otlphttpexporter/factory_test.go | 8 ++-- .../generated_component_test.go | 4 +- exporter/otlphttpexporter/otlp_test.go | 30 +++++++-------- extension/extensiontest/nop_extension.go | 12 ++++-- extension/extensiontest/nop_extension_test.go | 2 +- .../memorylimiterextension/factory_test.go | 2 +- .../generated_component_test.go | 4 +- extension/zpagesextension/factory_test.go | 4 +- .../generated_component_test.go | 6 +-- internal/e2e/otlphttp_test.go | 14 +++---- .../batchprocessor/batch_processor_test.go | 34 ++++++++--------- processor/batchprocessor/factory_test.go | 2 +- .../generated_component_test.go | 4 +- .../metadatatest/generated_telemetrytest.go | 2 +- .../memorylimiterprocessor/factory_test.go | 2 +- .../generated_component_test.go | 2 +- .../metadatatest/generated_telemetrytest.go | 2 +- .../memorylimiter_test.go | 14 +++---- processor/processorhelper/logs_test.go | 14 +++---- processor/processorhelper/metrics_test.go | 12 +++--- processor/processorhelper/traces_test.go | 12 +++--- .../xprocessorhelper/profiles_test.go | 12 +++--- processor/processortest/nop_processor.go | 12 ++++-- processor/processortest/nop_processor_test.go | 8 ++-- processor/processortest/shutdown_verifier.go | 6 +-- .../processortest/unhealthy_processor_test.go | 6 +-- .../nopreceiver/generated_component_test.go | 6 +-- receiver/nopreceiver/nop_receiver_test.go | 6 +-- receiver/otlpreceiver/factory_test.go | 10 ++--- receiver/otlpreceiver/fuzz_test.go | 2 +- .../otlpreceiver/generated_component_test.go | 6 +-- .../otlpreceiver/internal/logs/otlp_test.go | 2 +- .../internal/metrics/otlp_test.go | 2 +- .../otlpreceiver/internal/trace/otlp_test.go | 2 +- receiver/otlpreceiver/otlp_test.go | 8 ++-- receiver/receivertest/contract_checker.go | 6 +-- receiver/receivertest/nop_receiver.go | 12 ++++-- receiver/receivertest/nop_receiver_test.go | 8 ++-- scraper/scraperhelper/controller_test.go | 16 ++++---- scraper/scrapertest/settings.go | 12 ++++-- .../builders/builders_test/connector_test.go | 2 +- .../builders/builders_test/exporter_test.go | 2 +- .../builders/builders_test/extension_test.go | 2 +- .../builders/builders_test/processor_test.go | 2 +- .../builders/builders_test/receiver_test.go | 2 +- .../testcomponents/example_router_test.go | 8 ++-- 81 files changed, 408 insertions(+), 359 deletions(-) create mode 100644 .chloggen/deprecate-newnopsettingswithtype.yaml diff --git a/.chloggen/deprecate-newnopsettingswithtype.yaml b/.chloggen/deprecate-newnopsettingswithtype.yaml new file mode 100644 index 0000000000..24b37875e5 --- /dev/null +++ b/.chloggen/deprecate-newnopsettingswithtype.yaml @@ -0,0 +1,25 @@ +# Use this changelog template to create an entry for release notes. + +# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix' +change_type: deprecation + +# The name of the component, or a single word describing the area of concern, (e.g. otlpreceiver) +component: connector, exporter, extension, processor, receiver, scraper + +# A brief description of the change. Surround your text with quotes ("") if it needs to start with a backtick (`). +note: Add type parameter to `NewNopSettings` and deprecate `NewNopSettingsWithType` + +# One or more tracking issues or pull requests related to the change +issues: [12305] + +# (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: + +# 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: [api] diff --git a/cmd/mdatagen/internal/sampleprocessor/generated_component_test.go b/cmd/mdatagen/internal/sampleprocessor/generated_component_test.go index 8f2e212465..6925f6f82f 100644 --- a/cmd/mdatagen/internal/sampleprocessor/generated_component_test.go +++ b/cmd/mdatagen/internal/sampleprocessor/generated_component_test.go @@ -71,13 +71,13 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { t.Run(tt.name+"-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), processortest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), processortest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) }) t.Run(tt.name+"-lifecycle", func(t *testing.T) { - c, err := tt.createFn(context.Background(), processortest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), processortest.NewNopSettings(typ), cfg) require.NoError(t, err) host := componenttest.NewNopHost() err = c.Start(context.Background(), host) diff --git a/cmd/mdatagen/internal/samplereceiver/generated_component_test.go b/cmd/mdatagen/internal/samplereceiver/generated_component_test.go index 9cafc1c533..e317b2ec85 100644 --- a/cmd/mdatagen/internal/samplereceiver/generated_component_test.go +++ b/cmd/mdatagen/internal/samplereceiver/generated_component_test.go @@ -66,19 +66,19 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { t.Run(tt.name+"-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), receivertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), receivertest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) }) t.Run(tt.name+"-lifecycle", func(t *testing.T) { - firstRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettingsWithType(typ), cfg) + firstRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettings(typ), cfg) require.NoError(t, err) host := componenttest.NewNopHost() require.NoError(t, err) require.NoError(t, firstRcvr.Start(context.Background(), host)) require.NoError(t, firstRcvr.Shutdown(context.Background())) - secondRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettingsWithType(typ), cfg) + secondRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, secondRcvr.Start(context.Background(), host)) require.NoError(t, secondRcvr.Shutdown(context.Background())) diff --git a/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics_test.go b/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics_test.go index 6f6f8a7e57..19c3c790cd 100644 --- a/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics_test.go +++ b/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics_test.go @@ -58,7 +58,7 @@ func TestMetricsBuilder(t *testing.T) { start := pcommon.Timestamp(1_000_000_000) ts := pcommon.Timestamp(1_000_001_000) observedZapCore, observedLogs := observer.New(zap.WarnLevel) - settings := receivertest.NewNopSettingsWithType(receivertest.NopType) + settings := receivertest.NewNopSettings(receivertest.NopType) settings.Logger = zap.New(observedZapCore) mb := NewMetricsBuilder(loadMetricsBuilderConfig(t, tt.name), settings, WithStartTime(start)) diff --git a/cmd/mdatagen/internal/samplereceiver/internal/metadatatest/generated_telemetrytest.go b/cmd/mdatagen/internal/samplereceiver/internal/metadatatest/generated_telemetrytest.go index cbbc9f407d..c89f21ad04 100644 --- a/cmd/mdatagen/internal/samplereceiver/internal/metadatatest/generated_telemetrytest.go +++ b/cmd/mdatagen/internal/samplereceiver/internal/metadatatest/generated_telemetrytest.go @@ -16,7 +16,7 @@ import ( ) func NewSettings(tt *componenttest.Telemetry) receiver.Settings { - set := receivertest.NewNopSettingsWithType(receivertest.NopType) + set := receivertest.NewNopSettings(receivertest.NopType) set.ID = component.NewID(component.MustNewType("sample")) set.TelemetrySettings = tt.NewTelemetrySettings() return set diff --git a/cmd/mdatagen/internal/samplereceiver/metrics_test.go b/cmd/mdatagen/internal/samplereceiver/metrics_test.go index 0e713ae228..f010ec208b 100644 --- a/cmd/mdatagen/internal/samplereceiver/metrics_test.go +++ b/cmd/mdatagen/internal/samplereceiver/metrics_test.go @@ -20,7 +20,7 @@ import ( // TestGeneratedMetrics verifies that the internal/metadata API is generated correctly. func TestGeneratedMetrics(t *testing.T) { - mb := metadata.NewMetricsBuilder(metadata.DefaultMetricsBuilderConfig(), receivertest.NewNopSettingsWithType(metadata.Type)) + mb := metadata.NewMetricsBuilder(metadata.DefaultMetricsBuilderConfig(), receivertest.NewNopSettings(metadata.Type)) m := mb.Emit() require.Equal(t, 0, m.ResourceMetrics().Len()) } diff --git a/cmd/mdatagen/internal/samplescraper/generated_component_test.go b/cmd/mdatagen/internal/samplescraper/generated_component_test.go index 7dac5d0f5b..720e8c36fe 100644 --- a/cmd/mdatagen/internal/samplescraper/generated_component_test.go +++ b/cmd/mdatagen/internal/samplescraper/generated_component_test.go @@ -51,19 +51,19 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { t.Run(tt.name+"-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), scrapertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), scrapertest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) }) t.Run(tt.name+"-lifecycle", func(t *testing.T) { - firstRcvr, err := tt.createFn(context.Background(), scrapertest.NewNopSettingsWithType(typ), cfg) + firstRcvr, err := tt.createFn(context.Background(), scrapertest.NewNopSettings(typ), cfg) require.NoError(t, err) host := componenttest.NewNopHost() require.NoError(t, err) require.NoError(t, firstRcvr.Start(context.Background(), host)) require.NoError(t, firstRcvr.Shutdown(context.Background())) - secondRcvr, err := tt.createFn(context.Background(), scrapertest.NewNopSettingsWithType(typ), cfg) + secondRcvr, err := tt.createFn(context.Background(), scrapertest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, secondRcvr.Start(context.Background(), host)) require.NoError(t, secondRcvr.Shutdown(context.Background())) diff --git a/cmd/mdatagen/internal/samplescraper/internal/metadata/generated_metrics_test.go b/cmd/mdatagen/internal/samplescraper/internal/metadata/generated_metrics_test.go index 59fc9d326a..579ec0defb 100644 --- a/cmd/mdatagen/internal/samplescraper/internal/metadata/generated_metrics_test.go +++ b/cmd/mdatagen/internal/samplescraper/internal/metadata/generated_metrics_test.go @@ -58,7 +58,7 @@ func TestMetricsBuilder(t *testing.T) { start := pcommon.Timestamp(1_000_000_000) ts := pcommon.Timestamp(1_000_001_000) observedZapCore, observedLogs := observer.New(zap.WarnLevel) - settings := scrapertest.NewNopSettingsWithType(scrapertest.NopType) + settings := scrapertest.NewNopSettings(scrapertest.NopType) settings.Logger = zap.New(observedZapCore) mb := NewMetricsBuilder(loadMetricsBuilderConfig(t, tt.name), settings, WithStartTime(start)) diff --git a/cmd/mdatagen/internal/templates/component_test.go.tmpl b/cmd/mdatagen/internal/templates/component_test.go.tmpl index ea088bf56a..39002f5fd1 100644 --- a/cmd/mdatagen/internal/templates/component_test.go.tmpl +++ b/cmd/mdatagen/internal/templates/component_test.go.tmpl @@ -113,7 +113,7 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { {{- if not .Tests.SkipShutdown }} t.Run(tt.name + "-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), exportertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), exportertest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) @@ -122,7 +122,7 @@ func TestComponentLifecycle(t *testing.T) { {{- if not .Tests.SkipLifecycle }} t.Run(tt.name + "-lifecycle", func(t *testing.T) { - c, err := tt.createFn(context.Background(), exportertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), exportertest.NewNopSettings(typ), cfg) require.NoError(t, err) host := {{ .Tests.Host }} err = c.Start(context.Background(), host) @@ -210,7 +210,7 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { {{- if not .Tests.SkipShutdown }} t.Run(tt.name + "-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), processortest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), processortest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) @@ -219,7 +219,7 @@ func TestComponentLifecycle(t *testing.T) { {{- if not .Tests.SkipLifecycle }} t.Run(tt.name + "-lifecycle", func(t *testing.T) { - c, err := tt.createFn(context.Background(), processortest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), processortest.NewNopSettings(typ), cfg) require.NoError(t, err) host := {{ .Tests.Host }} err = c.Start(context.Background(), host) @@ -305,7 +305,7 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { {{- if not .Tests.SkipShutdown }} t.Run(tt.name + "-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), receivertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), receivertest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) @@ -314,13 +314,13 @@ func TestComponentLifecycle(t *testing.T) { {{- if not .Tests.SkipLifecycle }} t.Run(tt.name + "-lifecycle", func(t *testing.T) { - firstRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettingsWithType(typ), cfg) + firstRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettings(typ), cfg) require.NoError(t, err) host := {{ .Tests.Host }} require.NoError(t, err) require.NoError(t, firstRcvr.Start(context.Background(), host)) require.NoError(t, firstRcvr.Shutdown(context.Background())) - secondRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettingsWithType(typ), cfg) + secondRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, secondRcvr.Start(context.Background(), host)) require.NoError(t, secondRcvr.Shutdown(context.Background())) @@ -374,7 +374,7 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { {{- if not .Tests.SkipShutdown }} t.Run(tt.name + "-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), scrapertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), scrapertest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) @@ -383,13 +383,13 @@ func TestComponentLifecycle(t *testing.T) { {{- if not .Tests.SkipLifecycle }} t.Run(tt.name + "-lifecycle", func(t *testing.T) { - firstRcvr, err := tt.createFn(context.Background(), scrapertest.NewNopSettingsWithType(typ), cfg) + firstRcvr, err := tt.createFn(context.Background(), scrapertest.NewNopSettings(typ), cfg) require.NoError(t, err) host := {{ .Tests.Host }} require.NoError(t, err) require.NoError(t, firstRcvr.Start(context.Background(), host)) require.NoError(t, firstRcvr.Shutdown(context.Background())) - secondRcvr, err := tt.createFn(context.Background(), scrapertest.NewNopSettingsWithType(typ), cfg) + secondRcvr, err := tt.createFn(context.Background(), scrapertest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, secondRcvr.Start(context.Background(), host)) require.NoError(t, secondRcvr.Shutdown(context.Background())) @@ -412,7 +412,7 @@ func TestComponentLifecycle(t *testing.T) { {{- if not .Tests.SkipShutdown }} t.Run("shutdown", func(t *testing.T) { - e, err := factory.Create(context.Background(), extensiontest.NewNopSettingsWithType(typ), cfg) + e, err := factory.Create(context.Background(), extensiontest.NewNopSettings(typ), cfg) require.NoError(t, err) err = e.Shutdown(context.Background()) require.NoError(t, err) @@ -421,12 +421,12 @@ func TestComponentLifecycle(t *testing.T) { {{- if not .Tests.SkipLifecycle }} t.Run("lifecycle", func(t *testing.T) { - firstExt, err := factory.Create(context.Background(), extensiontest.NewNopSettingsWithType(typ), cfg) + firstExt, err := factory.Create(context.Background(), extensiontest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, firstExt.Start(context.Background(), {{ .Tests.Host }})) require.NoError(t, firstExt.Shutdown(context.Background())) - secondExt, err := factory.Create(context.Background(), extensiontest.NewNopSettingsWithType(typ), cfg) + secondExt, err := factory.Create(context.Background(), extensiontest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, secondExt.Start(context.Background(), {{ .Tests.Host }})) require.NoError(t, secondExt.Shutdown(context.Background())) @@ -536,7 +536,7 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { {{- if not .Tests.SkipShutdown }} t.Run(tt.name + "-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), connectortest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), connectortest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) @@ -545,13 +545,13 @@ func TestComponentLifecycle(t *testing.T) { {{- if not .Tests.SkipLifecycle }} t.Run(tt.name + "-lifecycle", func(t *testing.T) { - firstConnector, err := tt.createFn(context.Background(), connectortest.NewNopSettingsWithType(typ), cfg) + firstConnector, err := tt.createFn(context.Background(), connectortest.NewNopSettings(typ), cfg) require.NoError(t, err) host := {{ .Tests.Host }} require.NoError(t, err) require.NoError(t, firstConnector.Start(context.Background(), host)) require.NoError(t, firstConnector.Shutdown(context.Background())) - secondConnector, err := tt.createFn(context.Background(), connectortest.NewNopSettingsWithType(typ), cfg) + secondConnector, err := tt.createFn(context.Background(), connectortest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, secondConnector.Start(context.Background(), host)) require.NoError(t, secondConnector.Shutdown(context.Background())) diff --git a/cmd/mdatagen/internal/templates/metrics_test.go.tmpl b/cmd/mdatagen/internal/templates/metrics_test.go.tmpl index 615ba43cbc..9a230f8ed2 100644 --- a/cmd/mdatagen/internal/templates/metrics_test.go.tmpl +++ b/cmd/mdatagen/internal/templates/metrics_test.go.tmpl @@ -63,7 +63,7 @@ func TestMetricsBuilder(t *testing.T) { ts := pcommon.Timestamp(1_000_001_000) observedZapCore, observedLogs := observer.New(zap.WarnLevel) {{- if or isReceiver isScraper }} - settings := {{ .Status.Class }}test.NewNopSettingsWithType({{ .Status.Class }}test.NopType) + settings := {{ .Status.Class }}test.NewNopSettings({{ .Status.Class }}test.NopType) {{- end }} settings.Logger = zap.New(observedZapCore) mb := NewMetricsBuilder(loadMetricsBuilderConfig(t, tt.name), settings, WithStartTime(start)) diff --git a/cmd/mdatagen/internal/templates/telemetrytest.go.tmpl b/cmd/mdatagen/internal/templates/telemetrytest.go.tmpl index 5fbb7b4539..00c0bbafd1 100644 --- a/cmd/mdatagen/internal/templates/telemetrytest.go.tmpl +++ b/cmd/mdatagen/internal/templates/telemetrytest.go.tmpl @@ -22,7 +22,7 @@ import ( {{ if or isConnector isExporter isExtension isProcessor isReceiver isScraper }} func NewSettings(tt *componenttest.Telemetry) {{ .Status.Class }}.Settings { -set := {{ .Status.Class }}test.NewNopSettingsWithType({{ .Status.Class }}test.NopType) +set := {{ .Status.Class }}test.NewNopSettings({{ .Status.Class }}test.NopType) set.ID = component.NewID(component.MustNewType("{{ .Type }}")) set.TelemetrySettings = tt.NewTelemetrySettings() return set diff --git a/connector/connectortest/connector.go b/connector/connectortest/connector.go index 843d0a2953..279bdb32cf 100644 --- a/connector/connectortest/connector.go +++ b/connector/connectortest/connector.go @@ -19,12 +19,16 @@ import ( var NopType = component.MustNewType("nop") -// NewNopSettings returns a new nop settings for Create* functions. -// Deprecated: [v0.120.0] Use NewNopSettingsWithType instead. -func NewNopSettings() connector.Settings { - return NewNopSettingsWithType(NopType) +// NewNopSettings returns a new nop settings for Create* functions with the given type. +func NewNopSettings(typ component.Type) connector.Settings { + return connector.Settings{ + ID: component.NewIDWithName(typ, uuid.NewString()), + TelemetrySettings: componenttest.NewNopTelemetrySettings(), + BuildInfo: component.NewDefaultBuildInfo(), + } } +// Deprecated: [v0.121.0] Use NewNopSettings(NopType) instead. // NewNopSettingsWithType returns a new nop settings for Create* functions with the given type. func NewNopSettingsWithType(typ component.Type) connector.Settings { return connector.Settings{ diff --git a/connector/connectortest/connector_test.go b/connector/connectortest/connector_test.go index 21d0883334..ec8cb187c0 100644 --- a/connector/connectortest/connector_test.go +++ b/connector/connectortest/connector_test.go @@ -27,97 +27,97 @@ func TestNewNopConnectorFactory(t *testing.T) { cfg := factory.CreateDefaultConfig() assert.Equal(t, &nopConfig{}, cfg) - tracesToTraces, err := factory.CreateTracesToTraces(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + tracesToTraces, err := factory.CreateTracesToTraces(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, tracesToTraces.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, tracesToTraces.ConsumeTraces(context.Background(), ptrace.NewTraces())) assert.NoError(t, tracesToTraces.Shutdown(context.Background())) - tracesToMetrics, err := factory.CreateTracesToMetrics(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + tracesToMetrics, err := factory.CreateTracesToMetrics(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, tracesToMetrics.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, tracesToMetrics.ConsumeTraces(context.Background(), ptrace.NewTraces())) assert.NoError(t, tracesToMetrics.Shutdown(context.Background())) - tracesToLogs, err := factory.CreateTracesToLogs(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + tracesToLogs, err := factory.CreateTracesToLogs(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, tracesToLogs.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, tracesToLogs.ConsumeTraces(context.Background(), ptrace.NewTraces())) assert.NoError(t, tracesToLogs.Shutdown(context.Background())) - tracesToProfiles, err := factory.(xconnector.Factory).CreateTracesToProfiles(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + tracesToProfiles, err := factory.(xconnector.Factory).CreateTracesToProfiles(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, tracesToProfiles.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, tracesToProfiles.ConsumeTraces(context.Background(), ptrace.NewTraces())) assert.NoError(t, tracesToProfiles.Shutdown(context.Background())) - metricsToTraces, err := factory.CreateMetricsToTraces(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + metricsToTraces, err := factory.CreateMetricsToTraces(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, metricsToTraces.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, metricsToTraces.ConsumeMetrics(context.Background(), pmetric.NewMetrics())) assert.NoError(t, metricsToTraces.Shutdown(context.Background())) - metricsToMetrics, err := factory.CreateMetricsToMetrics(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + metricsToMetrics, err := factory.CreateMetricsToMetrics(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, metricsToMetrics.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, metricsToMetrics.ConsumeMetrics(context.Background(), pmetric.NewMetrics())) assert.NoError(t, metricsToMetrics.Shutdown(context.Background())) - metricsToLogs, err := factory.CreateMetricsToLogs(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + metricsToLogs, err := factory.CreateMetricsToLogs(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, metricsToLogs.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, metricsToLogs.ConsumeMetrics(context.Background(), pmetric.NewMetrics())) assert.NoError(t, metricsToLogs.Shutdown(context.Background())) - metricsToProfiles, err := factory.(xconnector.Factory).CreateMetricsToProfiles(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + metricsToProfiles, err := factory.(xconnector.Factory).CreateMetricsToProfiles(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, metricsToProfiles.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, metricsToProfiles.ConsumeMetrics(context.Background(), pmetric.NewMetrics())) assert.NoError(t, metricsToProfiles.Shutdown(context.Background())) - logsToTraces, err := factory.CreateLogsToTraces(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + logsToTraces, err := factory.CreateLogsToTraces(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, logsToTraces.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, logsToTraces.ConsumeLogs(context.Background(), plog.NewLogs())) assert.NoError(t, logsToTraces.Shutdown(context.Background())) - logsToMetrics, err := factory.CreateLogsToMetrics(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + logsToMetrics, err := factory.CreateLogsToMetrics(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, logsToMetrics.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, logsToMetrics.ConsumeLogs(context.Background(), plog.NewLogs())) assert.NoError(t, logsToMetrics.Shutdown(context.Background())) - logsToLogs, err := factory.CreateLogsToLogs(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + logsToLogs, err := factory.CreateLogsToLogs(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, logsToLogs.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, logsToLogs.ConsumeLogs(context.Background(), plog.NewLogs())) assert.NoError(t, logsToLogs.Shutdown(context.Background())) - logsToProfiles, err := factory.(xconnector.Factory).CreateLogsToProfiles(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + logsToProfiles, err := factory.(xconnector.Factory).CreateLogsToProfiles(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, logsToProfiles.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, logsToProfiles.ConsumeLogs(context.Background(), plog.NewLogs())) assert.NoError(t, logsToProfiles.Shutdown(context.Background())) - profilesToTraces, err := factory.(xconnector.Factory).CreateProfilesToTraces(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + profilesToTraces, err := factory.(xconnector.Factory).CreateProfilesToTraces(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, profilesToTraces.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, profilesToTraces.ConsumeProfiles(context.Background(), pprofile.NewProfiles())) assert.NoError(t, profilesToTraces.Shutdown(context.Background())) - profilesToMetrics, err := factory.(xconnector.Factory).CreateProfilesToMetrics(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + profilesToMetrics, err := factory.(xconnector.Factory).CreateProfilesToMetrics(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, profilesToMetrics.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, profilesToMetrics.ConsumeProfiles(context.Background(), pprofile.NewProfiles())) assert.NoError(t, profilesToMetrics.Shutdown(context.Background())) - profilesToLogs, err := factory.(xconnector.Factory).CreateProfilesToProfiles(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + profilesToLogs, err := factory.(xconnector.Factory).CreateProfilesToProfiles(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, profilesToLogs.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, profilesToLogs.ConsumeProfiles(context.Background(), pprofile.NewProfiles())) assert.NoError(t, profilesToLogs.Shutdown(context.Background())) - profilesToProfiles, err := factory.(xconnector.Factory).CreateProfilesToProfiles(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + profilesToProfiles, err := factory.(xconnector.Factory).CreateProfilesToProfiles(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, profilesToProfiles.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, profilesToProfiles.ConsumeProfiles(context.Background(), pprofile.NewProfiles())) diff --git a/connector/forwardconnector/forward_test.go b/connector/forwardconnector/forward_test.go index 7554a25f94..101f3c20c8 100644 --- a/connector/forwardconnector/forward_test.go +++ b/connector/forwardconnector/forward_test.go @@ -23,7 +23,7 @@ func TestForward(t *testing.T) { assert.Equal(t, &Config{}, cfg) ctx := context.Background() - set := connectortest.NewNopSettingsWithType(f.Type()) + set := connectortest.NewNopSettings(f.Type()) host := componenttest.NewNopHost() tracesSink := new(consumertest.TracesSink) diff --git a/connector/forwardconnector/generated_component_test.go b/connector/forwardconnector/generated_component_test.go index e1ea8b0478..8814bd8d64 100644 --- a/connector/forwardconnector/generated_component_test.go +++ b/connector/forwardconnector/generated_component_test.go @@ -70,19 +70,19 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { t.Run(tt.name+"-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), connectortest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), connectortest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) }) t.Run(tt.name+"-lifecycle", func(t *testing.T) { - firstConnector, err := tt.createFn(context.Background(), connectortest.NewNopSettingsWithType(typ), cfg) + firstConnector, err := tt.createFn(context.Background(), connectortest.NewNopSettings(typ), cfg) require.NoError(t, err) host := componenttest.NewNopHost() require.NoError(t, err) require.NoError(t, firstConnector.Start(context.Background(), host)) require.NoError(t, firstConnector.Shutdown(context.Background())) - secondConnector, err := tt.createFn(context.Background(), connectortest.NewNopSettingsWithType(typ), cfg) + secondConnector, err := tt.createFn(context.Background(), connectortest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, secondConnector.Start(context.Background(), host)) require.NoError(t, secondConnector.Shutdown(context.Background())) diff --git a/exporter/debugexporter/exporter_test.go b/exporter/debugexporter/exporter_test.go index c354206619..671aabd878 100644 --- a/exporter/debugexporter/exporter_test.go +++ b/exporter/debugexporter/exporter_test.go @@ -25,7 +25,7 @@ import ( func TestTracesNoErrors(t *testing.T) { for _, tc := range createTestCases() { t.Run(tc.name, func(t *testing.T) { - lte, err := createTraces(context.Background(), exportertest.NewNopSettingsWithType(metadata.Type), tc.config) + lte, err := createTraces(context.Background(), exportertest.NewNopSettings(metadata.Type), tc.config) require.NotNil(t, lte) assert.NoError(t, err) @@ -40,7 +40,7 @@ func TestTracesNoErrors(t *testing.T) { func TestMetricsNoErrors(t *testing.T) { for _, tc := range createTestCases() { t.Run(tc.name, func(t *testing.T) { - lme, err := createMetrics(context.Background(), exportertest.NewNopSettingsWithType(metadata.Type), tc.config) + lme, err := createMetrics(context.Background(), exportertest.NewNopSettings(metadata.Type), tc.config) require.NotNil(t, lme) assert.NoError(t, err) @@ -58,7 +58,7 @@ func TestMetricsNoErrors(t *testing.T) { func TestLogsNoErrors(t *testing.T) { for _, tc := range createTestCases() { t.Run(tc.name, func(t *testing.T) { - lle, err := createLogs(context.Background(), exportertest.NewNopSettingsWithType(metadata.Type), createDefaultConfig()) + lle, err := createLogs(context.Background(), exportertest.NewNopSettings(metadata.Type), createDefaultConfig()) require.NotNil(t, lle) assert.NoError(t, err) @@ -73,7 +73,7 @@ func TestLogsNoErrors(t *testing.T) { func TestProfilesNoErrors(t *testing.T) { for _, tc := range createTestCases() { t.Run(tc.name, func(t *testing.T) { - lle, err := createProfiles(context.Background(), exportertest.NewNopSettingsWithType(metadata.Type), createDefaultConfig()) + lle, err := createProfiles(context.Background(), exportertest.NewNopSettings(metadata.Type), createDefaultConfig()) require.NotNil(t, lle) assert.NoError(t, err) diff --git a/exporter/debugexporter/factory_test.go b/exporter/debugexporter/factory_test.go index 498e97e1ce..509228cfb9 100644 --- a/exporter/debugexporter/factory_test.go +++ b/exporter/debugexporter/factory_test.go @@ -26,7 +26,7 @@ func TestCreateMetrics(t *testing.T) { factory := NewFactory() cfg := factory.CreateDefaultConfig() - me, err := factory.CreateMetrics(context.Background(), exportertest.NewNopSettingsWithType(factory.Type()), cfg) + me, err := factory.CreateMetrics(context.Background(), exportertest.NewNopSettings(factory.Type()), cfg) require.NoError(t, err) assert.NotNil(t, me) } @@ -35,7 +35,7 @@ func TestCreateTraces(t *testing.T) { factory := NewFactory() cfg := factory.CreateDefaultConfig() - te, err := factory.CreateTraces(context.Background(), exportertest.NewNopSettingsWithType(factory.Type()), cfg) + te, err := factory.CreateTraces(context.Background(), exportertest.NewNopSettings(factory.Type()), cfg) require.NoError(t, err) assert.NotNil(t, te) } @@ -44,7 +44,7 @@ func TestCreateLogs(t *testing.T) { factory := NewFactory() cfg := factory.CreateDefaultConfig() - te, err := factory.CreateLogs(context.Background(), exportertest.NewNopSettingsWithType(factory.Type()), cfg) + te, err := factory.CreateLogs(context.Background(), exportertest.NewNopSettings(factory.Type()), cfg) require.NoError(t, err) assert.NotNil(t, te) } @@ -53,7 +53,7 @@ func TestCreateFactoryProfiles(t *testing.T) { factory := NewFactory() cfg := factory.CreateDefaultConfig() - te, err := factory.(xexporter.Factory).CreateProfiles(context.Background(), exportertest.NewNopSettingsWithType(factory.Type()), cfg) + te, err := factory.(xexporter.Factory).CreateProfiles(context.Background(), exportertest.NewNopSettings(factory.Type()), cfg) require.NoError(t, err) assert.NotNil(t, te) } diff --git a/exporter/debugexporter/generated_component_test.go b/exporter/debugexporter/generated_component_test.go index debcc78ae8..a1a503c484 100644 --- a/exporter/debugexporter/generated_component_test.go +++ b/exporter/debugexporter/generated_component_test.go @@ -69,13 +69,13 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { t.Run(tt.name+"-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), exportertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), exportertest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) }) t.Run(tt.name+"-lifecycle", func(t *testing.T) { - c, err := tt.createFn(context.Background(), exportertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), exportertest.NewNopSettings(typ), cfg) require.NoError(t, err) host := componenttest.NewNopHost() err = c.Start(context.Background(), host) diff --git a/exporter/exporterhelper/internal/base_exporter_test.go b/exporter/exporterhelper/internal/base_exporter_test.go index c160649a0a..92915b4549 100644 --- a/exporter/exporterhelper/internal/base_exporter_test.go +++ b/exporter/exporterhelper/internal/base_exporter_test.go @@ -30,7 +30,7 @@ var ( defaultSignal = pipeline.SignalMetrics defaultID = component.NewID(defaultType) defaultSettings = func() exporter.Settings { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) set.ID = defaultID return set }() @@ -68,16 +68,16 @@ func TestBaseExporterWithOptions(t *testing.T) { } func TestQueueOptionsWithRequestExporter(t *testing.T) { - bs, err := NewBaseExporter(exportertest.NewNopSettingsWithType(exportertest.NopType), defaultSignal, + bs, err := NewBaseExporter(exportertest.NewNopSettings(exportertest.NopType), defaultSignal, WithRetry(configretry.NewDefaultBackOffConfig())) require.NoError(t, err) require.Nil(t, bs.Marshaler) require.Nil(t, bs.Unmarshaler) - _, err = NewBaseExporter(exportertest.NewNopSettingsWithType(exportertest.NopType), defaultSignal, + _, err = NewBaseExporter(exportertest.NewNopSettings(exportertest.NopType), defaultSignal, WithRetry(configretry.NewDefaultBackOffConfig()), WithQueue(NewDefaultQueueConfig())) require.Error(t, err) - _, err = NewBaseExporter(exportertest.NewNopSettingsWithType(exportertest.NopType), defaultSignal, + _, err = NewBaseExporter(exportertest.NewNopSettings(exportertest.NopType), defaultSignal, WithMarshaler(mockRequestMarshaler), WithUnmarshaler(mockRequestUnmarshaler(&requesttest.FakeRequest{Items: 1})), WithRetry(configretry.NewDefaultBackOffConfig()), WithRequestQueue(exporterqueue.NewDefaultConfig(), exporterqueue.NewMemoryQueueFactory[request.Request]())) @@ -85,7 +85,7 @@ func TestQueueOptionsWithRequestExporter(t *testing.T) { } func TestBaseExporterLogging(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) logger, observed := observer.New(zap.DebugLevel) set.Logger = zap.New(logger) rCfg := configretry.NewDefaultBackOffConfig() @@ -151,7 +151,7 @@ func TestQueueRetryWithDisabledQueue(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) logger, observed := observer.New(zap.ErrorLevel) set.Logger = zap.New(logger) be, err := NewBaseExporter(set, pipeline.SignalLogs, tt.queueOptions...) diff --git a/exporter/exporterhelper/internal/batcher/disabled_batcher_test.go b/exporter/exporterhelper/internal/batcher/disabled_batcher_test.go index 75dccd1984..09cd3f4a7f 100644 --- a/exporter/exporterhelper/internal/batcher/disabled_batcher_test.go +++ b/exporter/exporterhelper/internal/batcher/disabled_batcher_test.go @@ -49,7 +49,7 @@ func TestDisabledBatcher_Basic(t *testing.T) { context.Background(), exporterqueue.Settings{ Signal: pipeline.SignalTraces, - ExporterSettings: exportertest.NewNopSettingsWithType(exportertest.NopType), + ExporterSettings: exportertest.NewNopSettings(exportertest.NopType), }, exporterqueue.NewDefaultConfig(), ba.Consume) diff --git a/exporter/exporterhelper/internal/queue_sender_test.go b/exporter/exporterhelper/internal/queue_sender_test.go index 80edcc36d5..927af0ad27 100644 --- a/exporter/exporterhelper/internal/queue_sender_test.go +++ b/exporter/exporterhelper/internal/queue_sender_test.go @@ -261,7 +261,7 @@ func TestQueueBatcherPersistentEnabled_NoDataLossOnShutdown(t *testing.T) { } func TestQueueBatcherNoStartShutdown(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) set.ID = exporterID qSet := exporterqueue.Settings{ Signal: pipeline.SignalTraces, diff --git a/exporter/exporterhelper/internal/retry_sender_test.go b/exporter/exporterhelper/internal/retry_sender_test.go index 2e61a64fe2..2a3f753e61 100644 --- a/exporter/exporterhelper/internal/retry_sender_test.go +++ b/exporter/exporterhelper/internal/retry_sender_test.go @@ -39,7 +39,7 @@ func TestRetrySenderDropOnPermanentError(t *testing.T) { rCfg := configretry.NewDefaultBackOffConfig() sink := requesttest.NewSink() expErr := consumererror.NewPermanent(errors.New("bad data")) - rs := newRetrySender(rCfg, exportertest.NewNopSettingsWithType(exportertest.NopType), newNoopExportSender()) + rs := newRetrySender(rCfg, exportertest.NewNopSettings(exportertest.NopType), newNoopExportSender()) require.NoError(t, rs.Start(context.Background(), componenttest.NewNopHost())) require.ErrorIs(t, rs.Send(context.Background(), &requesttest.FakeRequest{Items: 2, Sink: sink, ExportErr: expErr}), expErr) require.ErrorIs(t, rs.Send(context.Background(), &requesttest.FakeRequest{Items: 3, Sink: sink, ExportErr: expErr}), expErr) @@ -53,7 +53,7 @@ func TestRetrySenderSimpleRetry(t *testing.T) { rCfg.InitialInterval = 0 sink := requesttest.NewSink() expErr := errors.New("transient error") - rs := newRetrySender(rCfg, exportertest.NewNopSettingsWithType(exportertest.NopType), newNoopExportSender()) + rs := newRetrySender(rCfg, exportertest.NewNopSettings(exportertest.NopType), newNoopExportSender()) require.NoError(t, rs.Start(context.Background(), componenttest.NewNopHost())) require.NoError(t, rs.Send(context.Background(), &requesttest.FakeRequest{Items: 2, Sink: sink, ExportErr: expErr})) assert.Equal(t, int64(2), sink.ItemsCount()) @@ -65,7 +65,7 @@ func TestRetrySenderRetryPartial(t *testing.T) { rCfg := configretry.NewDefaultBackOffConfig() rCfg.InitialInterval = 0 sink := requesttest.NewSink() - rs := newRetrySender(rCfg, exportertest.NewNopSettingsWithType(exportertest.NopType), newNoopExportSender()) + rs := newRetrySender(rCfg, exportertest.NewNopSettings(exportertest.NopType), newNoopExportSender()) require.NoError(t, rs.Start(context.Background(), componenttest.NewNopHost())) require.NoError(t, rs.Send(context.Background(), &requesttest.FakeRequest{Items: 5, Sink: sink, Partial: 3})) assert.Equal(t, int64(5), sink.ItemsCount()) @@ -78,7 +78,7 @@ func TestRetrySenderMaxElapsedTime(t *testing.T) { rCfg.InitialInterval = time.Millisecond rCfg.MaxElapsedTime = 100 * time.Millisecond sink := requesttest.NewSink() - rs := newRetrySender(rCfg, exportertest.NewNopSettingsWithType(exportertest.NopType), newNoopExportSender()) + rs := newRetrySender(rCfg, exportertest.NewNopSettings(exportertest.NopType), newNoopExportSender()) require.NoError(t, rs.Start(context.Background(), componenttest.NewNopHost())) expErr := errors.New("transient error") require.ErrorIs(t, rs.Send(context.Background(), newErrorRequest(expErr)), expErr) @@ -91,7 +91,7 @@ func TestRetrySenderThrottleError(t *testing.T) { rCfg := configretry.NewDefaultBackOffConfig() rCfg.InitialInterval = 10 * time.Millisecond sink := requesttest.NewSink() - rs := newRetrySender(rCfg, exportertest.NewNopSettingsWithType(exportertest.NopType), newNoopExportSender()) + rs := newRetrySender(rCfg, exportertest.NewNopSettings(exportertest.NopType), newNoopExportSender()) require.NoError(t, rs.Start(context.Background(), componenttest.NewNopHost())) retry := fmt.Errorf("wrappe error: %w", NewThrottleRetry(errors.New("throttle error"), 100*time.Millisecond)) start := time.Now() @@ -112,7 +112,7 @@ func TestRetrySenderWithContextTimeout(t *testing.T) { rCfg.RandomizationFactor = 0 // Second attempt is at twice the testTimeout rCfg.Multiplier = float64(2 * testTimeout / rCfg.InitialInterval) - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) logger, observed := observer.New(zap.InfoLevel) set.Logger = zap.New(logger) rs := newRetrySender(rCfg, set, newNoopExportSender()) @@ -134,7 +134,7 @@ func TestRetrySenderWithCancelledContext(t *testing.T) { rCfg.Enabled = true // First attempt after 1s is attempted rCfg.InitialInterval = 1 * time.Second - rs := newRetrySender(rCfg, exportertest.NewNopSettingsWithType(exportertest.NopType), newNoopExportSender()) + rs := newRetrySender(rCfg, exportertest.NewNopSettings(exportertest.NopType), newNoopExportSender()) require.NoError(t, rs.Start(context.Background(), componenttest.NewNopHost())) start := time.Now() ctx, cancel := context.WithCancelCause(context.Background()) diff --git a/exporter/exporterhelper/logs_test.go b/exporter/exporterhelper/logs_test.go index bd5420e4bc..6a87363925 100644 --- a/exporter/exporterhelper/logs_test.go +++ b/exporter/exporterhelper/logs_test.go @@ -57,7 +57,7 @@ func TestLogsRequest(t *testing.T) { } func TestLogs_InvalidName(t *testing.T) { - le, err := NewLogs(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), nil, newPushLogsData(nil)) + le, err := NewLogs(context.Background(), exportertest.NewNopSettings(exportertest.NopType), nil, newPushLogsData(nil)) require.Nil(t, le) require.Equal(t, errNilConfig, err) } @@ -75,20 +75,20 @@ func TestLogsRequest_NilLogger(t *testing.T) { } func TestLogs_NilPushLogsData(t *testing.T) { - le, err := NewLogs(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeLogsConfig, nil) + le, err := NewLogs(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeLogsConfig, nil) require.Nil(t, le) require.Equal(t, errNilPushLogsData, err) } func TestLogsRequest_NilLogsConverter(t *testing.T) { - le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), nil) + le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), nil) require.Nil(t, le) require.Equal(t, errNilLogsConverter, err) } func TestLogs_Default(t *testing.T) { ld := plog.NewLogs() - le, err := NewLogs(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeLogsConfig, newPushLogsData(nil)) + le, err := NewLogs(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeLogsConfig, newPushLogsData(nil)) assert.NotNil(t, le) require.NoError(t, err) @@ -100,7 +100,7 @@ func TestLogs_Default(t *testing.T) { func TestLogsRequest_Default(t *testing.T) { ld := plog.NewLogs() - le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromLogsFunc(nil)) assert.NotNil(t, le) require.NoError(t, err) @@ -113,7 +113,7 @@ func TestLogsRequest_Default(t *testing.T) { func TestLogs_WithCapabilities(t *testing.T) { capabilities := consumer.Capabilities{MutatesData: true} - le, err := NewLogs(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeLogsConfig, newPushLogsData(nil), WithCapabilities(capabilities)) + le, err := NewLogs(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeLogsConfig, newPushLogsData(nil), WithCapabilities(capabilities)) require.NoError(t, err) require.NotNil(t, le) @@ -122,7 +122,7 @@ func TestLogs_WithCapabilities(t *testing.T) { func TestLogsRequest_WithCapabilities(t *testing.T) { capabilities := consumer.Capabilities{MutatesData: true} - le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromLogsFunc(nil), WithCapabilities(capabilities)) require.NoError(t, err) require.NotNil(t, le) @@ -133,7 +133,7 @@ func TestLogsRequest_WithCapabilities(t *testing.T) { func TestLogs_Default_ReturnError(t *testing.T) { ld := plog.NewLogs() want := errors.New("my_error") - le, err := NewLogs(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeLogsConfig, newPushLogsData(want)) + le, err := NewLogs(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeLogsConfig, newPushLogsData(want)) require.NoError(t, err) require.NotNil(t, le) require.Equal(t, want, le.ConsumeLogs(context.Background(), ld)) @@ -142,7 +142,7 @@ func TestLogs_Default_ReturnError(t *testing.T) { func TestLogsRequest_Default_ConvertError(t *testing.T) { ld := plog.NewLogs() want := errors.New("convert_error") - le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), func(context.Context, plog.Logs) (Request, error) { return nil, want }) @@ -154,7 +154,7 @@ func TestLogsRequest_Default_ConvertError(t *testing.T) { func TestLogsRequest_Default_ExportError(t *testing.T) { ld := plog.NewLogs() want := errors.New("export_error") - le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromLogsFunc(want)) require.NoError(t, err) require.NotNil(t, le) @@ -167,7 +167,7 @@ func TestLogs_WithPersistentQueue(t *testing.T) { qCfg.StorageID = &storageID rCfg := configretry.NewDefaultBackOffConfig() ts := consumertest.LogsSink{} - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) set.ID = component.MustNewIDWithName("test_logs", "with_persistent_queue") te, err := NewLogs(context.Background(), set, &fakeLogsConfig, ts.ConsumeLogs, WithRetry(rCfg), WithQueue(qCfg)) require.NoError(t, err) @@ -257,7 +257,7 @@ func TestLogsRequest_WithRecordMetrics_ExportError(t *testing.T) { } func TestLogs_WithSpan(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -270,7 +270,7 @@ func TestLogs_WithSpan(t *testing.T) { } func TestLogsRequest_WithSpan(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -283,7 +283,7 @@ func TestLogsRequest_WithSpan(t *testing.T) { } func TestLogs_WithSpan_ReturnError(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -297,7 +297,7 @@ func TestLogs_WithSpan_ReturnError(t *testing.T) { } func TestLogsRequest_WithSpan_ReturnError(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -314,7 +314,7 @@ func TestLogs_WithShutdown(t *testing.T) { shutdownCalled := false shutdown := func(context.Context) error { shutdownCalled = true; return nil } - le, err := NewLogs(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeLogsConfig, newPushLogsData(nil), WithShutdown(shutdown)) + le, err := NewLogs(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeLogsConfig, newPushLogsData(nil), WithShutdown(shutdown)) assert.NotNil(t, le) assert.NoError(t, err) @@ -326,7 +326,7 @@ func TestLogsRequest_WithShutdown(t *testing.T) { shutdownCalled := false shutdown := func(context.Context) error { shutdownCalled = true; return nil } - le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromLogsFunc(nil), WithShutdown(shutdown)) assert.NotNil(t, le) assert.NoError(t, err) @@ -339,7 +339,7 @@ func TestLogs_WithShutdown_ReturnError(t *testing.T) { want := errors.New("my_error") shutdownErr := func(context.Context) error { return want } - le, err := NewLogs(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeLogsConfig, newPushLogsData(nil), WithShutdown(shutdownErr)) + le, err := NewLogs(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeLogsConfig, newPushLogsData(nil), WithShutdown(shutdownErr)) assert.NotNil(t, le) require.NoError(t, err) @@ -350,7 +350,7 @@ func TestLogsRequest_WithShutdown_ReturnError(t *testing.T) { want := errors.New("my_error") shutdownErr := func(context.Context) error { return want } - le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromLogsFunc(nil), WithShutdown(shutdownErr)) assert.NotNil(t, le) require.NoError(t, err) diff --git a/exporter/exporterhelper/metrics_test.go b/exporter/exporterhelper/metrics_test.go index 653e0e827f..82303a222c 100644 --- a/exporter/exporterhelper/metrics_test.go +++ b/exporter/exporterhelper/metrics_test.go @@ -57,7 +57,7 @@ func TestMetricsRequest(t *testing.T) { } func TestMetrics_NilConfig(t *testing.T) { - me, err := NewMetrics(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), nil, newPushMetricsData(nil)) + me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(exportertest.NopType), nil, newPushMetricsData(nil)) require.Nil(t, me) require.Equal(t, errNilConfig, err) } @@ -76,20 +76,20 @@ func TestMetricsRequest_NilLogger(t *testing.T) { } func TestMetrics_NilPushMetricsData(t *testing.T) { - me, err := NewMetrics(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeMetricsConfig, nil) + me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeMetricsConfig, nil) require.Nil(t, me) require.Equal(t, errNilPushMetricsData, err) } func TestMetricsRequest_NilMetricsConverter(t *testing.T) { - me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), nil) + me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), nil) require.Nil(t, me) require.Equal(t, errNilMetricsConverter, err) } func TestMetrics_Default(t *testing.T) { md := pmetric.NewMetrics() - me, err := NewMetrics(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeMetricsConfig, newPushMetricsData(nil)) + me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeMetricsConfig, newPushMetricsData(nil)) require.NoError(t, err) assert.NotNil(t, me) @@ -101,7 +101,7 @@ func TestMetrics_Default(t *testing.T) { func TestMetricsRequest_Default(t *testing.T) { md := pmetric.NewMetrics() - me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromMetricsFunc(nil)) require.NoError(t, err) assert.NotNil(t, me) @@ -114,7 +114,7 @@ func TestMetricsRequest_Default(t *testing.T) { func TestMetrics_WithCapabilities(t *testing.T) { capabilities := consumer.Capabilities{MutatesData: true} - me, err := NewMetrics(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeMetricsConfig, newPushMetricsData(nil), WithCapabilities(capabilities)) + me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeMetricsConfig, newPushMetricsData(nil), WithCapabilities(capabilities)) require.NoError(t, err) assert.NotNil(t, me) @@ -123,7 +123,7 @@ func TestMetrics_WithCapabilities(t *testing.T) { func TestMetricsRequest_WithCapabilities(t *testing.T) { capabilities := consumer.Capabilities{MutatesData: true} - me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromMetricsFunc(nil), WithCapabilities(capabilities)) require.NoError(t, err) assert.NotNil(t, me) @@ -134,7 +134,7 @@ func TestMetricsRequest_WithCapabilities(t *testing.T) { func TestMetrics_Default_ReturnError(t *testing.T) { md := pmetric.NewMetrics() want := errors.New("my_error") - me, err := NewMetrics(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeMetricsConfig, newPushMetricsData(want)) + me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeMetricsConfig, newPushMetricsData(want)) require.NoError(t, err) require.NotNil(t, me) require.Equal(t, want, me.ConsumeMetrics(context.Background(), md)) @@ -143,7 +143,7 @@ func TestMetrics_Default_ReturnError(t *testing.T) { func TestMetricsRequest_Default_ConvertError(t *testing.T) { md := pmetric.NewMetrics() want := errors.New("convert_error") - me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), func(context.Context, pmetric.Metrics) (Request, error) { return nil, want }) @@ -155,7 +155,7 @@ func TestMetricsRequest_Default_ConvertError(t *testing.T) { func TestMetricsRequest_Default_ExportError(t *testing.T) { md := pmetric.NewMetrics() want := errors.New("export_error") - me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromMetricsFunc(want)) require.NoError(t, err) require.NotNil(t, me) @@ -168,7 +168,7 @@ func TestMetrics_WithPersistentQueue(t *testing.T) { qCfg.StorageID = &storageID rCfg := configretry.NewDefaultBackOffConfig() ms := consumertest.MetricsSink{} - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) set.ID = component.MustNewIDWithName("test_metrics", "with_persistent_queue") te, err := NewMetrics(context.Background(), set, &fakeMetricsConfig, ms.ConsumeMetrics, WithRetry(rCfg), WithQueue(qCfg)) require.NoError(t, err) @@ -259,7 +259,7 @@ func TestMetricsRequest_WithRecordMetrics_ExportError(t *testing.T) { } func TestMetrics_WithSpan(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -272,7 +272,7 @@ func TestMetrics_WithSpan(t *testing.T) { } func TestMetricsRequest_WithSpan(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -285,7 +285,7 @@ func TestMetricsRequest_WithSpan(t *testing.T) { } func TestMetrics_WithSpan_ReturnError(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -299,7 +299,7 @@ func TestMetrics_WithSpan_ReturnError(t *testing.T) { } func TestMetricsRequest_WithSpan_ExportError(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -316,7 +316,7 @@ func TestMetrics_WithShutdown(t *testing.T) { shutdownCalled := false shutdown := func(context.Context) error { shutdownCalled = true; return nil } - me, err := NewMetrics(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeMetricsConfig, newPushMetricsData(nil), WithShutdown(shutdown)) + me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeMetricsConfig, newPushMetricsData(nil), WithShutdown(shutdown)) assert.NotNil(t, me) assert.NoError(t, err) @@ -329,7 +329,7 @@ func TestMetricsRequest_WithShutdown(t *testing.T) { shutdownCalled := false shutdown := func(context.Context) error { shutdownCalled = true; return nil } - me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromMetricsFunc(nil), WithShutdown(shutdown)) assert.NotNil(t, me) assert.NoError(t, err) @@ -343,7 +343,7 @@ func TestMetrics_WithShutdown_ReturnError(t *testing.T) { want := errors.New("my_error") shutdownErr := func(context.Context) error { return want } - me, err := NewMetrics(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeMetricsConfig, newPushMetricsData(nil), WithShutdown(shutdownErr)) + me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeMetricsConfig, newPushMetricsData(nil), WithShutdown(shutdownErr)) assert.NotNil(t, me) assert.NoError(t, err) @@ -355,7 +355,7 @@ func TestMetricsRequest_WithShutdown_ReturnError(t *testing.T) { want := errors.New("my_error") shutdownErr := func(context.Context) error { return want } - me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromMetricsFunc(nil), WithShutdown(shutdownErr)) assert.NotNil(t, me) assert.NoError(t, err) diff --git a/exporter/exporterhelper/traces_test.go b/exporter/exporterhelper/traces_test.go index b0e339c6a0..5a9d9e9d5d 100644 --- a/exporter/exporterhelper/traces_test.go +++ b/exporter/exporterhelper/traces_test.go @@ -53,7 +53,7 @@ func TestTracesRequest(t *testing.T) { } func TestTraces_InvalidName(t *testing.T) { - te, err := NewTraces(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), nil, newTraceDataPusher(nil)) + te, err := NewTraces(context.Background(), exportertest.NewNopSettings(exportertest.NopType), nil, newTraceDataPusher(nil)) require.Nil(t, te) require.Equal(t, errNilConfig, err) } @@ -71,20 +71,20 @@ func TestTracesRequest_NilLogger(t *testing.T) { } func TestTraces_NilPushTraceData(t *testing.T) { - te, err := NewTraces(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeTracesConfig, nil) + te, err := NewTraces(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeTracesConfig, nil) require.Nil(t, te) require.Equal(t, errNilPushTraceData, err) } func TestTracesRequest_NilTracesConverter(t *testing.T) { - te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), nil) + te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), nil) require.Nil(t, te) require.Equal(t, errNilTracesConverter, err) } func TestTraces_Default(t *testing.T) { td := ptrace.NewTraces() - te, err := NewTraces(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeTracesConfig, newTraceDataPusher(nil)) + te, err := NewTraces(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeTracesConfig, newTraceDataPusher(nil)) assert.NotNil(t, te) require.NoError(t, err) @@ -96,7 +96,7 @@ func TestTraces_Default(t *testing.T) { func TestTracesRequest_Default(t *testing.T) { td := ptrace.NewTraces() - te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromTracesFunc(nil)) assert.NotNil(t, te) require.NoError(t, err) @@ -109,7 +109,7 @@ func TestTracesRequest_Default(t *testing.T) { func TestTraces_WithCapabilities(t *testing.T) { capabilities := consumer.Capabilities{MutatesData: true} - te, err := NewTraces(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeTracesConfig, newTraceDataPusher(nil), WithCapabilities(capabilities)) + te, err := NewTraces(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeTracesConfig, newTraceDataPusher(nil), WithCapabilities(capabilities)) assert.NotNil(t, te) require.NoError(t, err) @@ -118,7 +118,7 @@ func TestTraces_WithCapabilities(t *testing.T) { func TestTracesRequest_WithCapabilities(t *testing.T) { capabilities := consumer.Capabilities{MutatesData: true} - te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromTracesFunc(nil), WithCapabilities(capabilities)) assert.NotNil(t, te) require.NoError(t, err) @@ -129,7 +129,7 @@ func TestTracesRequest_WithCapabilities(t *testing.T) { func TestTraces_Default_ReturnError(t *testing.T) { td := ptrace.NewTraces() want := errors.New("my_error") - te, err := NewTraces(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeTracesConfig, newTraceDataPusher(want)) + te, err := NewTraces(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeTracesConfig, newTraceDataPusher(want)) require.NoError(t, err) require.NotNil(t, te) @@ -140,7 +140,7 @@ func TestTraces_Default_ReturnError(t *testing.T) { func TestTracesRequest_Default_ConvertError(t *testing.T) { td := ptrace.NewTraces() want := errors.New("convert_error") - te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), func(context.Context, ptrace.Traces) (Request, error) { return nil, want }) @@ -152,7 +152,7 @@ func TestTracesRequest_Default_ConvertError(t *testing.T) { func TestTracesRequest_Default_ExportError(t *testing.T) { td := ptrace.NewTraces() want := errors.New("export_error") - te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromTracesFunc(want)) require.NoError(t, err) require.NotNil(t, te) @@ -165,7 +165,7 @@ func TestTraces_WithPersistentQueue(t *testing.T) { qCfg.StorageID = &storageID rCfg := configretry.NewDefaultBackOffConfig() ts := consumertest.TracesSink{} - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) set.ID = component.MustNewIDWithName("test_traces", "with_persistent_queue") te, err := NewTraces(context.Background(), set, &fakeTracesConfig, ts.ConsumeTraces, WithRetry(rCfg), WithQueue(qCfg)) require.NoError(t, err) @@ -256,7 +256,7 @@ func TestTracesRequest_WithRecordMetrics_RequestSenderError(t *testing.T) { } func TestTraces_WithSpan(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -270,7 +270,7 @@ func TestTraces_WithSpan(t *testing.T) { } func TestTracesRequest_WithSpan(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -284,7 +284,7 @@ func TestTracesRequest_WithSpan(t *testing.T) { } func TestTraces_WithSpan_ReturnError(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -299,7 +299,7 @@ func TestTraces_WithSpan_ReturnError(t *testing.T) { } func TestTracesRequest_WithSpan_ExportError(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -317,7 +317,7 @@ func TestTraces_WithShutdown(t *testing.T) { shutdownCalled := false shutdown := func(context.Context) error { shutdownCalled = true; return nil } - te, err := NewTraces(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeTracesConfig, newTraceDataPusher(nil), WithShutdown(shutdown)) + te, err := NewTraces(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeTracesConfig, newTraceDataPusher(nil), WithShutdown(shutdown)) assert.NotNil(t, te) assert.NoError(t, err) @@ -330,7 +330,7 @@ func TestTracesRequest_WithShutdown(t *testing.T) { shutdownCalled := false shutdown := func(context.Context) error { shutdownCalled = true; return nil } - te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromTracesFunc(nil), WithShutdown(shutdown)) assert.NotNil(t, te) assert.NoError(t, err) @@ -344,7 +344,7 @@ func TestTraces_WithShutdown_ReturnError(t *testing.T) { want := errors.New("my_error") shutdownErr := func(context.Context) error { return want } - te, err := NewTraces(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeTracesConfig, newTraceDataPusher(nil), WithShutdown(shutdownErr)) + te, err := NewTraces(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeTracesConfig, newTraceDataPusher(nil), WithShutdown(shutdownErr)) assert.NotNil(t, te) assert.NoError(t, err) @@ -356,7 +356,7 @@ func TestTracesRequest_WithShutdown_ReturnError(t *testing.T) { want := errors.New("my_error") shutdownErr := func(context.Context) error { return want } - te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requesttest.RequestFromTracesFunc(nil), WithShutdown(shutdownErr)) assert.NotNil(t, te) assert.NoError(t, err) diff --git a/exporter/exporterhelper/xexporterhelper/profiles_test.go b/exporter/exporterhelper/xexporterhelper/profiles_test.go index f5cb43b7d4..0fb0561a54 100644 --- a/exporter/exporterhelper/xexporterhelper/profiles_test.go +++ b/exporter/exporterhelper/xexporterhelper/profiles_test.go @@ -55,7 +55,7 @@ func TestProfilesRequest(t *testing.T) { } func TestProfilesExporter_InvalidName(t *testing.T) { - le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), nil, newPushProfilesData(nil)) + le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), nil, newPushProfilesData(nil)) require.Nil(t, le) require.Equal(t, errNilConfig, err) } @@ -73,20 +73,20 @@ func TestProfilesRequestExporter_NilLogger(t *testing.T) { } func TestProfilesExporter_NilPushProfilesData(t *testing.T) { - le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeProfilesExporterConfig, nil) + le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeProfilesExporterConfig, nil) require.Nil(t, le) require.Equal(t, errNilPushProfileData, err) } func TestProfilesRequestExporter_NilProfilesConverter(t *testing.T) { - le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), nil) + le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), nil) require.Nil(t, le) require.Equal(t, errNilProfilesConverter, err) } func TestProfilesExporter_Default(t *testing.T) { ld := pprofile.NewProfiles() - le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeProfilesExporterConfig, newPushProfilesData(nil)) + le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeProfilesExporterConfig, newPushProfilesData(nil)) assert.NotNil(t, le) require.NoError(t, err) @@ -98,7 +98,7 @@ func TestProfilesExporter_Default(t *testing.T) { func TestProfilesRequestExporter_Default(t *testing.T) { ld := pprofile.NewProfiles() - le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requestFromProfilesFunc(nil)) assert.NotNil(t, le) require.NoError(t, err) @@ -111,7 +111,7 @@ func TestProfilesRequestExporter_Default(t *testing.T) { func TestProfilesExporter_WithCapabilities(t *testing.T) { capabilities := consumer.Capabilities{MutatesData: true} - le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeProfilesExporterConfig, newPushProfilesData(nil), exporterhelper.WithCapabilities(capabilities)) + le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeProfilesExporterConfig, newPushProfilesData(nil), exporterhelper.WithCapabilities(capabilities)) require.NoError(t, err) require.NotNil(t, le) @@ -120,7 +120,7 @@ func TestProfilesExporter_WithCapabilities(t *testing.T) { func TestProfilesRequestExporter_WithCapabilities(t *testing.T) { capabilities := consumer.Capabilities{MutatesData: true} - le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requestFromProfilesFunc(nil), exporterhelper.WithCapabilities(capabilities)) require.NoError(t, err) require.NotNil(t, le) @@ -131,7 +131,7 @@ func TestProfilesRequestExporter_WithCapabilities(t *testing.T) { func TestProfilesExporter_Default_ReturnError(t *testing.T) { ld := pprofile.NewProfiles() want := errors.New("my_error") - le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeProfilesExporterConfig, newPushProfilesData(want)) + le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeProfilesExporterConfig, newPushProfilesData(want)) require.NoError(t, err) require.NotNil(t, le) require.Equal(t, want, le.ConsumeProfiles(context.Background(), ld)) @@ -140,7 +140,7 @@ func TestProfilesExporter_Default_ReturnError(t *testing.T) { func TestProfilesRequestExporter_Default_ConvertError(t *testing.T) { ld := pprofile.NewProfiles() want := errors.New("convert_error") - le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), func(context.Context, pprofile.Profiles) (exporterhelper.Request, error) { return nil, want }) @@ -152,7 +152,7 @@ func TestProfilesRequestExporter_Default_ConvertError(t *testing.T) { func TestProfilesRequestExporter_Default_ExportError(t *testing.T) { ld := pprofile.NewProfiles() want := errors.New("export_error") - le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requestFromProfilesFunc(want)) require.NoError(t, err) require.NotNil(t, le) @@ -165,7 +165,7 @@ func TestProfilesExporter_WithPersistentQueue(t *testing.T) { qCfg.StorageID = &storageID rCfg := configretry.NewDefaultBackOffConfig() ts := consumertest.ProfilesSink{} - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) set.ID = component.MustNewIDWithName("test_profiles", "with_persistent_queue") te, err := NewProfilesExporter(context.Background(), set, &fakeProfilesExporterConfig, ts.ConsumeProfiles, exporterhelper.WithRetry(rCfg), exporterhelper.WithQueue(qCfg)) require.NoError(t, err) @@ -184,7 +184,7 @@ func TestProfilesExporter_WithPersistentQueue(t *testing.T) { } func TestProfilesExporter_WithSpan(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -197,7 +197,7 @@ func TestProfilesExporter_WithSpan(t *testing.T) { } func TestProfilesRequestExporter_WithSpan(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -210,7 +210,7 @@ func TestProfilesRequestExporter_WithSpan(t *testing.T) { } func TestProfilesExporter_WithSpan_ReturnError(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -224,7 +224,7 @@ func TestProfilesExporter_WithSpan_ReturnError(t *testing.T) { } func TestProfilesRequestExporter_WithSpan_ReturnError(t *testing.T) { - set := exportertest.NewNopSettingsWithType(exportertest.NopType) + set := exportertest.NewNopSettings(exportertest.NopType) sr := new(tracetest.SpanRecorder) set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr)) otel.SetTracerProvider(set.TracerProvider) @@ -241,7 +241,7 @@ func TestProfilesExporter_WithShutdown(t *testing.T) { shutdownCalled := false shutdown := func(context.Context) error { shutdownCalled = true; return nil } - le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeProfilesExporterConfig, newPushProfilesData(nil), exporterhelper.WithShutdown(shutdown)) + le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeProfilesExporterConfig, newPushProfilesData(nil), exporterhelper.WithShutdown(shutdown)) assert.NotNil(t, le) require.NoError(t, err) @@ -253,7 +253,7 @@ func TestProfilesRequestExporter_WithShutdown(t *testing.T) { shutdownCalled := false shutdown := func(context.Context) error { shutdownCalled = true; return nil } - le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requestFromProfilesFunc(nil), exporterhelper.WithShutdown(shutdown)) assert.NotNil(t, le) require.NoError(t, err) @@ -266,7 +266,7 @@ func TestProfilesExporter_WithShutdown_ReturnError(t *testing.T) { want := errors.New("my_error") shutdownErr := func(context.Context) error { return want } - le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), &fakeProfilesExporterConfig, newPushProfilesData(nil), exporterhelper.WithShutdown(shutdownErr)) + le, err := NewProfilesExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), &fakeProfilesExporterConfig, newPushProfilesData(nil), exporterhelper.WithShutdown(shutdownErr)) assert.NotNil(t, le) require.NoError(t, err) @@ -277,7 +277,7 @@ func TestProfilesRequestExporter_WithShutdown_ReturnError(t *testing.T) { want := errors.New("my_error") shutdownErr := func(context.Context) error { return want } - le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettingsWithType(exportertest.NopType), + le, err := NewProfilesRequestExporter(context.Background(), exportertest.NewNopSettings(exportertest.NopType), requestFromProfilesFunc(nil), exporterhelper.WithShutdown(shutdownErr)) assert.NotNil(t, le) require.NoError(t, err) diff --git a/exporter/exporterqueue/persistent_queue_test.go b/exporter/exporterqueue/persistent_queue_test.go index b7c57f6fb7..ffb897f41a 100644 --- a/exporter/exporterqueue/persistent_queue_test.go +++ b/exporter/exporterqueue/persistent_queue_test.go @@ -227,7 +227,7 @@ func createAndStartTestPersistentQueue(t *testing.T, sizer sizer[uint64], capaci storageID: component.ID{}, marshaler: uint64Marshaler, unmarshaler: uint64Unmarshaler, - set: exportertest.NewNopSettingsWithType(exportertest.NopType), + set: exportertest.NewNopSettings(exportertest.NopType), }) ac := newAsyncQueue(pq, numConsumers, func(ctx context.Context, item uint64, done Done) { done.OnDone(consumeFunc(ctx, item)) @@ -250,7 +250,7 @@ func createTestPersistentQueueWithClient(client storage.Client) *persistentQueue storageID: component.ID{}, marshaler: uint64Marshaler, unmarshaler: uint64Unmarshaler, - set: exportertest.NewNopSettingsWithType(exportertest.NopType), + set: exportertest.NewNopSettings(exportertest.NopType), }).(*persistentQueue[uint64]) pq.initClient(context.Background(), client) return pq @@ -274,7 +274,7 @@ func createTestPersistentQueueWithCapacityLimiter(tb testing.TB, ext storage.Ext storageID: component.ID{}, marshaler: uint64Marshaler, unmarshaler: uint64Unmarshaler, - set: exportertest.NewNopSettingsWithType(exportertest.NopType), + set: exportertest.NewNopSettings(exportertest.NopType), }).(*persistentQueue[uint64]) require.NoError(tb, pq.Start(context.Background(), &mockHost{ext: map[component.ID]component.Component{{}: ext}})) return pq @@ -422,7 +422,7 @@ func TestPersistentBlockingQueue(t *testing.T) { storageID: component.ID{}, marshaler: uint64Marshaler, unmarshaler: uint64Unmarshaler, - set: exportertest.NewNopSettingsWithType(exportertest.NopType), + set: exportertest.NewNopSettings(exportertest.NopType), }) consumed := &atomic.Int64{} ac := newAsyncQueue(pq, 10, func(_ context.Context, _ uint64, done Done) { @@ -524,7 +524,7 @@ func TestInvalidStorageExtensionType(t *testing.T) { // make a test extension factory := extensiontest.NewNopFactory() extConfig := factory.CreateDefaultConfig() - settings := extensiontest.NewNopSettingsWithType(factory.Type()) + settings := extensiontest.NewNopSettings(factory.Type()) extension, err := factory.Create(context.Background(), settings, extConfig) require.NoError(t, err) extensions := map[component.ID]component.Component{ diff --git a/exporter/exportertest/contract_checker.go b/exporter/exportertest/contract_checker.go index 86fbbf5622..7a3a61ff5f 100644 --- a/exporter/exportertest/contract_checker.go +++ b/exporter/exportertest/contract_checker.go @@ -86,17 +86,17 @@ func checkConsumeContractScenario(t *testing.T, params CheckConsumeContractParam mockConsumerInstance := newMockConsumer(decisionFunc) switch params.Signal { case pipeline.SignalLogs: - r, err := params.ReceiverFactory.CreateLogs(context.Background(), receivertest.NewNopSettingsWithType(params.ReceiverFactory.Type()), params.ReceiverConfig, &mockConsumerInstance) + r, err := params.ReceiverFactory.CreateLogs(context.Background(), receivertest.NewNopSettings(params.ReceiverFactory.Type()), params.ReceiverConfig, &mockConsumerInstance) require.NoError(t, err) require.NoError(t, r.Start(context.Background(), componenttest.NewNopHost())) checkLogs(t, params, r, &mockConsumerInstance, checkIfTestPassed) case pipeline.SignalTraces: - r, err := params.ReceiverFactory.CreateTraces(context.Background(), receivertest.NewNopSettingsWithType(params.ReceiverFactory.Type()), params.ReceiverConfig, &mockConsumerInstance) + r, err := params.ReceiverFactory.CreateTraces(context.Background(), receivertest.NewNopSettings(params.ReceiverFactory.Type()), params.ReceiverConfig, &mockConsumerInstance) require.NoError(t, err) require.NoError(t, r.Start(context.Background(), componenttest.NewNopHost())) checkTraces(t, params, r, &mockConsumerInstance, checkIfTestPassed) case pipeline.SignalMetrics: - r, err := params.ReceiverFactory.CreateMetrics(context.Background(), receivertest.NewNopSettingsWithType(params.ReceiverFactory.Type()), params.ReceiverConfig, &mockConsumerInstance) + r, err := params.ReceiverFactory.CreateMetrics(context.Background(), receivertest.NewNopSettings(params.ReceiverFactory.Type()), params.ReceiverConfig, &mockConsumerInstance) require.NoError(t, err) require.NoError(t, r.Start(context.Background(), componenttest.NewNopHost())) checkMetrics(t, params, r, &mockConsumerInstance, checkIfTestPassed) @@ -111,7 +111,7 @@ func checkMetrics(t *testing.T, params CheckConsumeContractParams, mockReceiver ctx := context.Background() var exp exporter.Metrics var err error - exp, err = params.ExporterFactory.CreateMetrics(ctx, NewNopSettingsWithType(params.ExporterFactory.Type()), params.ExporterConfig) + exp, err = params.ExporterFactory.CreateMetrics(ctx, NewNopSettings(params.ExporterFactory.Type()), params.ExporterConfig) require.NoError(t, err) require.NotNil(t, exp) @@ -151,7 +151,7 @@ func checkTraces(t *testing.T, params CheckConsumeContractParams, mockReceiver c ctx := context.Background() var exp exporter.Traces var err error - exp, err = params.ExporterFactory.CreateTraces(ctx, NewNopSettingsWithType(NopType), params.ExporterConfig) + exp, err = params.ExporterFactory.CreateTraces(ctx, NewNopSettings(NopType), params.ExporterConfig) require.NoError(t, err) require.NotNil(t, exp) @@ -191,7 +191,7 @@ func checkLogs(t *testing.T, params CheckConsumeContractParams, mockReceiver com ctx := context.Background() var exp exporter.Logs var err error - exp, err = params.ExporterFactory.CreateLogs(ctx, NewNopSettingsWithType(NopType), params.ExporterConfig) + exp, err = params.ExporterFactory.CreateLogs(ctx, NewNopSettings(NopType), params.ExporterConfig) require.NoError(t, err) require.NotNil(t, exp) diff --git a/exporter/exportertest/nop_exporter.go b/exporter/exportertest/nop_exporter.go index 415d2f5434..a1c70e4c4d 100644 --- a/exporter/exportertest/nop_exporter.go +++ b/exporter/exportertest/nop_exporter.go @@ -17,12 +17,16 @@ import ( var NopType = component.MustNewType("nop") -// NewNopSettings returns a new nop settings for Create* functions. -// Deprecated: [v0.120.0] Use NewNopSettingsWithType instead. -func NewNopSettings() exporter.Settings { - return NewNopSettingsWithType(NopType) +// NewNopSettings returns a new nop settings for Create* functions with the given type. +func NewNopSettings(typ component.Type) exporter.Settings { + return exporter.Settings{ + ID: component.NewIDWithName(typ, uuid.NewString()), + TelemetrySettings: componenttest.NewNopTelemetrySettings(), + BuildInfo: component.NewDefaultBuildInfo(), + } } +// Deprecated: [v0.121.0] Use NewNopSettings(NopType) instead. // NewNopSettingsWithType returns a new nop settings for Create* functions with the given type. func NewNopSettingsWithType(typ component.Type) exporter.Settings { return exporter.Settings{ diff --git a/exporter/exportertest/nop_exporter_test.go b/exporter/exportertest/nop_exporter_test.go index 610d77556b..2b6e96c3f0 100644 --- a/exporter/exportertest/nop_exporter_test.go +++ b/exporter/exportertest/nop_exporter_test.go @@ -26,25 +26,25 @@ func TestNewNopFactory(t *testing.T) { cfg := factory.CreateDefaultConfig() assert.Equal(t, &nopConfig{}, cfg) - traces, err := factory.CreateTraces(context.Background(), NewNopSettingsWithType(NopType), cfg) + traces, err := factory.CreateTraces(context.Background(), NewNopSettings(NopType), cfg) require.NoError(t, err) assert.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, traces.ConsumeTraces(context.Background(), ptrace.NewTraces())) assert.NoError(t, traces.Shutdown(context.Background())) - metrics, err := factory.CreateMetrics(context.Background(), NewNopSettingsWithType(NopType), cfg) + metrics, err := factory.CreateMetrics(context.Background(), NewNopSettings(NopType), cfg) require.NoError(t, err) assert.NoError(t, metrics.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, metrics.ConsumeMetrics(context.Background(), pmetric.NewMetrics())) assert.NoError(t, metrics.Shutdown(context.Background())) - logs, err := factory.CreateLogs(context.Background(), NewNopSettingsWithType(NopType), cfg) + logs, err := factory.CreateLogs(context.Background(), NewNopSettings(NopType), cfg) require.NoError(t, err) assert.NoError(t, logs.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, logs.ConsumeLogs(context.Background(), plog.NewLogs())) assert.NoError(t, logs.Shutdown(context.Background())) - profiles, err := factory.(xexporter.Factory).CreateProfiles(context.Background(), NewNopSettingsWithType(NopType), cfg) + profiles, err := factory.(xexporter.Factory).CreateProfiles(context.Background(), NewNopSettings(NopType), cfg) require.NoError(t, err) assert.NoError(t, profiles.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, profiles.ConsumeProfiles(context.Background(), pprofile.NewProfiles())) diff --git a/exporter/nopexporter/generated_component_test.go b/exporter/nopexporter/generated_component_test.go index 12adc21a8f..ea06ba9701 100644 --- a/exporter/nopexporter/generated_component_test.go +++ b/exporter/nopexporter/generated_component_test.go @@ -69,13 +69,13 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { t.Run(tt.name+"-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), exportertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), exportertest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) }) t.Run(tt.name+"-lifecycle", func(t *testing.T) { - c, err := tt.createFn(context.Background(), exportertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), exportertest.NewNopSettings(typ), cfg) require.NoError(t, err) host := componenttest.NewNopHost() err = c.Start(context.Background(), host) diff --git a/exporter/nopexporter/nop_exporter_test.go b/exporter/nopexporter/nop_exporter_test.go index 9754ccd8b0..22e1c7ce59 100644 --- a/exporter/nopexporter/nop_exporter_test.go +++ b/exporter/nopexporter/nop_exporter_test.go @@ -25,19 +25,19 @@ func TestNewNopFactory(t *testing.T) { cfg := factory.CreateDefaultConfig() assert.Equal(t, &struct{}{}, cfg) - traces, err := factory.CreateTraces(context.Background(), exportertest.NewNopSettingsWithType(factory.Type()), cfg) + traces, err := factory.CreateTraces(context.Background(), exportertest.NewNopSettings(factory.Type()), cfg) require.NoError(t, err) assert.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, traces.ConsumeTraces(context.Background(), ptrace.NewTraces())) assert.NoError(t, traces.Shutdown(context.Background())) - metrics, err := factory.CreateMetrics(context.Background(), exportertest.NewNopSettingsWithType(factory.Type()), cfg) + metrics, err := factory.CreateMetrics(context.Background(), exportertest.NewNopSettings(factory.Type()), cfg) require.NoError(t, err) assert.NoError(t, metrics.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, metrics.ConsumeMetrics(context.Background(), pmetric.NewMetrics())) assert.NoError(t, metrics.Shutdown(context.Background())) - logs, err := factory.CreateLogs(context.Background(), exportertest.NewNopSettingsWithType(factory.Type()), cfg) + logs, err := factory.CreateLogs(context.Background(), exportertest.NewNopSettings(factory.Type()), cfg) require.NoError(t, err) assert.NoError(t, logs.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, logs.ConsumeLogs(context.Background(), plog.NewLogs())) diff --git a/exporter/otlpexporter/factory_test.go b/exporter/otlpexporter/factory_test.go index 19db68d990..1f3e502fa2 100644 --- a/exporter/otlpexporter/factory_test.go +++ b/exporter/otlpexporter/factory_test.go @@ -42,7 +42,7 @@ func TestCreateMetrics(t *testing.T) { cfg := factory.CreateDefaultConfig().(*Config) cfg.ClientConfig.Endpoint = testutil.GetAvailableLocalAddress(t) - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) oexp, err := factory.CreateMetrics(context.Background(), set, cfg) require.NoError(t, err) require.NotNil(t, oexp) @@ -167,7 +167,7 @@ func TestCreateTraces(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { factory := NewFactory() - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) consumer, err := factory.CreateTraces(context.Background(), set, tt.config) require.NoError(t, err) assert.NotNil(t, consumer) @@ -193,7 +193,7 @@ func TestCreateLogs(t *testing.T) { cfg := factory.CreateDefaultConfig().(*Config) cfg.ClientConfig.Endpoint = testutil.GetAvailableLocalAddress(t) - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) oexp, err := factory.CreateLogs(context.Background(), set, cfg) require.NoError(t, err) require.NotNil(t, oexp) @@ -318,7 +318,7 @@ func TestCreateProfiles(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { factory := NewFactory() - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) consumer, err := factory.(xexporter.Factory).CreateProfiles(context.Background(), set, tt.config) require.NoError(t, err) assert.NotNil(t, consumer) diff --git a/exporter/otlpexporter/generated_component_test.go b/exporter/otlpexporter/generated_component_test.go index 1fdc76cb16..6e78d30042 100644 --- a/exporter/otlpexporter/generated_component_test.go +++ b/exporter/otlpexporter/generated_component_test.go @@ -69,13 +69,13 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { t.Run(tt.name+"-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), exportertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), exportertest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) }) t.Run(tt.name+"-lifecycle", func(t *testing.T) { - c, err := tt.createFn(context.Background(), exportertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), exportertest.NewNopSettings(typ), cfg) require.NoError(t, err) host := componenttest.NewNopHost() err = c.Start(context.Background(), host) diff --git a/exporter/otlpexporter/otlp_test.go b/exporter/otlpexporter/otlp_test.go index f2802aaba5..94e194bd66 100644 --- a/exporter/otlpexporter/otlp_test.go +++ b/exporter/otlpexporter/otlp_test.go @@ -313,7 +313,7 @@ func TestSendTraces(t *testing.T) { "header": "header-value", }, } - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) set.BuildInfo.Description = "Collector" set.BuildInfo.Version = "1.2.3test" @@ -432,7 +432,7 @@ func TestSendTracesWhenEndpointHasHttpScheme(t *testing.T) { if test.useTLS { cfg.ClientConfig.TLSSetting.InsecureSkipVerify = true } - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) exp, err := factory.CreateTraces(context.Background(), set, cfg) require.NoError(t, err) require.NotNil(t, exp) @@ -485,7 +485,7 @@ func TestSendMetrics(t *testing.T) { "header": "header-value", }, } - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) set.BuildInfo.Description = "Collector" set.BuildInfo.Version = "1.2.3test" @@ -590,7 +590,7 @@ func TestSendTraceDataServerDownAndUp(t *testing.T) { // Do not rely on external retry logic here, if that is intended set InitialInterval to 100ms. WaitForReady: true, } - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) exp, err := factory.CreateTraces(context.Background(), set, cfg) require.NoError(t, err) require.NotNil(t, exp) @@ -647,7 +647,7 @@ func TestSendTraceDataServerStartWhileRequest(t *testing.T) { Insecure: true, }, } - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) exp, err := factory.CreateTraces(context.Background(), set, cfg) require.NoError(t, err) require.NotNil(t, exp) @@ -698,7 +698,7 @@ func TestSendTracesOnResourceExhaustion(t *testing.T) { Insecure: true, }, } - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) exp, err := factory.CreateTraces(context.Background(), set, cfg) require.NoError(t, err) require.NotNil(t, exp) @@ -779,7 +779,7 @@ func TestSendLogData(t *testing.T) { Insecure: true, }, } - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) set.BuildInfo.Description = "Collector" set.BuildInfo.Version = "1.2.3test" @@ -886,7 +886,7 @@ func TestSendProfiles(t *testing.T) { "header": "header-value", }, } - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) set.BuildInfo.Description = "Collector" set.BuildInfo.Version = "1.2.3test" @@ -1005,7 +1005,7 @@ func TestSendProfilesWhenEndpointHasHttpScheme(t *testing.T) { if test.useTLS { cfg.ClientConfig.TLSSetting.InsecureSkipVerify = true } - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) exp, err := factory.(xexporter.Factory).CreateProfiles(context.Background(), set, cfg) require.NoError(t, err) require.NotNil(t, exp) diff --git a/exporter/otlphttpexporter/factory_test.go b/exporter/otlphttpexporter/factory_test.go index 4216314627..2945ba859b 100644 --- a/exporter/otlphttpexporter/factory_test.go +++ b/exporter/otlphttpexporter/factory_test.go @@ -45,7 +45,7 @@ func TestCreateMetrics(t *testing.T) { cfg := factory.CreateDefaultConfig().(*Config) cfg.ClientConfig.Endpoint = "http://" + testutil.GetAvailableLocalAddress(t) - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) oexp, err := factory.CreateMetrics(context.Background(), set, cfg) require.NoError(t, err) require.NotNil(t, oexp) @@ -164,7 +164,7 @@ func TestCreateTraces(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { factory := NewFactory() - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) consumer, err := factory.CreateTraces(context.Background(), set, tt.config) if tt.mustFailOnCreate { @@ -193,7 +193,7 @@ func TestCreateLogs(t *testing.T) { cfg := factory.CreateDefaultConfig().(*Config) cfg.ClientConfig.Endpoint = "http://" + testutil.GetAvailableLocalAddress(t) - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) oexp, err := factory.CreateLogs(context.Background(), set, cfg) require.NoError(t, err) require.NotNil(t, oexp) @@ -204,7 +204,7 @@ func TestCreateProfiles(t *testing.T) { cfg := factory.CreateDefaultConfig().(*Config) cfg.ClientConfig.Endpoint = "http://" + testutil.GetAvailableLocalAddress(t) - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) oexp, err := factory.(xexporter.Factory).CreateProfiles(context.Background(), set, cfg) require.NoError(t, err) require.NotNil(t, oexp) diff --git a/exporter/otlphttpexporter/generated_component_test.go b/exporter/otlphttpexporter/generated_component_test.go index 096e897dcb..91c0c0ac22 100644 --- a/exporter/otlphttpexporter/generated_component_test.go +++ b/exporter/otlphttpexporter/generated_component_test.go @@ -69,13 +69,13 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { t.Run(tt.name+"-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), exportertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), exportertest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) }) t.Run(tt.name+"-lifecycle", func(t *testing.T) { - c, err := tt.createFn(context.Background(), exportertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), exportertest.NewNopSettings(typ), cfg) require.NoError(t, err) host := componenttest.NewNopHost() err = c.Start(context.Background(), host) diff --git a/exporter/otlphttpexporter/otlp_test.go b/exporter/otlphttpexporter/otlp_test.go index 41044813a4..9b8cf772bb 100644 --- a/exporter/otlphttpexporter/otlp_test.go +++ b/exporter/otlphttpexporter/otlp_test.go @@ -258,7 +258,7 @@ func TestErrorResponses(t *testing.T) { // Create without QueueConfig and RetryConfig so that ConsumeTraces // returns the errors that we want to check immediately. } - exp, err := createTraces(context.Background(), exportertest.NewNopSettingsWithType(metadata.Type), cfg) + exp, err := createTraces(context.Background(), exportertest.NewNopSettings(metadata.Type), cfg) require.NoError(t, err) // start the exporter @@ -287,7 +287,7 @@ func TestErrorResponseInvalidResponseBody(t *testing.T) { } func TestUserAgent(t *testing.T) { - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) set.BuildInfo.Description = "Collector" set.BuildInfo.Version = "1.2.3test" @@ -453,7 +453,7 @@ func TestUserAgent(t *testing.T) { func TestPartialSuccessInvalidBody(t *testing.T) { cfg := createDefaultConfig() - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) exp, err := newExporter(cfg, set) require.NoError(t, err) invalidBodyCases := []struct { @@ -487,7 +487,7 @@ func TestPartialSuccessInvalidBody(t *testing.T) { func TestPartialSuccessUnsupportedContentType(t *testing.T) { cfg := createDefaultConfig() - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) exp, err := newExporter(cfg, set) require.NoError(t, err) unsupportedContentTypeCases := []struct { @@ -547,7 +547,7 @@ func TestPartialSuccess_logs(t *testing.T) { LogsEndpoint: srv.URL + "/v1/logs", ClientConfig: confighttp.ClientConfig{}, } - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) logger, observed := observer.New(zap.DebugLevel) set.TelemetrySettings.Logger = zap.New(logger) @@ -572,7 +572,7 @@ func TestPartialSuccess_logs(t *testing.T) { func TestPartialResponse_missingHeaderButHasBody(t *testing.T) { cfg := createDefaultConfig() - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) exp, err := newExporter(cfg, set) require.NoError(t, err) @@ -645,7 +645,7 @@ func TestPartialResponse_missingHeaderButHasBody(t *testing.T) { func TestPartialResponse_missingHeaderAndBody(t *testing.T) { cfg := createDefaultConfig() - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) exp, err := newExporter(cfg, set) require.NoError(t, err) @@ -698,7 +698,7 @@ func TestPartialResponse_missingHeaderAndBody(t *testing.T) { func TestPartialResponse_nonErrUnexpectedEOFError(t *testing.T) { cfg := createDefaultConfig() - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) exp, err := newExporter(cfg, set) require.NoError(t, err) @@ -713,7 +713,7 @@ func TestPartialResponse_nonErrUnexpectedEOFError(t *testing.T) { func TestPartialSuccess_shortContentLengthHeader(t *testing.T) { cfg := createDefaultConfig() - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) exp, err := newExporter(cfg, set) require.NoError(t, err) @@ -818,7 +818,7 @@ func TestPartialSuccess_longContentLengthHeader(t *testing.T) { for _, tt := range telemetryTypes { t.Run(tt.telemetryType+" "+ct.contentType, func(t *testing.T) { cfg := createDefaultConfig() - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) logger, observed := observer.New(zap.DebugLevel) set.TelemetrySettings.Logger = zap.New(logger) exp, err := newExporter(cfg, set) @@ -873,7 +873,7 @@ func TestPartialSuccess_longContentLengthHeader(t *testing.T) { func TestPartialSuccessInvalidResponseBody(t *testing.T) { cfg := createDefaultConfig() - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) exp, err := newExporter(cfg, set) require.NoError(t, err) @@ -907,7 +907,7 @@ func TestPartialSuccess_traces(t *testing.T) { TracesEndpoint: srv.URL + "/v1/traces", ClientConfig: confighttp.ClientConfig{}, } - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) logger, observed := observer.New(zap.DebugLevel) set.TelemetrySettings.Logger = zap.New(logger) exp, err := createTraces(context.Background(), set, cfg) @@ -947,7 +947,7 @@ func TestPartialSuccess_metrics(t *testing.T) { MetricsEndpoint: srv.URL + "/v1/metrics", ClientConfig: confighttp.ClientConfig{}, } - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) logger, observed := observer.New(zap.DebugLevel) set.TelemetrySettings.Logger = zap.New(logger) exp, err := createMetrics(context.Background(), set, cfg) @@ -988,7 +988,7 @@ func TestPartialSuccess_profiles(t *testing.T) { Endpoint: srv.URL, }, } - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) logger, observed := observer.New(zap.DebugLevel) set.TelemetrySettings.Logger = zap.New(logger) exp, err := createProfiles(context.Background(), set, cfg) @@ -1010,7 +1010,7 @@ func TestPartialSuccess_profiles(t *testing.T) { } func TestEncoding(t *testing.T) { - set := exportertest.NewNopSettingsWithType(metadata.Type) + set := exportertest.NewNopSettings(metadata.Type) set.BuildInfo.Description = "Collector" set.BuildInfo.Version = "1.2.3test" diff --git a/extension/extensiontest/nop_extension.go b/extension/extensiontest/nop_extension.go index 5ba5358ee8..b2678e6a10 100644 --- a/extension/extensiontest/nop_extension.go +++ b/extension/extensiontest/nop_extension.go @@ -16,12 +16,16 @@ import ( // NopType is the type of the nop extension. var NopType = component.MustNewType("nop") -// NewNopSettings returns a new nop settings for extension.Factory Create* functions. -// Deprecated: [v0.120.0] Use NewNopSettingsWithType(NopType) instead. -func NewNopSettings() extension.Settings { - return NewNopSettingsWithType(NopType) +// NewNopSettings returns a new nop settings for extension.Factory Create* functions with the given type. +func NewNopSettings(typ component.Type) extension.Settings { + return extension.Settings{ + ID: component.NewIDWithName(typ, uuid.NewString()), + TelemetrySettings: componenttest.NewNopTelemetrySettings(), + BuildInfo: component.NewDefaultBuildInfo(), + } } +// Deprecated: [v0.121.0] Use NewNopSettings(NopType) instead. // NewNopSettings returns a new nop settings for extension.Factory Create* functions with the given type. func NewNopSettingsWithType(ty component.Type) extension.Settings { return extension.Settings{ diff --git a/extension/extensiontest/nop_extension_test.go b/extension/extensiontest/nop_extension_test.go index 7fd2e70f33..9ab08f2560 100644 --- a/extension/extensiontest/nop_extension_test.go +++ b/extension/extensiontest/nop_extension_test.go @@ -21,7 +21,7 @@ func TestNewNopFactory(t *testing.T) { cfg := factory.CreateDefaultConfig() assert.Equal(t, &nopConfig{}, cfg) - traces, err := factory.Create(context.Background(), NewNopSettingsWithType(NopType), cfg) + traces, err := factory.Create(context.Background(), NewNopSettings(NopType), cfg) require.NoError(t, err) assert.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, traces.Shutdown(context.Background())) diff --git a/extension/memorylimiterextension/factory_test.go b/extension/memorylimiterextension/factory_test.go index a8364eaaac..2e8b874412 100644 --- a/extension/memorylimiterextension/factory_test.go +++ b/extension/memorylimiterextension/factory_test.go @@ -38,7 +38,7 @@ func TestCreate(t *testing.T) { pCfg.MemorySpikeLimitMiB = 1907 pCfg.CheckInterval = 100 * time.Millisecond - set := extensiontest.NewNopSettingsWithType(factory.Type()) + set := extensiontest.NewNopSettings(factory.Type()) set.ID = component.NewID(factory.Type()) tp, err := factory.Create(context.Background(), set, cfg) diff --git a/extension/memorylimiterextension/generated_component_test.go b/extension/memorylimiterextension/generated_component_test.go index 1a15028eb5..3a7cd50107 100644 --- a/extension/memorylimiterextension/generated_component_test.go +++ b/extension/memorylimiterextension/generated_component_test.go @@ -34,12 +34,12 @@ func TestComponentLifecycle(t *testing.T) { require.NoError(t, err) require.NoError(t, sub.Unmarshal(&cfg)) t.Run("lifecycle", func(t *testing.T) { - firstExt, err := factory.Create(context.Background(), extensiontest.NewNopSettingsWithType(typ), cfg) + firstExt, err := factory.Create(context.Background(), extensiontest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, firstExt.Start(context.Background(), componenttest.NewNopHost())) require.NoError(t, firstExt.Shutdown(context.Background())) - secondExt, err := factory.Create(context.Background(), extensiontest.NewNopSettingsWithType(typ), cfg) + secondExt, err := factory.Create(context.Background(), extensiontest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, secondExt.Start(context.Background(), componenttest.NewNopHost())) require.NoError(t, secondExt.Shutdown(context.Background())) diff --git a/extension/zpagesextension/factory_test.go b/extension/zpagesextension/factory_test.go index 1bc6d81996..a4c7520fbb 100644 --- a/extension/zpagesextension/factory_test.go +++ b/extension/zpagesextension/factory_test.go @@ -28,7 +28,7 @@ func TestFactory_CreateDefaultConfig(t *testing.T) { cfg) require.NoError(t, componenttest.CheckConfigStruct(cfg)) - ext, err := create(context.Background(), extensiontest.NewNopSettingsWithType(metadata.Type), cfg) + ext, err := create(context.Background(), extensiontest.NewNopSettings(metadata.Type), cfg) require.NoError(t, err) require.NotNil(t, ext) } @@ -37,7 +37,7 @@ func TestFactoryCreate(t *testing.T) { cfg := createDefaultConfig().(*Config) cfg.ServerConfig.Endpoint = testutil.GetAvailableLocalAddress(t) - set := extensiontest.NewNopSettingsWithType(extensiontest.NopType) + set := extensiontest.NewNopSettings(extensiontest.NopType) set.ID = component.NewID(NewFactory().Type()) ext, err := create(context.Background(), set, cfg) require.NoError(t, err) diff --git a/extension/zpagesextension/generated_component_test.go b/extension/zpagesextension/generated_component_test.go index bfd2fd3a30..ca305e577f 100644 --- a/extension/zpagesextension/generated_component_test.go +++ b/extension/zpagesextension/generated_component_test.go @@ -34,18 +34,18 @@ func TestComponentLifecycle(t *testing.T) { require.NoError(t, err) require.NoError(t, sub.Unmarshal(&cfg)) t.Run("shutdown", func(t *testing.T) { - e, err := factory.Create(context.Background(), extensiontest.NewNopSettingsWithType(typ), cfg) + e, err := factory.Create(context.Background(), extensiontest.NewNopSettings(typ), cfg) require.NoError(t, err) err = e.Shutdown(context.Background()) require.NoError(t, err) }) t.Run("lifecycle", func(t *testing.T) { - firstExt, err := factory.Create(context.Background(), extensiontest.NewNopSettingsWithType(typ), cfg) + firstExt, err := factory.Create(context.Background(), extensiontest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, firstExt.Start(context.Background(), componenttest.NewNopHost())) require.NoError(t, firstExt.Shutdown(context.Background())) - secondExt, err := factory.Create(context.Background(), extensiontest.NewNopSettingsWithType(typ), cfg) + secondExt, err := factory.Create(context.Background(), extensiontest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, secondExt.Start(context.Background(), componenttest.NewNopHost())) require.NoError(t, secondExt.Shutdown(context.Background())) diff --git a/internal/e2e/otlphttp_test.go b/internal/e2e/otlphttp_test.go index e8d6d184d3..cfd9bdf0fd 100644 --- a/internal/e2e/otlphttp_test.go +++ b/internal/e2e/otlphttp_test.go @@ -43,7 +43,7 @@ func TestInvalidConfig(t *testing.T) { }, } f := otlphttpexporter.NewFactory() - set := exportertest.NewNopSettingsWithType(f.Type()) + set := exportertest.NewNopSettings(f.Type()) _, err := f.CreateTraces(context.Background(), set, config) require.Error(t, err) _, err = f.CreateMetrics(context.Background(), set, config) @@ -291,7 +291,7 @@ func startTraces(t *testing.T, baseURL string, overrideURL string) exporter.Trac factory := otlphttpexporter.NewFactory() cfg := createConfig(baseURL, factory.CreateDefaultConfig()) cfg.TracesEndpoint = overrideURL - exp, err := factory.CreateTraces(context.Background(), exportertest.NewNopSettingsWithType(factory.Type()), cfg) + exp, err := factory.CreateTraces(context.Background(), exportertest.NewNopSettings(factory.Type()), cfg) require.NoError(t, err) startAndCleanup(t, exp) return exp @@ -301,7 +301,7 @@ func startMetrics(t *testing.T, baseURL string, overrideURL string) exporter.Met factory := otlphttpexporter.NewFactory() cfg := createConfig(baseURL, factory.CreateDefaultConfig()) cfg.MetricsEndpoint = overrideURL - exp, err := factory.CreateMetrics(context.Background(), exportertest.NewNopSettingsWithType(factory.Type()), cfg) + exp, err := factory.CreateMetrics(context.Background(), exportertest.NewNopSettings(factory.Type()), cfg) require.NoError(t, err) startAndCleanup(t, exp) return exp @@ -311,7 +311,7 @@ func startLogs(t *testing.T, baseURL string, overrideURL string) exporter.Logs { factory := otlphttpexporter.NewFactory() cfg := createConfig(baseURL, factory.CreateDefaultConfig()) cfg.LogsEndpoint = overrideURL - exp, err := factory.CreateLogs(context.Background(), exportertest.NewNopSettingsWithType(factory.Type()), cfg) + exp, err := factory.CreateLogs(context.Background(), exportertest.NewNopSettings(factory.Type()), cfg) require.NoError(t, err) startAndCleanup(t, exp) return exp @@ -328,7 +328,7 @@ func createConfig(baseURL string, defaultCfg component.Config) *otlphttpexporter func startTracesReceiver(t *testing.T, addr string, next consumer.Traces) { factory := otlpreceiver.NewFactory() cfg := createReceiverConfig(addr, factory.CreateDefaultConfig()) - recv, err := factory.CreateTraces(context.Background(), receivertest.NewNopSettingsWithType(factory.Type()), cfg, next) + recv, err := factory.CreateTraces(context.Background(), receivertest.NewNopSettings(factory.Type()), cfg, next) require.NoError(t, err) startAndCleanup(t, recv) } @@ -336,7 +336,7 @@ func startTracesReceiver(t *testing.T, addr string, next consumer.Traces) { func startMetricsReceiver(t *testing.T, addr string, next consumer.Metrics) { factory := otlpreceiver.NewFactory() cfg := createReceiverConfig(addr, factory.CreateDefaultConfig()) - recv, err := factory.CreateMetrics(context.Background(), receivertest.NewNopSettingsWithType(factory.Type()), cfg, next) + recv, err := factory.CreateMetrics(context.Background(), receivertest.NewNopSettings(factory.Type()), cfg, next) require.NoError(t, err) startAndCleanup(t, recv) } @@ -344,7 +344,7 @@ func startMetricsReceiver(t *testing.T, addr string, next consumer.Metrics) { func startLogsReceiver(t *testing.T, addr string, next consumer.Logs) { factory := otlpreceiver.NewFactory() cfg := createReceiverConfig(addr, factory.CreateDefaultConfig()) - recv, err := factory.CreateLogs(context.Background(), receivertest.NewNopSettingsWithType(factory.Type()), cfg, next) + recv, err := factory.CreateLogs(context.Background(), receivertest.NewNopSettings(factory.Type()), cfg, next) require.NoError(t, err) startAndCleanup(t, recv) } diff --git a/processor/batchprocessor/batch_processor_test.go b/processor/batchprocessor/batch_processor_test.go index 4d46756095..d1321c1a7a 100644 --- a/processor/batchprocessor/batch_processor_test.go +++ b/processor/batchprocessor/batch_processor_test.go @@ -35,7 +35,7 @@ func TestProcessorShutdown(t *testing.T) { factory := NewFactory() ctx := context.Background() - processorCreationSet := processortest.NewNopSettingsWithType(processortest.NopType) + processorCreationSet := processortest.NewNopSettings(processortest.NopType) for i := 0; i < 5; i++ { require.NotPanics(t, func() { @@ -62,7 +62,7 @@ func TestProcessorLifecycle(t *testing.T) { factory := NewFactory() ctx := context.Background() - processorCreationSet := processortest.NewNopSettingsWithType(processortest.NopType) + processorCreationSet := processortest.NewNopSettings(processortest.NopType) for i := 0; i < 5; i++ { tProc, err := factory.CreateTraces(ctx, processorCreationSet, factory.CreateDefaultConfig(), consumertest.NewNop()) @@ -86,7 +86,7 @@ func TestBatchProcessorSpansDelivered(t *testing.T) { sink := new(consumertest.TracesSink) cfg := createDefaultConfig().(*Config) cfg.SendBatchSize = 128 - traces, err := NewFactory().CreateTraces(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + traces, err := NewFactory().CreateTraces(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost())) @@ -127,7 +127,7 @@ func TestBatchProcessorSpansDeliveredEnforceBatchSize(t *testing.T) { cfg := createDefaultConfig().(*Config) cfg.SendBatchSize = 128 cfg.SendBatchMaxSize = 130 - traces, err := NewFactory().CreateTraces(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + traces, err := NewFactory().CreateTraces(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost())) @@ -368,7 +368,7 @@ func TestBatchProcessorSentByTimeout(t *testing.T) { spansPerRequest := 10 start := time.Now() - traces, err := NewFactory().CreateTraces(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + traces, err := NewFactory().CreateTraces(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost())) @@ -413,7 +413,7 @@ func TestBatchProcessorTraceSendWhenClosing(t *testing.T) { } sink := new(consumertest.TracesSink) - traces, err := NewFactory().CreateTraces(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + traces, err := NewFactory().CreateTraces(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost())) @@ -442,7 +442,7 @@ func TestBatchMetricProcessor_ReceivingData(t *testing.T) { metricsPerRequest := 5 sink := new(consumertest.MetricsSink) - metrics, err := NewFactory().CreateMetrics(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + metrics, err := NewFactory().CreateMetrics(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, metrics.Start(context.Background(), componenttest.NewNopHost())) @@ -603,7 +603,7 @@ func TestBatchMetricsProcessor_Timeout(t *testing.T) { metricsPerRequest := 10 sink := new(consumertest.MetricsSink) - metrics, err := NewFactory().CreateMetrics(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + metrics, err := NewFactory().CreateMetrics(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, metrics.Start(context.Background(), componenttest.NewNopHost())) @@ -650,7 +650,7 @@ func TestBatchMetricProcessor_Shutdown(t *testing.T) { metricsPerRequest := 10 sink := new(consumertest.MetricsSink) - metrics, err := NewFactory().CreateMetrics(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + metrics, err := NewFactory().CreateMetrics(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, metrics.Start(context.Background(), componenttest.NewNopHost())) @@ -746,7 +746,7 @@ func BenchmarkMultiBatchMetricProcessor(b *testing.B) { func runMetricsProcessorBenchmark(b *testing.B, cfg *Config) { ctx := context.Background() sink := new(metricsSink) - metrics, err := NewFactory().CreateMetrics(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + metrics, err := NewFactory().CreateMetrics(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(b, err) require.NoError(b, metrics.Start(ctx, componenttest.NewNopHost())) @@ -792,7 +792,7 @@ func TestBatchLogProcessor_ReceivingData(t *testing.T) { logsPerRequest := 5 sink := new(consumertest.LogsSink) - logs, err := NewFactory().CreateLogs(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + logs, err := NewFactory().CreateLogs(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, logs.Start(context.Background(), componenttest.NewNopHost())) @@ -931,7 +931,7 @@ func TestBatchLogsProcessor_Timeout(t *testing.T) { logsPerRequest := 10 sink := new(consumertest.LogsSink) - logs, err := NewFactory().CreateLogs(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + logs, err := NewFactory().CreateLogs(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, logs.Start(context.Background(), componenttest.NewNopHost())) @@ -978,7 +978,7 @@ func TestBatchLogProcessor_Shutdown(t *testing.T) { logsPerRequest := 10 sink := new(consumertest.LogsSink) - logs, err := NewFactory().CreateLogs(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + logs, err := NewFactory().CreateLogs(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, logs.Start(context.Background(), componenttest.NewNopHost())) @@ -1055,7 +1055,7 @@ func TestBatchProcessorSpansBatchedByMetadata(t *testing.T) { cfg.SendBatchSize = 1000 cfg.Timeout = 10 * time.Minute cfg.MetadataKeys = []string{"token1", "token2"} - traces, err := NewFactory().CreateTraces(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + traces, err := NewFactory().CreateTraces(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost())) @@ -1146,7 +1146,7 @@ func TestBatchProcessorMetadataCardinalityLimit(t *testing.T) { cfg := createDefaultConfig().(*Config) cfg.MetadataKeys = []string{"token"} cfg.MetadataCardinalityLimit = cardLimit - traces, err := NewFactory().CreateTraces(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + traces, err := NewFactory().CreateTraces(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost())) @@ -1187,7 +1187,7 @@ func TestBatchZeroConfig(t *testing.T) { const requestCount = 5 const logsPerRequest = 10 sink := new(consumertest.LogsSink) - logs, err := NewFactory().CreateLogs(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + logs, err := NewFactory().CreateLogs(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, logs.Start(context.Background(), componenttest.NewNopHost())) defer func() { require.NoError(t, logs.Shutdown(context.Background())) }() @@ -1226,7 +1226,7 @@ func TestBatchSplitOnly(t *testing.T) { require.NoError(t, cfg.Validate()) sink := new(consumertest.LogsSink) - logs, err := NewFactory().CreateLogs(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), cfg, sink) + logs, err := NewFactory().CreateLogs(context.Background(), processortest.NewNopSettings(processortest.NopType), cfg, sink) require.NoError(t, err) require.NoError(t, logs.Start(context.Background(), componenttest.NewNopHost())) defer func() { require.NoError(t, logs.Shutdown(context.Background())) }() diff --git a/processor/batchprocessor/factory_test.go b/processor/batchprocessor/factory_test.go index 6cbf5476bf..b0e7e2a8be 100644 --- a/processor/batchprocessor/factory_test.go +++ b/processor/batchprocessor/factory_test.go @@ -25,7 +25,7 @@ func TestCreateProcessor(t *testing.T) { factory := NewFactory() cfg := factory.CreateDefaultConfig() - creationSet := processortest.NewNopSettingsWithType(factory.Type()) + creationSet := processortest.NewNopSettings(factory.Type()) tp, err := factory.CreateTraces(context.Background(), creationSet, cfg, nil) assert.NotNil(t, tp) assert.NoError(t, err, "cannot create trace processor") diff --git a/processor/batchprocessor/generated_component_test.go b/processor/batchprocessor/generated_component_test.go index 603f6e2ff4..beeee720e8 100644 --- a/processor/batchprocessor/generated_component_test.go +++ b/processor/batchprocessor/generated_component_test.go @@ -70,13 +70,13 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { t.Run(tt.name+"-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), processortest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), processortest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) }) t.Run(tt.name+"-lifecycle", func(t *testing.T) { - c, err := tt.createFn(context.Background(), processortest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), processortest.NewNopSettings(typ), cfg) require.NoError(t, err) host := componenttest.NewNopHost() err = c.Start(context.Background(), host) diff --git a/processor/batchprocessor/internal/metadatatest/generated_telemetrytest.go b/processor/batchprocessor/internal/metadatatest/generated_telemetrytest.go index 4863a3faea..335bb0006a 100644 --- a/processor/batchprocessor/internal/metadatatest/generated_telemetrytest.go +++ b/processor/batchprocessor/internal/metadatatest/generated_telemetrytest.go @@ -16,7 +16,7 @@ import ( ) func NewSettings(tt *componenttest.Telemetry) processor.Settings { - set := processortest.NewNopSettingsWithType(processortest.NopType) + set := processortest.NewNopSettings(processortest.NopType) set.ID = component.NewID(component.MustNewType("batch")) set.TelemetrySettings = tt.NewTelemetrySettings() return set diff --git a/processor/memorylimiterprocessor/factory_test.go b/processor/memorylimiterprocessor/factory_test.go index 921fd5dd2e..d824560271 100644 --- a/processor/memorylimiterprocessor/factory_test.go +++ b/processor/memorylimiterprocessor/factory_test.go @@ -50,7 +50,7 @@ func TestCreateProcessor(t *testing.T) { attribute.String(componentattribute.ComponentIDKey, "memorylimiter"), attribute.String(componentattribute.PipelineIDKey, "logs/foo"), ) - set := processortest.NewNopSettingsWithType(factory.Type()) + set := processortest.NewNopSettings(factory.Type()) set.Logger = componentattribute.NewLogger(zap.New(core), &attrs) tp, err := factory.CreateTraces(context.Background(), set, cfg, consumertest.NewNop()) diff --git a/processor/memorylimiterprocessor/generated_component_test.go b/processor/memorylimiterprocessor/generated_component_test.go index 712f46ebac..042f372e46 100644 --- a/processor/memorylimiterprocessor/generated_component_test.go +++ b/processor/memorylimiterprocessor/generated_component_test.go @@ -70,7 +70,7 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { t.Run(tt.name+"-lifecycle", func(t *testing.T) { - c, err := tt.createFn(context.Background(), processortest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), processortest.NewNopSettings(typ), cfg) require.NoError(t, err) host := componenttest.NewNopHost() err = c.Start(context.Background(), host) diff --git a/processor/memorylimiterprocessor/internal/metadatatest/generated_telemetrytest.go b/processor/memorylimiterprocessor/internal/metadatatest/generated_telemetrytest.go index 201edf1182..e595cbef6c 100644 --- a/processor/memorylimiterprocessor/internal/metadatatest/generated_telemetrytest.go +++ b/processor/memorylimiterprocessor/internal/metadatatest/generated_telemetrytest.go @@ -16,7 +16,7 @@ import ( ) func NewSettings(tt *componenttest.Telemetry) processor.Settings { - set := processortest.NewNopSettingsWithType(processortest.NopType) + set := processortest.NewNopSettings(processortest.NopType) set.ID = component.NewID(component.MustNewType("memory_limiter")) set.TelemetrySettings = tt.NewTelemetrySettings() return set diff --git a/processor/memorylimiterprocessor/memorylimiter_test.go b/processor/memorylimiterprocessor/memorylimiter_test.go index 518e0c344b..85a7fdf4fc 100644 --- a/processor/memorylimiterprocessor/memorylimiter_test.go +++ b/processor/memorylimiterprocessor/memorylimiter_test.go @@ -57,7 +57,7 @@ func TestNoDataLoss(t *testing.T) { cfg.MemoryLimitMiB = uint32(ms.Alloc/(1024*1024) + expectedMemoryIncreaseMiB) cfg.MemorySpikeLimitMiB = 1 - set := processortest.NewNopSettingsWithType(metadata.Type) + set := processortest.NewNopSettings(metadata.Type) limiter, err := newMemoryLimiterProcessor(set, cfg) require.NoError(t, err) @@ -180,11 +180,11 @@ func TestMetricsMemoryPressureResponse(t *testing.T) { ms.Alloc = tt.memAlloc } - ml, err := newMemoryLimiterProcessor(processortest.NewNopSettingsWithType(metadata.Type), tt.mlCfg) + ml, err := newMemoryLimiterProcessor(processortest.NewNopSettings(metadata.Type), tt.mlCfg) require.NoError(t, err) mp, err := processorhelper.NewMetrics( context.Background(), - processortest.NewNopSettingsWithType(metadata.Type), + processortest.NewNopSettings(metadata.Type), tt.mlCfg, consumertest.NewNop(), ml.processMetrics, @@ -299,11 +299,11 @@ func TestTraceMemoryPressureResponse(t *testing.T) { ms.Alloc = tt.memAlloc } - ml, err := newMemoryLimiterProcessor(processortest.NewNopSettingsWithType(metadata.Type), tt.mlCfg) + ml, err := newMemoryLimiterProcessor(processortest.NewNopSettings(metadata.Type), tt.mlCfg) require.NoError(t, err) tp, err := processorhelper.NewTraces( context.Background(), - processortest.NewNopSettingsWithType(metadata.Type), + processortest.NewNopSettings(metadata.Type), tt.mlCfg, consumertest.NewNop(), ml.processTraces, @@ -389,11 +389,11 @@ func TestLogMemoryPressureResponse(t *testing.T) { ms.Alloc = tt.memAlloc } - ml, err := newMemoryLimiterProcessor(processortest.NewNopSettingsWithType(metadata.Type), tt.mlCfg) + ml, err := newMemoryLimiterProcessor(processortest.NewNopSettings(metadata.Type), tt.mlCfg) require.NoError(t, err) tp, err := processorhelper.NewLogs( context.Background(), - processortest.NewNopSettingsWithType(metadata.Type), + processortest.NewNopSettings(metadata.Type), tt.mlCfg, consumertest.NewNop(), ml.processLogs, diff --git a/processor/processorhelper/logs_test.go b/processor/processorhelper/logs_test.go index 942676b6a4..440090098d 100644 --- a/processor/processorhelper/logs_test.go +++ b/processor/processorhelper/logs_test.go @@ -28,7 +28,7 @@ import ( var testLogsCfg = struct{}{} func TestNewLogs(t *testing.T) { - lp, err := NewLogs(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testLogsCfg, consumertest.NewNop(), newTestLProcessor(nil)) + lp, err := NewLogs(context.Background(), processortest.NewNopSettings(processortest.NopType), &testLogsCfg, consumertest.NewNop(), newTestLProcessor(nil)) require.NoError(t, err) assert.True(t, lp.Capabilities().MutatesData) @@ -39,7 +39,7 @@ func TestNewLogs(t *testing.T) { func TestNewLogs_WithOptions(t *testing.T) { want := errors.New("my_error") - lp, err := NewLogs(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testLogsCfg, consumertest.NewNop(), newTestLProcessor(nil), + lp, err := NewLogs(context.Background(), processortest.NewNopSettings(processortest.NopType), &testLogsCfg, consumertest.NewNop(), newTestLProcessor(nil), WithStart(func(context.Context, component.Host) error { return want }), WithShutdown(func(context.Context) error { return want }), WithCapabilities(consumer.Capabilities{MutatesData: false})) @@ -51,19 +51,19 @@ func TestNewLogs_WithOptions(t *testing.T) { } func TestNewLogs_NilRequiredFields(t *testing.T) { - _, err := NewLogs(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testLogsCfg, consumertest.NewNop(), nil) + _, err := NewLogs(context.Background(), processortest.NewNopSettings(processortest.NopType), &testLogsCfg, consumertest.NewNop(), nil) assert.Error(t, err) } func TestNewLogs_ProcessLogError(t *testing.T) { want := errors.New("my_error") - lp, err := NewLogs(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testLogsCfg, consumertest.NewNop(), newTestLProcessor(want)) + lp, err := NewLogs(context.Background(), processortest.NewNopSettings(processortest.NopType), &testLogsCfg, consumertest.NewNop(), newTestLProcessor(want)) require.NoError(t, err) assert.Equal(t, want, lp.ConsumeLogs(context.Background(), plog.NewLogs())) } func TestNewLogs_ProcessLogsErrSkipProcessingData(t *testing.T) { - lp, err := NewLogs(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testLogsCfg, consumertest.NewNop(), newTestLProcessor(ErrSkipProcessingData)) + lp, err := NewLogs(context.Background(), processortest.NewNopSettings(processortest.NopType), &testLogsCfg, consumertest.NewNop(), newTestLProcessor(ErrSkipProcessingData)) require.NoError(t, err) assert.NoError(t, lp.ConsumeLogs(context.Background(), plog.NewLogs())) } @@ -87,7 +87,7 @@ func TestLogsConcurrency(t *testing.T) { incomingLogRecords.AppendEmpty() incomingLogRecords.AppendEmpty() - lp, err := NewLogs(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testLogsCfg, consumertest.NewNop(), logsFunc) + lp, err := NewLogs(context.Background(), processortest.NewNopSettings(processortest.NopType), &testLogsCfg, consumertest.NewNop(), logsFunc) require.NoError(t, err) assert.NoError(t, lp.Start(context.Background(), componenttest.NewNopHost())) @@ -184,7 +184,7 @@ func TestLogs_RecordIn_ErrorOut(t *testing.T) { } func newSettings(tel *componenttest.Telemetry) processor.Settings { - set := processortest.NewNopSettingsWithType(component.MustNewType("processorhelper")) + set := processortest.NewNopSettings(component.MustNewType("processorhelper")) set.TelemetrySettings = tel.NewTelemetrySettings() return set } diff --git a/processor/processorhelper/metrics_test.go b/processor/processorhelper/metrics_test.go index ae558325e3..12b77643ee 100644 --- a/processor/processorhelper/metrics_test.go +++ b/processor/processorhelper/metrics_test.go @@ -27,7 +27,7 @@ import ( var testMetricsCfg = struct{}{} func TestNewMetrics(t *testing.T) { - mp, err := NewMetrics(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testMetricsCfg, consumertest.NewNop(), newTestMProcessor(nil)) + mp, err := NewMetrics(context.Background(), processortest.NewNopSettings(processortest.NopType), &testMetricsCfg, consumertest.NewNop(), newTestMProcessor(nil)) require.NoError(t, err) assert.True(t, mp.Capabilities().MutatesData) @@ -38,7 +38,7 @@ func TestNewMetrics(t *testing.T) { func TestNewMetrics_WithOptions(t *testing.T) { want := errors.New("my_error") - mp, err := NewMetrics(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testMetricsCfg, consumertest.NewNop(), newTestMProcessor(nil), + mp, err := NewMetrics(context.Background(), processortest.NewNopSettings(processortest.NopType), &testMetricsCfg, consumertest.NewNop(), newTestMProcessor(nil), WithStart(func(context.Context, component.Host) error { return want }), WithShutdown(func(context.Context) error { return want }), WithCapabilities(consumer.Capabilities{MutatesData: false})) @@ -50,19 +50,19 @@ func TestNewMetrics_WithOptions(t *testing.T) { } func TestNewMetrics_NilRequiredFields(t *testing.T) { - _, err := NewMetrics(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testMetricsCfg, consumertest.NewNop(), nil) + _, err := NewMetrics(context.Background(), processortest.NewNopSettings(processortest.NopType), &testMetricsCfg, consumertest.NewNop(), nil) assert.Error(t, err) } func TestNewMetrics_ProcessMetricsError(t *testing.T) { want := errors.New("my_error") - mp, err := NewMetrics(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testMetricsCfg, consumertest.NewNop(), newTestMProcessor(want)) + mp, err := NewMetrics(context.Background(), processortest.NewNopSettings(processortest.NopType), &testMetricsCfg, consumertest.NewNop(), newTestMProcessor(want)) require.NoError(t, err) assert.Equal(t, want, mp.ConsumeMetrics(context.Background(), pmetric.NewMetrics())) } func TestNewMetrics_ProcessMetricsErrSkipProcessingData(t *testing.T) { - mp, err := NewMetrics(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testMetricsCfg, consumertest.NewNop(), newTestMProcessor(ErrSkipProcessingData)) + mp, err := NewMetrics(context.Background(), processortest.NewNopSettings(processortest.NopType), &testMetricsCfg, consumertest.NewNop(), newTestMProcessor(ErrSkipProcessingData)) require.NoError(t, err) assert.NoError(t, mp.ConsumeMetrics(context.Background(), pmetric.NewMetrics())) } @@ -85,7 +85,7 @@ func TestMetricsConcurrency(t *testing.T) { dps.AppendEmpty() dps.AppendEmpty() - mp, err := NewMetrics(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testLogsCfg, consumertest.NewNop(), metricsFunc) + mp, err := NewMetrics(context.Background(), processortest.NewNopSettings(processortest.NopType), &testLogsCfg, consumertest.NewNop(), metricsFunc) require.NoError(t, err) assert.NoError(t, mp.Start(context.Background(), componenttest.NewNopHost())) diff --git a/processor/processorhelper/traces_test.go b/processor/processorhelper/traces_test.go index 7131f4e31f..17825096ff 100644 --- a/processor/processorhelper/traces_test.go +++ b/processor/processorhelper/traces_test.go @@ -27,7 +27,7 @@ import ( var testTracesCfg = struct{}{} func TestNewTraces(t *testing.T) { - tp, err := NewTraces(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testTracesCfg, consumertest.NewNop(), newTestTProcessor(nil)) + tp, err := NewTraces(context.Background(), processortest.NewNopSettings(processortest.NopType), &testTracesCfg, consumertest.NewNop(), newTestTProcessor(nil)) require.NoError(t, err) assert.True(t, tp.Capabilities().MutatesData) @@ -38,7 +38,7 @@ func TestNewTraces(t *testing.T) { func TestNewTraces_WithOptions(t *testing.T) { want := errors.New("my_error") - tp, err := NewTraces(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testTracesCfg, consumertest.NewNop(), newTestTProcessor(nil), + tp, err := NewTraces(context.Background(), processortest.NewNopSettings(processortest.NopType), &testTracesCfg, consumertest.NewNop(), newTestTProcessor(nil), WithStart(func(context.Context, component.Host) error { return want }), WithShutdown(func(context.Context) error { return want }), WithCapabilities(consumer.Capabilities{MutatesData: false})) @@ -50,19 +50,19 @@ func TestNewTraces_WithOptions(t *testing.T) { } func TestNewTraces_NilRequiredFields(t *testing.T) { - _, err := NewTraces(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testTracesCfg, consumertest.NewNop(), nil) + _, err := NewTraces(context.Background(), processortest.NewNopSettings(processortest.NopType), &testTracesCfg, consumertest.NewNop(), nil) assert.Error(t, err) } func TestNewTraces_ProcessTraceError(t *testing.T) { want := errors.New("my_error") - tp, err := NewTraces(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testTracesCfg, consumertest.NewNop(), newTestTProcessor(want)) + tp, err := NewTraces(context.Background(), processortest.NewNopSettings(processortest.NopType), &testTracesCfg, consumertest.NewNop(), newTestTProcessor(want)) require.NoError(t, err) assert.Equal(t, want, tp.ConsumeTraces(context.Background(), ptrace.NewTraces())) } func TestNewTraces_ProcessTracesErrSkipProcessingData(t *testing.T) { - tp, err := NewTraces(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testTracesCfg, consumertest.NewNop(), newTestTProcessor(ErrSkipProcessingData)) + tp, err := NewTraces(context.Background(), processortest.NewNopSettings(processortest.NopType), &testTracesCfg, consumertest.NewNop(), newTestTProcessor(ErrSkipProcessingData)) require.NoError(t, err) assert.NoError(t, tp.ConsumeTraces(context.Background(), ptrace.NewTraces())) } @@ -87,7 +87,7 @@ func TestTracesConcurrency(t *testing.T) { incomingSpans.AppendEmpty() incomingSpans.AppendEmpty() - mp, err := NewTraces(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testLogsCfg, consumertest.NewNop(), tracesFunc) + mp, err := NewTraces(context.Background(), processortest.NewNopSettings(processortest.NopType), &testLogsCfg, consumertest.NewNop(), tracesFunc) require.NoError(t, err) assert.NoError(t, mp.Start(context.Background(), componenttest.NewNopHost())) diff --git a/processor/processorhelper/xprocessorhelper/profiles_test.go b/processor/processorhelper/xprocessorhelper/profiles_test.go index dd226d4130..c0bf846d59 100644 --- a/processor/processorhelper/xprocessorhelper/profiles_test.go +++ b/processor/processorhelper/xprocessorhelper/profiles_test.go @@ -24,7 +24,7 @@ import ( var testProfilesCfg = struct{}{} func TestNewProfiles(t *testing.T) { - pp, err := NewProfiles(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testProfilesCfg, consumertest.NewNop(), newTestPProcessor(nil)) + pp, err := NewProfiles(context.Background(), processortest.NewNopSettings(processortest.NopType), &testProfilesCfg, consumertest.NewNop(), newTestPProcessor(nil)) require.NoError(t, err) assert.True(t, pp.Capabilities().MutatesData) @@ -35,7 +35,7 @@ func TestNewProfiles(t *testing.T) { func TestNewProfiles_WithOptions(t *testing.T) { want := errors.New("my_error") - pp, err := NewProfiles(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testProfilesCfg, consumertest.NewNop(), newTestPProcessor(nil), + pp, err := NewProfiles(context.Background(), processortest.NewNopSettings(processortest.NopType), &testProfilesCfg, consumertest.NewNop(), newTestPProcessor(nil), WithStart(func(context.Context, component.Host) error { return want }), WithShutdown(func(context.Context) error { return want }), WithCapabilities(consumer.Capabilities{MutatesData: false})) @@ -47,19 +47,19 @@ func TestNewProfiles_WithOptions(t *testing.T) { } func TestNewProfiles_NilRequiredFields(t *testing.T) { - _, err := NewProfiles(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testProfilesCfg, consumertest.NewNop(), nil) + _, err := NewProfiles(context.Background(), processortest.NewNopSettings(processortest.NopType), &testProfilesCfg, consumertest.NewNop(), nil) assert.Error(t, err) } func TestNewProfiles_ProcessProfileError(t *testing.T) { want := errors.New("my_error") - pp, err := NewProfiles(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testProfilesCfg, consumertest.NewNop(), newTestPProcessor(want)) + pp, err := NewProfiles(context.Background(), processortest.NewNopSettings(processortest.NopType), &testProfilesCfg, consumertest.NewNop(), newTestPProcessor(want)) require.NoError(t, err) assert.Equal(t, want, pp.ConsumeProfiles(context.Background(), pprofile.NewProfiles())) } func TestNewProfiles_ProcessProfilesErrSkipProcessingData(t *testing.T) { - pp, err := NewProfiles(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testProfilesCfg, consumertest.NewNop(), newTestPProcessor(processorhelper.ErrSkipProcessingData)) + pp, err := NewProfiles(context.Background(), processortest.NewNopSettings(processortest.NopType), &testProfilesCfg, consumertest.NewNop(), newTestPProcessor(processorhelper.ErrSkipProcessingData)) require.NoError(t, err) assert.NoError(t, pp.ConsumeProfiles(context.Background(), pprofile.NewProfiles())) } @@ -83,7 +83,7 @@ func TestProfilesConcurrency(t *testing.T) { ps.AppendEmpty() ps.AppendEmpty() - pp, err := NewProfiles(context.Background(), processortest.NewNopSettingsWithType(processortest.NopType), &testProfilesCfg, consumertest.NewNop(), profilesFunc) + pp, err := NewProfiles(context.Background(), processortest.NewNopSettings(processortest.NopType), &testProfilesCfg, consumertest.NewNop(), profilesFunc) require.NoError(t, err) assert.NoError(t, pp.Start(context.Background(), componenttest.NewNopHost())) diff --git a/processor/processortest/nop_processor.go b/processor/processortest/nop_processor.go index f7012368ac..e76a47eb6f 100644 --- a/processor/processortest/nop_processor.go +++ b/processor/processortest/nop_processor.go @@ -17,12 +17,16 @@ import ( var NopType = component.MustNewType("nop") -// NewNopSettings returns a new nop settings for Create* functions. -// Deprecated: [v0.120.0] Use NewNopSettingsWithType instead. -func NewNopSettings() processor.Settings { - return NewNopSettingsWithType(NopType) +// NewNopSettings returns a new nop settings for Create* functions with the given type. +func NewNopSettings(typ component.Type) processor.Settings { + return processor.Settings{ + ID: component.NewID(typ), + TelemetrySettings: componenttest.NewNopTelemetrySettings(), + BuildInfo: component.NewDefaultBuildInfo(), + } } +// Deprecated: [v0.121.0] Use NewNopSettings(NopType) instead. // NewNopSettingsWithType returns a new nop settings for Create* functions with the given type. func NewNopSettingsWithType(typ component.Type) processor.Settings { return processor.Settings{ diff --git a/processor/processortest/nop_processor_test.go b/processor/processortest/nop_processor_test.go index 6e040d3e2e..3a37c4d45c 100644 --- a/processor/processortest/nop_processor_test.go +++ b/processor/processortest/nop_processor_test.go @@ -28,28 +28,28 @@ func TestNewNopFactory(t *testing.T) { cfg := factory.CreateDefaultConfig() assert.Equal(t, &nopConfig{}, cfg) - traces, err := factory.CreateTraces(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + traces, err := factory.CreateTraces(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.Equal(t, consumer.Capabilities{MutatesData: false}, traces.Capabilities()) assert.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, traces.ConsumeTraces(context.Background(), ptrace.NewTraces())) assert.NoError(t, traces.Shutdown(context.Background())) - metrics, err := factory.CreateMetrics(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + metrics, err := factory.CreateMetrics(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.Equal(t, consumer.Capabilities{MutatesData: false}, metrics.Capabilities()) assert.NoError(t, metrics.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, metrics.ConsumeMetrics(context.Background(), pmetric.NewMetrics())) assert.NoError(t, metrics.Shutdown(context.Background())) - logs, err := factory.CreateLogs(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + logs, err := factory.CreateLogs(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.Equal(t, consumer.Capabilities{MutatesData: false}, logs.Capabilities()) assert.NoError(t, logs.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, logs.ConsumeLogs(context.Background(), plog.NewLogs())) assert.NoError(t, logs.Shutdown(context.Background())) - profiles, err := factory.(xprocessor.Factory).CreateProfiles(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + profiles, err := factory.(xprocessor.Factory).CreateProfiles(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.Equal(t, consumer.Capabilities{MutatesData: false}, profiles.Capabilities()) assert.NoError(t, profiles.Start(context.Background(), componenttest.NewNopHost())) diff --git a/processor/processortest/shutdown_verifier.go b/processor/processortest/shutdown_verifier.go index 44dc8e1f17..c579ecc3ca 100644 --- a/processor/processortest/shutdown_verifier.go +++ b/processor/processortest/shutdown_verifier.go @@ -22,7 +22,7 @@ import ( func verifyTracesDoesNotProduceAfterShutdown(t *testing.T, factory processor.Factory, cfg component.Config) { // Create a proc and output its produce to a sink. nextSink := new(consumertest.TracesSink) - proc, err := factory.CreateTraces(context.Background(), NewNopSettingsWithType(NopType), cfg, nextSink) + proc, err := factory.CreateTraces(context.Background(), NewNopSettings(NopType), cfg, nextSink) if errors.Is(err, pipeline.ErrSignalNotSupported) { return } @@ -46,7 +46,7 @@ func verifyTracesDoesNotProduceAfterShutdown(t *testing.T, factory processor.Fac func verifyLogsDoesNotProduceAfterShutdown(t *testing.T, factory processor.Factory, cfg component.Config) { // Create a proc and output its produce to a sink. nextSink := new(consumertest.LogsSink) - proc, err := factory.CreateLogs(context.Background(), NewNopSettingsWithType(NopType), cfg, nextSink) + proc, err := factory.CreateLogs(context.Background(), NewNopSettings(NopType), cfg, nextSink) if errors.Is(err, pipeline.ErrSignalNotSupported) { return } @@ -70,7 +70,7 @@ func verifyLogsDoesNotProduceAfterShutdown(t *testing.T, factory processor.Facto func verifyMetricsDoesNotProduceAfterShutdown(t *testing.T, factory processor.Factory, cfg component.Config) { // Create a proc and output its produce to a sink. nextSink := new(consumertest.MetricsSink) - proc, err := factory.CreateMetrics(context.Background(), NewNopSettingsWithType(NopType), cfg, nextSink) + proc, err := factory.CreateMetrics(context.Background(), NewNopSettings(NopType), cfg, nextSink) if errors.Is(err, pipeline.ErrSignalNotSupported) { return } diff --git a/processor/processortest/unhealthy_processor_test.go b/processor/processortest/unhealthy_processor_test.go index 61f7c3316c..4398d55bae 100644 --- a/processor/processortest/unhealthy_processor_test.go +++ b/processor/processortest/unhealthy_processor_test.go @@ -26,21 +26,21 @@ func TestNewUnhealthyProcessorFactory(t *testing.T) { cfg := factory.CreateDefaultConfig() assert.Equal(t, &struct{}{}, cfg) - traces, err := factory.CreateTraces(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + traces, err := factory.CreateTraces(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.Equal(t, consumer.Capabilities{MutatesData: false}, traces.Capabilities()) assert.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, traces.ConsumeTraces(context.Background(), ptrace.NewTraces())) assert.NoError(t, traces.Shutdown(context.Background())) - metrics, err := factory.CreateMetrics(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + metrics, err := factory.CreateMetrics(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.Equal(t, consumer.Capabilities{MutatesData: false}, metrics.Capabilities()) assert.NoError(t, metrics.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, metrics.ConsumeMetrics(context.Background(), pmetric.NewMetrics())) assert.NoError(t, metrics.Shutdown(context.Background())) - logs, err := factory.CreateLogs(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + logs, err := factory.CreateLogs(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.Equal(t, consumer.Capabilities{MutatesData: false}, logs.Capabilities()) assert.NoError(t, logs.Start(context.Background(), componenttest.NewNopHost())) diff --git a/receiver/nopreceiver/generated_component_test.go b/receiver/nopreceiver/generated_component_test.go index 6aac784444..49d1db079f 100644 --- a/receiver/nopreceiver/generated_component_test.go +++ b/receiver/nopreceiver/generated_component_test.go @@ -65,19 +65,19 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { t.Run(tt.name+"-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), receivertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), receivertest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) }) t.Run(tt.name+"-lifecycle", func(t *testing.T) { - firstRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettingsWithType(typ), cfg) + firstRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettings(typ), cfg) require.NoError(t, err) host := componenttest.NewNopHost() require.NoError(t, err) require.NoError(t, firstRcvr.Start(context.Background(), host)) require.NoError(t, firstRcvr.Shutdown(context.Background())) - secondRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettingsWithType(typ), cfg) + secondRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, secondRcvr.Start(context.Background(), host)) require.NoError(t, secondRcvr.Shutdown(context.Background())) diff --git a/receiver/nopreceiver/nop_receiver_test.go b/receiver/nopreceiver/nop_receiver_test.go index 08e39f7250..9a477ec418 100644 --- a/receiver/nopreceiver/nop_receiver_test.go +++ b/receiver/nopreceiver/nop_receiver_test.go @@ -23,17 +23,17 @@ func TestNewNopFactory(t *testing.T) { cfg := factory.CreateDefaultConfig() assert.Equal(t, &struct{}{}, cfg) - traces, err := factory.CreateTraces(context.Background(), receivertest.NewNopSettingsWithType(receivertest.NopType), cfg, consumertest.NewNop()) + traces, err := factory.CreateTraces(context.Background(), receivertest.NewNopSettings(receivertest.NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, traces.Shutdown(context.Background())) - metrics, err := factory.CreateMetrics(context.Background(), receivertest.NewNopSettingsWithType(receivertest.NopType), cfg, consumertest.NewNop()) + metrics, err := factory.CreateMetrics(context.Background(), receivertest.NewNopSettings(receivertest.NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, metrics.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, metrics.Shutdown(context.Background())) - logs, err := factory.CreateLogs(context.Background(), receivertest.NewNopSettingsWithType(receivertest.NopType), cfg, consumertest.NewNop()) + logs, err := factory.CreateLogs(context.Background(), receivertest.NewNopSettings(receivertest.NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, logs.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, logs.Shutdown(context.Background())) diff --git a/receiver/otlpreceiver/factory_test.go b/receiver/otlpreceiver/factory_test.go index ad04c31daf..29bf662169 100644 --- a/receiver/otlpreceiver/factory_test.go +++ b/receiver/otlpreceiver/factory_test.go @@ -46,7 +46,7 @@ func TestCreateSameReceiver(t *testing.T) { attribute.String(componentattribute.SignalKey, "traces"), // should be removed attribute.String(componentattribute.ComponentIDKey, "otlp"), ) - creationSet := receivertest.NewNopSettingsWithType(factory.Type()) + creationSet := receivertest.NewNopSettings(factory.Type()) creationSet.Logger = componentattribute.NewLogger(zap.New(core), &attrs) tReceiver, err := factory.CreateTraces(context.Background(), creationSet, cfg, consumertest.NewNop()) assert.NotNil(t, tReceiver) @@ -155,7 +155,7 @@ func TestCreateTraces(t *testing.T) { }, } ctx := context.Background() - creationSet := receivertest.NewNopSettingsWithType(metadata.Type) + creationSet := receivertest.NewNopSettings(metadata.Type) for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tr, err := factory.CreateTraces(ctx, creationSet, tt.cfg, tt.sink) @@ -249,7 +249,7 @@ func TestCreateMetric(t *testing.T) { }, } ctx := context.Background() - creationSet := receivertest.NewNopSettingsWithType(metadata.Type) + creationSet := receivertest.NewNopSettings(metadata.Type) for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { mr, err := factory.CreateMetrics(ctx, creationSet, tt.cfg, tt.sink) @@ -343,7 +343,7 @@ func TestCreateLogs(t *testing.T) { }, } ctx := context.Background() - creationSet := receivertest.NewNopSettingsWithType(metadata.Type) + creationSet := receivertest.NewNopSettings(metadata.Type) for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { mr, err := factory.CreateLogs(ctx, creationSet, tt.cfg, tt.sink) @@ -436,7 +436,7 @@ func TestCreateProfiles(t *testing.T) { }, } ctx := context.Background() - creationSet := receivertest.NewNopSettingsWithType(metadata.Type) + creationSet := receivertest.NewNopSettings(metadata.Type) for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tr, err := factory.(xreceiver.Factory).CreateProfiles(ctx, creationSet, tt.cfg, tt.sink) diff --git a/receiver/otlpreceiver/fuzz_test.go b/receiver/otlpreceiver/fuzz_test.go index 5366638ab4..1875c3a919 100644 --- a/receiver/otlpreceiver/fuzz_test.go +++ b/receiver/otlpreceiver/fuzz_test.go @@ -28,7 +28,7 @@ func FuzzReceiverHandlers(f *testing.F) { } else { req.Header.Add("Content-Type", jsonContentType) } - set := receivertest.NewNopSettingsWithType(receivertest.NopType) + set := receivertest.NewNopSettings(receivertest.NopType) set.TelemetrySettings = componenttest.NewNopTelemetrySettings() set.ID = otlpReceiverID cfg := createDefaultConfig().(*Config) diff --git a/receiver/otlpreceiver/generated_component_test.go b/receiver/otlpreceiver/generated_component_test.go index b573fb7c99..90607b16e3 100644 --- a/receiver/otlpreceiver/generated_component_test.go +++ b/receiver/otlpreceiver/generated_component_test.go @@ -65,19 +65,19 @@ func TestComponentLifecycle(t *testing.T) { for _, tt := range tests { t.Run(tt.name+"-shutdown", func(t *testing.T) { - c, err := tt.createFn(context.Background(), receivertest.NewNopSettingsWithType(typ), cfg) + c, err := tt.createFn(context.Background(), receivertest.NewNopSettings(typ), cfg) require.NoError(t, err) err = c.Shutdown(context.Background()) require.NoError(t, err) }) t.Run(tt.name+"-lifecycle", func(t *testing.T) { - firstRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettingsWithType(typ), cfg) + firstRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettings(typ), cfg) require.NoError(t, err) host := componenttest.NewNopHost() require.NoError(t, err) require.NoError(t, firstRcvr.Start(context.Background(), host)) require.NoError(t, firstRcvr.Shutdown(context.Background())) - secondRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettingsWithType(typ), cfg) + secondRcvr, err := tt.createFn(context.Background(), receivertest.NewNopSettings(typ), cfg) require.NoError(t, err) require.NoError(t, secondRcvr.Start(context.Background(), host)) require.NoError(t, secondRcvr.Shutdown(context.Background())) diff --git a/receiver/otlpreceiver/internal/logs/otlp_test.go b/receiver/otlpreceiver/internal/logs/otlp_test.go index 1b730c6b9a..2941d7d5c8 100644 --- a/receiver/otlpreceiver/internal/logs/otlp_test.go +++ b/receiver/otlpreceiver/internal/logs/otlp_test.go @@ -92,7 +92,7 @@ func otlpReceiverOnGRPCServer(t *testing.T, lc consumer.Logs) net.Addr { require.NoError(t, ln.Close()) }) - set := receivertest.NewNopSettingsWithType(metadata.Type) + set := receivertest.NewNopSettings(metadata.Type) set.ID = component.MustNewIDWithName("otlp", "log") obsreport, err := receiverhelper.NewObsReport(receiverhelper.ObsReportSettings{ ReceiverID: set.ID, diff --git a/receiver/otlpreceiver/internal/metrics/otlp_test.go b/receiver/otlpreceiver/internal/metrics/otlp_test.go index b333cc3620..1c30875e9b 100644 --- a/receiver/otlpreceiver/internal/metrics/otlp_test.go +++ b/receiver/otlpreceiver/internal/metrics/otlp_test.go @@ -93,7 +93,7 @@ func otlpReceiverOnGRPCServer(t *testing.T, mc consumer.Metrics) net.Addr { require.NoError(t, ln.Close()) }) - set := receivertest.NewNopSettingsWithType(metadata.Type) + set := receivertest.NewNopSettings(metadata.Type) set.ID = component.MustNewIDWithName("otlp", "metrics") obsreport, err := receiverhelper.NewObsReport(receiverhelper.ObsReportSettings{ ReceiverID: set.ID, diff --git a/receiver/otlpreceiver/internal/trace/otlp_test.go b/receiver/otlpreceiver/internal/trace/otlp_test.go index dacdcda943..3fb9578d2e 100644 --- a/receiver/otlpreceiver/internal/trace/otlp_test.go +++ b/receiver/otlpreceiver/internal/trace/otlp_test.go @@ -90,7 +90,7 @@ func otlpReceiverOnGRPCServer(t *testing.T, tc consumer.Traces) net.Addr { require.NoError(t, ln.Close()) }) - set := receivertest.NewNopSettingsWithType(metadata.Type) + set := receivertest.NewNopSettings(metadata.Type) set.ID = component.MustNewIDWithName("otlp", "trace") obsreport, err := receiverhelper.NewObsReport(receiverhelper.ObsReportSettings{ ReceiverID: set.ID, diff --git a/receiver/otlpreceiver/otlp_test.go b/receiver/otlpreceiver/otlp_test.go index ba8a341dd1..9a58c8d540 100644 --- a/receiver/otlpreceiver/otlp_test.go +++ b/receiver/otlpreceiver/otlp_test.go @@ -703,7 +703,7 @@ func TestGRPCInvalidTLSCredentials(t *testing.T) { r, err := NewFactory().CreateTraces( context.Background(), - receivertest.NewNopSettingsWithType(receivertest.NopType), + receivertest.NewNopSettings(receivertest.NopType), cfg, consumertest.NewNop()) require.NoError(t, err) @@ -772,7 +772,7 @@ func TestHTTPInvalidTLSCredentials(t *testing.T) { // TLS is resolved during Start for HTTP. r, err := NewFactory().CreateTraces( context.Background(), - receivertest.NewNopSettingsWithType(receivertest.NopType), + receivertest.NewNopSettings(receivertest.NopType), cfg, consumertest.NewNop()) require.NoError(t, err) @@ -838,7 +838,7 @@ func newHTTPReceiver(t *testing.T, settings component.TelemetrySettings, endpoin } func newReceiver(t *testing.T, settings component.TelemetrySettings, cfg *Config, id component.ID, c consumertest.Consumer) component.Component { - set := receivertest.NewNopSettingsWithType(receivertest.NopType) + set := receivertest.NewNopSettings(receivertest.NopType) set.TelemetrySettings = settings set.ID = id r, err := newOtlpReceiver(cfg, &set) @@ -1015,7 +1015,7 @@ func TestShutdown(t *testing.T) { cfg := factory.CreateDefaultConfig().(*Config) cfg.GRPC.NetAddr.Endpoint = endpointGrpc cfg.HTTP.Endpoint = endpointHTTP - set := receivertest.NewNopSettingsWithType(receivertest.NopType) + set := receivertest.NewNopSettings(receivertest.NopType) set.ID = otlpReceiverID r, err := NewFactory().CreateTraces( context.Background(), diff --git a/receiver/receivertest/contract_checker.go b/receiver/receivertest/contract_checker.go index 2850b61768..e356093243 100644 --- a/receiver/receivertest/contract_checker.go +++ b/receiver/receivertest/contract_checker.go @@ -113,11 +113,11 @@ func checkConsumeContractScenario(params CheckConsumeContractParams, decisionFun var err error switch params.Signal { case pipeline.SignalLogs: - receiver, err = params.Factory.CreateLogs(ctx, NewNopSettingsWithType(NopType), params.Config, consumer) + receiver, err = params.Factory.CreateLogs(ctx, NewNopSettings(NopType), params.Config, consumer) case pipeline.SignalTraces: - receiver, err = params.Factory.CreateTraces(ctx, NewNopSettingsWithType(NopType), params.Config, consumer) + receiver, err = params.Factory.CreateTraces(ctx, NewNopSettings(NopType), params.Config, consumer) case pipeline.SignalMetrics: - receiver, err = params.Factory.CreateMetrics(ctx, NewNopSettingsWithType(NopType), params.Config, consumer) + receiver, err = params.Factory.CreateMetrics(ctx, NewNopSettings(NopType), params.Config, consumer) default: require.FailNow(params.T, "must specify a valid DataType to test for") } diff --git a/receiver/receivertest/nop_receiver.go b/receiver/receivertest/nop_receiver.go index 20f7542f55..c565bd2c6c 100644 --- a/receiver/receivertest/nop_receiver.go +++ b/receiver/receivertest/nop_receiver.go @@ -18,12 +18,16 @@ import ( var NopType = component.MustNewType("nop") -// NewNopSettings returns a new nop settings for Create*Receiver functions. -// Deprecated: [v0.120.0] Use NewNopSettingsWithType instead. -func NewNopSettings() receiver.Settings { - return NewNopSettingsWithType(NopType) +// NewNopSettings returns a new nop settings for Create*Receiver functions with the given type. +func NewNopSettings(typ component.Type) receiver.Settings { + return receiver.Settings{ + ID: component.NewIDWithName(typ, uuid.NewString()), + TelemetrySettings: componenttest.NewNopTelemetrySettings(), + BuildInfo: component.NewDefaultBuildInfo(), + } } +// Deprecated: [v0.121.0] Use NewNopSettings(NopType) instead. // NewNopSettingsWithType returns a new nop settings for Create*Receiver functions with the given type. func NewNopSettingsWithType(typ component.Type) receiver.Settings { return receiver.Settings{ diff --git a/receiver/receivertest/nop_receiver_test.go b/receiver/receivertest/nop_receiver_test.go index a427dee68c..c8886d0928 100644 --- a/receiver/receivertest/nop_receiver_test.go +++ b/receiver/receivertest/nop_receiver_test.go @@ -22,22 +22,22 @@ func TestNewNopFactory(t *testing.T) { cfg := factory.CreateDefaultConfig() assert.Equal(t, &nopConfig{}, cfg) - traces, err := factory.CreateTraces(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + traces, err := factory.CreateTraces(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, traces.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, traces.Shutdown(context.Background())) - metrics, err := factory.CreateMetrics(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + metrics, err := factory.CreateMetrics(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, metrics.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, metrics.Shutdown(context.Background())) - logs, err := factory.CreateLogs(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + logs, err := factory.CreateLogs(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, logs.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, logs.Shutdown(context.Background())) - profiles, err := factory.(xreceiver.Factory).CreateProfiles(context.Background(), NewNopSettingsWithType(NopType), cfg, consumertest.NewNop()) + profiles, err := factory.(xreceiver.Factory).CreateProfiles(context.Background(), NewNopSettings(NopType), cfg, consumertest.NewNop()) require.NoError(t, err) assert.NoError(t, profiles.Start(context.Background(), componenttest.NewNopHost())) assert.NoError(t, profiles.Shutdown(context.Background())) diff --git a/scraper/scraperhelper/controller_test.go b/scraper/scraperhelper/controller_test.go index ea9fa1c826..96723c4583 100644 --- a/scraper/scraperhelper/controller_test.go +++ b/scraper/scraperhelper/controller_test.go @@ -530,7 +530,7 @@ func TestSingleLogsScraperPerInterval(t *testing.T) { recv, err := NewLogsController( cfg, - receivertest.NewNopSettingsWithType(receivertest.NopType), + receivertest.NewNopSettings(receivertest.NopType), new(consumertest.LogsSink), addLogsScraper(component.MustNewType("scraper"), scp), WithTickerChannel(tickerCh), @@ -573,7 +573,7 @@ func TestSingleMetricsScraperPerInterval(t *testing.T) { recv, err := NewMetricsController( cfg, - receivertest.NewNopSettingsWithType(receivertest.NopType), + receivertest.NewNopSettings(receivertest.NopType), new(consumertest.MetricsSink), AddScraper(component.MustNewType("scraper"), scp), WithTickerChannel(tickerCh), @@ -618,7 +618,7 @@ func TestLogsScraperControllerStartsOnInit(t *testing.T) { CollectionInterval: time.Hour, InitialDelay: 0, }, - receivertest.NewNopSettingsWithType(receivertest.NopType), + receivertest.NewNopSettings(receivertest.NopType), new(consumertest.LogsSink), addLogsScraper(component.MustNewType("scraper"), scp), ) @@ -645,7 +645,7 @@ func TestMetricsScraperControllerStartsOnInit(t *testing.T) { CollectionInterval: time.Hour, InitialDelay: 0, }, - receivertest.NewNopSettingsWithType(receivertest.NopType), + receivertest.NewNopSettings(receivertest.NopType), new(consumertest.MetricsSink), AddScraper(component.MustNewType("scraper"), scp), ) @@ -681,7 +681,7 @@ func TestLogsScraperControllerInitialDelay(t *testing.T) { r, err := NewLogsController( &cfg, - receivertest.NewNopSettingsWithType(receivertest.NopType), + receivertest.NewNopSettings(receivertest.NopType), new(consumertest.LogsSink), addLogsScraper(component.MustNewType("scraper"), scp), ) @@ -720,7 +720,7 @@ func TestMetricsScraperControllerInitialDelay(t *testing.T) { r, err := NewMetricsController( &cfg, - receivertest.NewNopSettingsWithType(receivertest.NopType), + receivertest.NewNopSettings(receivertest.NopType), new(consumertest.MetricsSink), AddScraper(component.MustNewType("scraper"), scp), ) @@ -750,7 +750,7 @@ func TestLogsScraperShutdownBeforeScrapeCanStart(t *testing.T) { r, err := NewLogsController( &cfg, - receivertest.NewNopSettingsWithType(receivertest.NopType), + receivertest.NewNopSettings(receivertest.NopType), new(consumertest.LogsSink), addLogsScraper(component.MustNewType("scraper"), scp), ) @@ -784,7 +784,7 @@ func TestMetricsScraperShutdownBeforeScrapeCanStart(t *testing.T) { r, err := NewMetricsController( &cfg, - receivertest.NewNopSettingsWithType(receivertest.NopType), + receivertest.NewNopSettings(receivertest.NopType), new(consumertest.MetricsSink), AddScraper(component.MustNewType("scraper"), scp), ) diff --git a/scraper/scrapertest/settings.go b/scraper/scrapertest/settings.go index f6eeb98cfb..dbf50c9ba3 100644 --- a/scraper/scrapertest/settings.go +++ b/scraper/scrapertest/settings.go @@ -13,12 +13,16 @@ import ( var NopType = component.MustNewType("nop") -// NewNopSettings returns a new nop scraper.Settings. -// Deprecated: [v0.120.0] Use NewNopSettingsWithType(NopType) instead. -func NewNopSettings() scraper.Settings { - return NewNopSettingsWithType(NopType) +// NewNopSettings returns a new nop scraper.Settings with the given type. +func NewNopSettings(typ component.Type) scraper.Settings { + return scraper.Settings{ + ID: component.NewIDWithName(typ, uuid.NewString()), + TelemetrySettings: componenttest.NewNopTelemetrySettings(), + BuildInfo: component.NewDefaultBuildInfo(), + } } +// Deprecated: [v0.121.0] Use NewNopSettings(NopType) instead. // NewNopSettings returns a new nop scraper.Settings with the given type. func NewNopSettingsWithType(typ component.Type) scraper.Settings { return scraper.Settings{ diff --git a/service/internal/builders/builders_test/connector_test.go b/service/internal/builders/builders_test/connector_test.go index ba8c733f3b..d6c651e00d 100644 --- a/service/internal/builders/builders_test/connector_test.go +++ b/service/internal/builders/builders_test/connector_test.go @@ -378,7 +378,7 @@ func TestNewNopConnectorConfigsAndFactories(t *testing.T) { factory := connectortest.NewNopFactory() cfg := factory.CreateDefaultConfig() - set := connectortest.NewNopSettingsWithType(factory.Type()) + set := connectortest.NewNopSettings(factory.Type()) set.ID = component.NewIDWithName(builders.NopType, "conn") tracesToTraces, err := factory.CreateTracesToTraces(context.Background(), set, cfg, consumertest.NewNop()) diff --git a/service/internal/builders/builders_test/exporter_test.go b/service/internal/builders/builders_test/exporter_test.go index e930b71b04..4124a3e88d 100644 --- a/service/internal/builders/builders_test/exporter_test.go +++ b/service/internal/builders/builders_test/exporter_test.go @@ -157,7 +157,7 @@ func TestNewNopExporterConfigsAndFactories(t *testing.T) { factory := exportertest.NewNopFactory() cfg := factory.CreateDefaultConfig() - set := exportertest.NewNopSettingsWithType(factory.Type()) + set := exportertest.NewNopSettings(factory.Type()) set.ID = component.NewID(builders.NopType) traces, err := factory.CreateTraces(context.Background(), set, cfg) diff --git a/service/internal/builders/builders_test/extension_test.go b/service/internal/builders/builders_test/extension_test.go index 26d135e62f..bbabcda6b1 100644 --- a/service/internal/builders/builders_test/extension_test.go +++ b/service/internal/builders/builders_test/extension_test.go @@ -74,7 +74,7 @@ func TestNewNopExtensionConfigsAndFactories(t *testing.T) { factory := extensiontest.NewNopFactory() cfg := factory.CreateDefaultConfig() - set := extensiontest.NewNopSettingsWithType(factory.Type()) + set := extensiontest.NewNopSettings(factory.Type()) set.ID = component.NewID(builders.NopType) ext, err := factory.Create(context.Background(), set, cfg) diff --git a/service/internal/builders/builders_test/processor_test.go b/service/internal/builders/builders_test/processor_test.go index 275ddb227e..1e12571ebf 100644 --- a/service/internal/builders/builders_test/processor_test.go +++ b/service/internal/builders/builders_test/processor_test.go @@ -188,7 +188,7 @@ func TestNewNopProcessorBuilder(t *testing.T) { factory := processortest.NewNopFactory() cfg := factory.CreateDefaultConfig() - set := processortest.NewNopSettingsWithType(factory.Type()) + set := processortest.NewNopSettings(factory.Type()) set.ID = component.NewID(builders.NopType) traces, err := factory.CreateTraces(context.Background(), set, cfg, consumertest.NewNop()) diff --git a/service/internal/builders/builders_test/receiver_test.go b/service/internal/builders/builders_test/receiver_test.go index d0c0d2c349..fa88a972a1 100644 --- a/service/internal/builders/builders_test/receiver_test.go +++ b/service/internal/builders/builders_test/receiver_test.go @@ -188,7 +188,7 @@ func TestNewNopReceiverConfigsAndFactories(t *testing.T) { factory := receivertest.NewNopFactory() cfg := factory.CreateDefaultConfig() - set := receivertest.NewNopSettingsWithType(factory.Type()) + set := receivertest.NewNopSettings(factory.Type()) set.ID = component.NewID(builders.NopType) traces, err := factory.CreateTraces(context.Background(), set, cfg, consumertest.NewNop()) diff --git a/service/internal/testcomponents/example_router_test.go b/service/internal/testcomponents/example_router_test.go index 48984446d3..76c424ad50 100644 --- a/service/internal/testcomponents/example_router_test.go +++ b/service/internal/testcomponents/example_router_test.go @@ -51,7 +51,7 @@ func TestTracesRouter(t *testing.T) { cfg := ExampleRouterConfig{Traces: &LeftRightConfig{Left: leftID, Right: rightID}} tr, err := ExampleRouterFactory.CreateTracesToTraces( - context.Background(), connectortest.NewNopSettingsWithType(ExampleRouterFactory.Type()), cfg, router) + context.Background(), connectortest.NewNopSettings(ExampleRouterFactory.Type()), cfg, router) require.NoError(t, err) assert.False(t, tr.Capabilities().MutatesData) @@ -90,7 +90,7 @@ func TestMetricsRouter(t *testing.T) { cfg := ExampleRouterConfig{Metrics: &LeftRightConfig{Left: leftID, Right: rightID}} mr, err := ExampleRouterFactory.CreateMetricsToMetrics( - context.Background(), connectortest.NewNopSettingsWithType(ExampleRouterFactory.Type()), cfg, router) + context.Background(), connectortest.NewNopSettings(ExampleRouterFactory.Type()), cfg, router) require.NoError(t, err) assert.False(t, mr.Capabilities().MutatesData) @@ -129,7 +129,7 @@ func TestLogsRouter(t *testing.T) { cfg := ExampleRouterConfig{Logs: &LeftRightConfig{Left: leftID, Right: rightID}} lr, err := ExampleRouterFactory.CreateLogsToLogs( - context.Background(), connectortest.NewNopSettingsWithType(ExampleRouterFactory.Type()), cfg, router) + context.Background(), connectortest.NewNopSettings(ExampleRouterFactory.Type()), cfg, router) require.NoError(t, err) assert.False(t, lr.Capabilities().MutatesData) @@ -168,7 +168,7 @@ func TestProfilesRouter(t *testing.T) { cfg := ExampleRouterConfig{Profiles: &LeftRightConfig{Left: leftID, Right: rightID}} tr, err := ExampleRouterFactory.CreateProfilesToProfiles( - context.Background(), connectortest.NewNopSettingsWithType(ExampleRouterFactory.Type()), cfg, router) + context.Background(), connectortest.NewNopSettings(ExampleRouterFactory.Type()), cfg, router) require.NoError(t, err) assert.False(t, tr.Capabilities().MutatesData)