open-telemetry
/
opentelemetry-collector
mirror of https://github.com/open-telemetry/opentelemetry-collector.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add `component.Type` parameter to `NewNopSettings` And deprecate `NewNopSettingsWithType` (#12452) 

<!--Ex. Fixing a bug - Describe the bug and how this fixes the issue.
Ex. Adding a feature - Explain what this achieves.-->
#### Description
Add `component.Type` parameter to `NewNopSettings` And deprecate
`NewNopSettingsWithType` cc @mx-psi

<!-- Issue number if applicable -->
#### Link to tracking issue
Relevant to #12305 

<!--Describe what testing was performed and which tests were added.-->
#### Testing
Updated

<!--Describe the documentation added.-->
#### Documentation
Added

<!--Please delete paragraphs that you did not use before submitting.-->
This commit is contained in:
Chao Weng 2025-02-21 19:17:45 +08:00 committed by GitHub
parent 04fe234fa3
commit 6de29ce169
81 changed files with 408 additions and 359 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
.chloggen/deprecate-newnopsettingswithtype.yaml Normal file
View File

@ -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]

4
cmd/mdatagen/internal/sampleprocessor/generated_component_test.go
View File

@ -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)

6
cmd/mdatagen/internal/samplereceiver/generated_component_test.go
View File

@ -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()))

2
cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics_test.go
View File

@ -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))

2
cmd/mdatagen/internal/samplereceiver/internal/metadatatest/generated_telemetrytest.go
View File

@ -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

2
cmd/mdatagen/internal/samplereceiver/metrics_test.go
View File

@ -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())
}

6
cmd/mdatagen/internal/samplescraper/generated_component_test.go
View File

@ -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()))

2
cmd/mdatagen/internal/samplescraper/internal/metadata/generated_metrics_test.go
View File

@ -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))

32
cmd/mdatagen/internal/templates/component_test.go.tmpl
View File

@ -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()))

2
cmd/mdatagen/internal/templates/metrics_test.go.tmpl
View File

@ -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))

2
cmd/mdatagen/internal/templates/telemetrytest.go.tmpl
View File

@ -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

12
connector/connectortest/connector.go
View File

@ -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{

32
connector/connectortest/connector_test.go
View File

@ -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()))

2
connector/forwardconnector/forward_test.go
View File

@ -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)

6
connector/forwardconnector/generated_component_test.go
View File

@ -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()))

8
exporter/debugexporter/exporter_test.go
View File

@ -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)

8
exporter/debugexporter/factory_test.go
View File

@ -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)
}

4
exporter/debugexporter/generated_component_test.go
View File

@ -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)

12
exporter/exporterhelper/internal/base_exporter_test.go
View File

@ -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...)

2
exporter/exporterhelper/internal/batcher/disabled_batcher_test.go
View File

@ -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)

2
exporter/exporterhelper/internal/queue_sender_test.go
View File

@ -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,

14
exporter/exporterhelper/internal/retry_sender_test.go
View File

@ -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())

38
exporter/exporterhelper/logs_test.go
View File

@ -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)

38
exporter/exporterhelper/metrics_test.go
View File

@ -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)

38
exporter/exporterhelper/traces_test.go
View File

@ -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)

38
exporter/exporterhelper/xexporterhelper/profiles_test.go
View File

@ -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)

10
exporter/exporterqueue/persistent_queue_test.go
View File

@ -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{

12
exporter/exportertest/contract_checker.go
View File

@ -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)

12
exporter/exportertest/nop_exporter.go
View File

@ -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{

8
exporter/exportertest/nop_exporter_test.go
View File

@ -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()))

4
exporter/nopexporter/generated_component_test.go
View File

@ -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)

6
exporter/nopexporter/nop_exporter_test.go
View File

@ -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()))

8
exporter/otlpexporter/factory_test.go
View File

@ -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)

4
exporter/otlpexporter/generated_component_test.go
View File

@ -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)

18
exporter/otlpexporter/otlp_test.go
View File

@ -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)

8
exporter/otlphttpexporter/factory_test.go
View File

@ -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)

4
exporter/otlphttpexporter/generated_component_test.go
View File

@ -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)

30
exporter/otlphttpexporter/otlp_test.go
View File

@ -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"

12
extension/extensiontest/nop_extension.go
View File

@ -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{

2
extension/extensiontest/nop_extension_test.go
View File

@ -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()))

2
extension/memorylimiterextension/factory_test.go
View File

@ -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)

4
extension/memorylimiterextension/generated_component_test.go
View File

@ -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()))

4
extension/zpagesextension/factory_test.go
View File

@ -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)

6
extension/zpagesextension/generated_component_test.go
View File

@ -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()))

14
internal/e2e/otlphttp_test.go
View File

@ -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)
}

34
processor/batchprocessor/batch_processor_test.go
View File

@ -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())) }()

2
processor/batchprocessor/factory_test.go
View File

@ -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")

4
processor/batchprocessor/generated_component_test.go
View File

@ -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)

2
processor/batchprocessor/internal/metadatatest/generated_telemetrytest.go
View File

@ -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

2
processor/memorylimiterprocessor/factory_test.go
View File

@ -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())

2
processor/memorylimiterprocessor/generated_component_test.go
View File

@ -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)

2
processor/memorylimiterprocessor/internal/metadatatest/generated_telemetrytest.go
View File

@ -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

14
processor/memorylimiterprocessor/memorylimiter_test.go
View File

@ -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,

14
processor/processorhelper/logs_test.go
View File

@ -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
}

12
processor/processorhelper/metrics_test.go
View File

@ -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()))

12
processor/processorhelper/traces_test.go
View File

@ -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()))

12
processor/processorhelper/xprocessorhelper/profiles_test.go
View File

@ -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()))

12
processor/processortest/nop_processor.go
View File

@ -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{

8
processor/processortest/nop_processor_test.go
View File

@ -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()))

6
processor/processortest/shutdown_verifier.go
View File

@ -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
}

6
processor/processortest/unhealthy_processor_test.go
View File

@ -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()))

6
receiver/nopreceiver/generated_component_test.go
View File

@ -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()))

6
receiver/nopreceiver/nop_receiver_test.go
View File

@ -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()))

10
receiver/otlpreceiver/factory_test.go
View File

@ -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)

2
receiver/otlpreceiver/fuzz_test.go
View File

@ -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)

6
receiver/otlpreceiver/generated_component_test.go
View File

@ -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()))

2
receiver/otlpreceiver/internal/logs/otlp_test.go
View File

@ -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,

2
receiver/otlpreceiver/internal/metrics/otlp_test.go
View File

@ -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,

2
receiver/otlpreceiver/internal/trace/otlp_test.go
View File

@ -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,

8
receiver/otlpreceiver/otlp_test.go
View File

@ -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(),

6
receiver/receivertest/contract_checker.go
View File

@ -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")
}

12
receiver/receivertest/nop_receiver.go
View File

@ -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{

8
receiver/receivertest/nop_receiver_test.go
View File

@ -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()))

16
scraper/scraperhelper/controller_test.go
View File

@ -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),
)

12
scraper/scrapertest/settings.go
View File

@ -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{

2
service/internal/builders/builders_test/connector_test.go
View File

@ -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())

2
service/internal/builders/builders_test/exporter_test.go
View File

@ -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)

2
service/internal/builders/builders_test/extension_test.go
View File

@ -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)

2
service/internal/builders/builders_test/processor_test.go
View File

@ -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())

2
service/internal/builders/builders_test/receiver_test.go
View File

@ -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())

8
service/internal/testcomponents/example_router_test.go
View File

@ -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)