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

Deprecate funcs that repeate exporter in name (#11370) 

Signed-off-by: Bogdan Drutu <bogdandrutu@gmail.com>
This commit is contained in:
Bogdan Drutu 2024-10-08 19:38:32 -07:00 committed by GitHub
parent cceb6c14e0
commit 738b9dfe66
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
36 changed files with 574 additions and 466 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
.chloggen/rm-dup-exporter.yaml Normal file
View File

@ -0,0 +1,27 @@
# Use this changelog template to create an entry for release notes.
# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
change_type: deprecation
# The name of the component, or a single word describing the area of concern, (e.g. otlpreceiver)
component: exporter
# A brief description of the change. Surround your text with quotes ("") if it needs to start with a backtick (`).
note: Deprecate funcs that repeate exporter in name
# One or more tracking issues or pull requests related to the change
issues: [11370]
# (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: |
Factory.Create[Traces|Metrics|Logs|Profiles]Exporter -> Factory.Create[Traces|Metrics|Logs|Profiles] |
Factory.[Traces|Metrics|Logs|Profiles]ExporterStability -> Factory.[Traces|Metrics|Logs|Profiles]Stability
# 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]

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

@ -76,7 +76,7 @@ func TestComponentLifecycle(t *testing.T) {
{
name: "logs",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateLogsExporter(ctx, set, cfg)
return factory.CreateLogs(ctx, set, cfg)
},
},
{{ end }}
@ -84,7 +84,7 @@ func TestComponentLifecycle(t *testing.T) {
{
name: "metrics",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateMetricsExporter(ctx, set, cfg)
return factory.CreateMetrics(ctx, set, cfg)
},
},
{{ end }}
@ -92,7 +92,7 @@ func TestComponentLifecycle(t *testing.T) {
{
name: "traces",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateTracesExporter(ctx, set, cfg)
return factory.CreateTraces(ctx, set, cfg)
},
},
{{ end }}

6
exporter/debugexporter/exporter.go
View File

@ -47,7 +47,7 @@ func newDebugExporter(logger *zap.Logger, verbosity configtelemetry.Level) *debu
}
func (s *debugExporter) pushTraces(_ context.Context, td ptrace.Traces) error {
s.logger.Info("TracesExporter",
s.logger.Info("Traces",
zap.Int("resource spans", td.ResourceSpans().Len()),
zap.Int("spans", td.SpanCount()))
if s.verbosity == configtelemetry.LevelBasic {
@ -63,7 +63,7 @@ func (s *debugExporter) pushTraces(_ context.Context, td ptrace.Traces) error {
}
func (s *debugExporter) pushMetrics(_ context.Context, md pmetric.Metrics) error {
s.logger.Info("MetricsExporter",
s.logger.Info("Metrics",
zap.Int("resource metrics", md.ResourceMetrics().Len()),
zap.Int("metrics", md.MetricCount()),
zap.Int("data points", md.DataPointCount()))
@ -80,7 +80,7 @@ func (s *debugExporter) pushMetrics(_ context.Context, md pmetric.Metrics) error
}
func (s *debugExporter) pushLogs(_ context.Context, ld plog.Logs) error {
s.logger.Info("LogsExporter",
s.logger.Info("Logs",
zap.Int("resource logs", ld.ResourceLogs().Len()),
zap.Int("log records", ld.LogRecordCount()))

14
exporter/debugexporter/exporter_test.go
View File

@ -20,10 +20,10 @@ import (
"go.opentelemetry.io/collector/pdata/testdata"
)
func TestTracesExporterNoErrors(t *testing.T) {
func TestTracesNoErrors(t *testing.T) {
for _, tc := range createTestCases() {
t.Run(tc.name, func(t *testing.T) {
lte, err := createTracesExporter(context.Background(), exportertest.NewNopSettings(), tc.config)
lte, err := createTraces(context.Background(), exportertest.NewNopSettings(), tc.config)
require.NotNil(t, lte)
assert.NoError(t, err)
@ -35,10 +35,10 @@ func TestTracesExporterNoErrors(t *testing.T) {
}
}
func TestMetricsExporterNoErrors(t *testing.T) {
func TestMetricsNoErrors(t *testing.T) {
for _, tc := range createTestCases() {
t.Run(tc.name, func(t *testing.T) {
lme, err := createMetricsExporter(context.Background(), exportertest.NewNopSettings(), tc.config)
lme, err := createMetrics(context.Background(), exportertest.NewNopSettings(), tc.config)
require.NotNil(t, lme)
assert.NoError(t, err)
@ -53,10 +53,10 @@ func TestMetricsExporterNoErrors(t *testing.T) {
}
}
func TestLogsExporterNoErrors(t *testing.T) {
func TestLogsNoErrors(t *testing.T) {
for _, tc := range createTestCases() {
t.Run(tc.name, func(t *testing.T) {
lle, err := createLogsExporter(context.Background(), exportertest.NewNopSettings(), createDefaultConfig())
lle, err := createLogs(context.Background(), exportertest.NewNopSettings(), createDefaultConfig())
require.NotNil(t, lle)
assert.NoError(t, err)
@ -68,7 +68,7 @@ func TestLogsExporterNoErrors(t *testing.T) {
}
}
func TestExporterErrors(t *testing.T) {
func TestErrors(t *testing.T) {
le := newDebugExporter(zaptest.NewLogger(t), configtelemetry.LevelDetailed)
require.NotNil(t, le)

30
exporter/debugexporter/factory.go
View File

@ -32,9 +32,9 @@ func NewFactory() exporter.Factory {
return exporter.NewFactory(
componentType,
createDefaultConfig,
exporter.WithTraces(createTracesExporter, metadata.TracesStability),
exporter.WithMetrics(createMetricsExporter, metadata.MetricsStability),
exporter.WithLogs(createLogsExporter, metadata.LogsStability),
exporter.WithTraces(createTraces, metadata.TracesStability),
exporter.WithMetrics(createMetrics, metadata.MetricsStability),
exporter.WithLogs(createLogs, metadata.LogsStability),
)
}
@ -47,36 +47,36 @@ func createDefaultConfig() component.Config {
}
}
func createTracesExporter(ctx context.Context, set exporter.Settings, config component.Config) (exporter.Traces, error) {
func createTraces(ctx context.Context, set exporter.Settings, config component.Config) (exporter.Traces, error) {
cfg := config.(*Config)
exporterLogger := createLogger(cfg, set.TelemetrySettings.Logger)
debugExporter := newDebugExporter(exporterLogger, cfg.Verbosity)
return exporterhelper.NewTracesExporter(ctx, set, config,
debugExporter.pushTraces,
debug := newDebugExporter(exporterLogger, cfg.Verbosity)
return exporterhelper.NewTraces(ctx, set, config,
debug.pushTraces,
exporterhelper.WithCapabilities(consumer.Capabilities{MutatesData: false}),
exporterhelper.WithTimeout(exporterhelper.TimeoutConfig{Timeout: 0}),
exporterhelper.WithShutdown(otlptext.LoggerSync(exporterLogger)),
)
}
func createMetricsExporter(ctx context.Context, set exporter.Settings, config component.Config) (exporter.Metrics, error) {
func createMetrics(ctx context.Context, set exporter.Settings, config component.Config) (exporter.Metrics, error) {
cfg := config.(*Config)
exporterLogger := createLogger(cfg, set.TelemetrySettings.Logger)
debugExporter := newDebugExporter(exporterLogger, cfg.Verbosity)
return exporterhelper.NewMetricsExporter(ctx, set, config,
debugExporter.pushMetrics,
debug := newDebugExporter(exporterLogger, cfg.Verbosity)
return exporterhelper.NewMetrics(ctx, set, config,
debug.pushMetrics,
exporterhelper.WithCapabilities(consumer.Capabilities{MutatesData: false}),
exporterhelper.WithTimeout(exporterhelper.TimeoutConfig{Timeout: 0}),
exporterhelper.WithShutdown(otlptext.LoggerSync(exporterLogger)),
)
}
func createLogsExporter(ctx context.Context, set exporter.Settings, config component.Config) (exporter.Logs, error) {
func createLogs(ctx context.Context, set exporter.Settings, config component.Config) (exporter.Logs, error) {
cfg := config.(*Config)
exporterLogger := createLogger(cfg, set.TelemetrySettings.Logger)
debugExporter := newDebugExporter(exporterLogger, cfg.Verbosity)
return exporterhelper.NewLogsExporter(ctx, set, config,
debugExporter.pushLogs,
debug := newDebugExporter(exporterLogger, cfg.Verbosity)
return exporterhelper.NewLogs(ctx, set, config,
debug.pushLogs,
exporterhelper.WithCapabilities(consumer.Capabilities{MutatesData: false}),
exporterhelper.WithTimeout(exporterhelper.TimeoutConfig{Timeout: 0}),
exporterhelper.WithShutdown(otlptext.LoggerSync(exporterLogger)),

12
exporter/debugexporter/factory_test.go
View File

@ -21,29 +21,29 @@ func TestCreateDefaultConfig(t *testing.T) {
assert.NoError(t, componenttest.CheckConfigStruct(cfg))
}
func TestCreateMetricsExporter(t *testing.T) {
func TestCreateMetrics(t *testing.T) {
factory := NewFactory()
cfg := factory.CreateDefaultConfig()
me, err := factory.CreateMetricsExporter(context.Background(), exportertest.NewNopSettings(), cfg)
me, err := factory.CreateMetrics(context.Background(), exportertest.NewNopSettings(), cfg)
require.NoError(t, err)
assert.NotNil(t, me)
}
func TestCreateTracesExporter(t *testing.T) {
func TestCreateTraces(t *testing.T) {
factory := NewFactory()
cfg := factory.CreateDefaultConfig()
te, err := factory.CreateTracesExporter(context.Background(), exportertest.NewNopSettings(), cfg)
te, err := factory.CreateTraces(context.Background(), exportertest.NewNopSettings(), cfg)
require.NoError(t, err)
assert.NotNil(t, te)
}
func TestCreateLogsExporter(t *testing.T) {
func TestCreateLogs(t *testing.T) {
factory := NewFactory()
cfg := factory.CreateDefaultConfig()
te, err := factory.CreateLogsExporter(context.Background(), exportertest.NewNopSettings(), cfg)
te, err := factory.CreateLogs(context.Background(), exportertest.NewNopSettings(), cfg)
require.NoError(t, err)
assert.NotNil(t, te)
}

6
exporter/debugexporter/generated_component_test.go
View File

@ -39,21 +39,21 @@ func TestComponentLifecycle(t *testing.T) {
{
name: "logs",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateLogsExporter(ctx, set, cfg)
return factory.CreateLogs(ctx, set, cfg)
},
},
{
name: "metrics",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateMetricsExporter(ctx, set, cfg)
return factory.CreateMetrics(ctx, set, cfg)
},
},
{
name: "traces",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateTracesExporter(ctx, set, cfg)
return factory.CreateTraces(ctx, set, cfg)
},
},
}

88
exporter/exporter.go
View File

@ -48,28 +48,46 @@ type Settings struct {
type Factory interface {
component.Factory
// CreateTracesExporter creates a TracesExporter based on this config.
// CreateTraces creates a Traces exporter based on this config.
// If the exporter type does not support tracing,
// this function returns the error [pipeline.ErrSignalNotSupported].
CreateTraces(ctx context.Context, set Settings, cfg component.Config) (Traces, error)
// TracesStability gets the stability level of the Traces exporter.
TracesStability() component.StabilityLevel
// Deprecated: [v0.112.0] use CreateTraces.
CreateTracesExporter(ctx context.Context, set Settings, cfg component.Config) (Traces, error)
// TracesExporterStability gets the stability level of the TracesExporter.
// Deprecated: [v0.112.0] use TracesStability.
TracesExporterStability() component.StabilityLevel
// CreateMetricsExporter creates a MetricsExporter based on this config.
// CreateMetrics creates a Metrics exporter based on this config.
// If the exporter type does not support metrics,
// this function returns the error [pipeline.ErrSignalNotSupported].
CreateMetrics(ctx context.Context, set Settings, cfg component.Config) (Metrics, error)
// MetricsStability gets the stability level of the Metrics exporter.
MetricsStability() component.StabilityLevel
// Deprecated: [v0.112.0] use CreateMetrics.
CreateMetricsExporter(ctx context.Context, set Settings, cfg component.Config) (Metrics, error)
// MetricsExporterStability gets the stability level of the MetricsExporter.
// Deprecated: [v0.112.0] use MetricsStability.
MetricsExporterStability() component.StabilityLevel
// CreateLogsExporter creates a LogsExporter based on the config.
// CreateLogs creates a Logs exporter based on the config.
// If the exporter type does not support logs,
// this function returns the error [pipeline.ErrSignalNotSupported].
CreateLogs(ctx context.Context, set Settings, cfg component.Config) (Logs, error)
// LogsStability gets the stability level of the Logs exporter.
LogsStability() component.StabilityLevel
// Deprecated: [v0.112.0] use CreateLogs.
CreateLogsExporter(ctx context.Context, set Settings, cfg component.Config) (Logs, error)
// LogsExporterStability gets the stability level of the LogsExporter.
// Deprecated: [v0.112.0] use LogsStability.
LogsExporterStability() component.StabilityLevel
unexportedFactoryFunc()
@ -77,52 +95,67 @@ type Factory interface {
// FactoryOption apply changes to Factory.
type FactoryOption interface {
// applyExporterFactoryOption applies the option.
applyExporterFactoryOption(o *factory)
// applyOption applies the option.
applyOption(o *factory)
}
var _ FactoryOption = (*factoryOptionFunc)(nil)
// factoryOptionFunc is an ExporterFactoryOption created through a function.
// factoryOptionFunc is an FactoryOption created through a function.
type factoryOptionFunc func(*factory)
func (f factoryOptionFunc) applyExporterFactoryOption(o *factory) {
func (f factoryOptionFunc) applyOption(o *factory) {
f(o)
}
// CreateTracesFunc is the equivalent of Factory.CreateTraces.
type CreateTracesFunc func(context.Context, Settings, component.Config) (Traces, error)
// CreateTracesExporter implements Factory.CreateTraces.
func (f CreateTracesFunc) CreateTracesExporter(ctx context.Context, set Settings, cfg component.Config) (Traces, error) {
// CreateTraces implements Factory.CreateTraces.
func (f CreateTracesFunc) CreateTraces(ctx context.Context, set Settings, cfg component.Config) (Traces, error) {
if f == nil {
return nil, pipeline.ErrSignalNotSupported
}
return f(ctx, set, cfg)
}
// Deprecated: [v0.112.0] use CreateTraces.
func (f CreateTracesFunc) CreateTracesExporter(ctx context.Context, set Settings, cfg component.Config) (Traces, error) {
return f.CreateTraces(ctx, set, cfg)
}
// CreateMetricsFunc is the equivalent of Factory.CreateMetrics.
type CreateMetricsFunc func(context.Context, Settings, component.Config) (Metrics, error)
// CreateMetricsExporter implements Factory.CreateMetrics.
func (f CreateMetricsFunc) CreateMetricsExporter(ctx context.Context, set Settings, cfg component.Config) (Metrics, error) {
// CreateMetrics implements Factory.CreateMetrics.
func (f CreateMetricsFunc) CreateMetrics(ctx context.Context, set Settings, cfg component.Config) (Metrics, error) {
if f == nil {
return nil, pipeline.ErrSignalNotSupported
}
return f(ctx, set, cfg)
}
// Deprecated: [v0.112.0] use CreateMetrics.
func (f CreateMetricsFunc) CreateMetricsExporter(ctx context.Context, set Settings, cfg component.Config) (Metrics, error) {
return f.CreateMetrics(ctx, set, cfg)
}
// CreateLogsFunc is the equivalent of Factory.CreateLogs.
type CreateLogsFunc func(context.Context, Settings, component.Config) (Logs, error)
// CreateLogsExporter implements Factory.CreateLogs.
func (f CreateLogsFunc) CreateLogsExporter(ctx context.Context, set Settings, cfg component.Config) (Logs, error) {
// CreateLogs implements Factory.CreateLogs.
func (f CreateLogsFunc) CreateLogs(ctx context.Context, set Settings, cfg component.Config) (Logs, error) {
if f == nil {
return nil, pipeline.ErrSignalNotSupported
}
return f(ctx, set, cfg)
}
// Deprecated: [v0.112.0] use CreateLogs.
func (f CreateLogsFunc) CreateLogsExporter(ctx context.Context, set Settings, cfg component.Config) (Logs, error) {
return f.CreateLogs(ctx, set, cfg)
}
type factory struct {
cfgType component.Type
component.CreateDefaultConfigFunc
@ -140,19 +173,34 @@ func (f *factory) Type() component.Type {
func (f *factory) unexportedFactoryFunc() {}
func (f *factory) TracesStability() component.StabilityLevel {
return f.tracesStabilityLevel
}
func (f *factory) MetricsStability() component.StabilityLevel {
return f.metricsStabilityLevel
}
func (f *factory) LogsStability() component.StabilityLevel {
return f.logsStabilityLevel
}
// Deprecated: [v0.112.0] use TracesStability.
func (f *factory) TracesExporterStability() component.StabilityLevel {
return f.tracesStabilityLevel
}
// Deprecated: [v0.112.0] use MetricsStability.
func (f *factory) MetricsExporterStability() component.StabilityLevel {
return f.metricsStabilityLevel
}
// Deprecated: [v0.112.0] use LogsStability.
func (f *factory) LogsExporterStability() component.StabilityLevel {
return f.logsStabilityLevel
}
// WithTraces overrides the default "error not supported" implementation for CreateTracesExporter and the default "undefined" stability level.
// WithTraces overrides the default "error not supported" implementation for Factory.CreateTraces and the default "undefined" stability level.
func WithTraces(createTraces CreateTracesFunc, sl component.StabilityLevel) FactoryOption {
return factoryOptionFunc(func(o *factory) {
o.tracesStabilityLevel = sl
@ -160,7 +208,7 @@ func WithTraces(createTraces CreateTracesFunc, sl component.StabilityLevel) Fact
})
}
// WithMetrics overrides the default "error not supported" implementation for CreateMetricsExporter and the default "undefined" stability level.
// WithMetrics overrides the default "error not supported" implementation for Factory.CreateMetrics and the default "undefined" stability level.
func WithMetrics(createMetrics CreateMetricsFunc, sl component.StabilityLevel) FactoryOption {
return factoryOptionFunc(func(o *factory) {
o.metricsStabilityLevel = sl
@ -168,7 +216,7 @@ func WithMetrics(createMetrics CreateMetricsFunc, sl component.StabilityLevel) F
})
}
// WithLogs overrides the default "error not supported" implementation for CreateLogsExporter and the default "undefined" stability level.
// WithLogs overrides the default "error not supported" implementation for Factory.CreateLogs and the default "undefined" stability level.
func WithLogs(createLogs CreateLogsFunc, sl component.StabilityLevel) FactoryOption {
return factoryOptionFunc(func(o *factory) {
o.logsStabilityLevel = sl
@ -183,7 +231,7 @@ func NewFactory(cfgType component.Type, createDefaultConfig component.CreateDefa
CreateDefaultConfigFunc: createDefaultConfig,
}
for _, opt := range options {
opt.applyExporterFactoryOption(f)
opt.applyOption(f)
}
return f
}

24
exporter/exporter_test.go
View File

@ -22,11 +22,11 @@ func TestNewFactory(t *testing.T) {
func() component.Config { return &defaultCfg })
assert.EqualValues(t, testType, factory.Type())
assert.EqualValues(t, &defaultCfg, factory.CreateDefaultConfig())
_, err := factory.CreateTracesExporter(context.Background(), Settings{}, &defaultCfg)
_, err := factory.CreateTraces(context.Background(), Settings{}, &defaultCfg)
require.Error(t, err)
_, err = factory.CreateMetricsExporter(context.Background(), Settings{}, &defaultCfg)
_, err = factory.CreateMetrics(context.Background(), Settings{}, &defaultCfg)
require.Error(t, err)
_, err = factory.CreateLogsExporter(context.Background(), Settings{}, &defaultCfg)
_, err = factory.CreateLogs(context.Background(), Settings{}, &defaultCfg)
assert.Error(t, err)
}
@ -42,16 +42,16 @@ func TestNewFactoryWithOptions(t *testing.T) {
assert.EqualValues(t, testType, factory.Type())
assert.EqualValues(t, &defaultCfg, factory.CreateDefaultConfig())
assert.Equal(t, component.StabilityLevelDevelopment, factory.TracesExporterStability())
_, err := factory.CreateTracesExporter(context.Background(), Settings{}, &defaultCfg)
assert.Equal(t, component.StabilityLevelDevelopment, factory.TracesStability())
_, err := factory.CreateTraces(context.Background(), Settings{}, &defaultCfg)
require.NoError(t, err)
assert.Equal(t, component.StabilityLevelAlpha, factory.MetricsExporterStability())
_, err = factory.CreateMetricsExporter(context.Background(), Settings{}, &defaultCfg)
assert.Equal(t, component.StabilityLevelAlpha, factory.MetricsStability())
_, err = factory.CreateMetrics(context.Background(), Settings{}, &defaultCfg)
require.NoError(t, err)
assert.Equal(t, component.StabilityLevelDeprecated, factory.LogsExporterStability())
_, err = factory.CreateLogsExporter(context.Background(), Settings{}, &defaultCfg)
assert.Equal(t, component.StabilityLevelDeprecated, factory.LogsStability())
_, err = factory.CreateLogs(context.Background(), Settings{}, &defaultCfg)
assert.NoError(t, err)
}
@ -92,12 +92,12 @@ func TestMakeFactoryMap(t *testing.T) {
}
}
var nopInstance = &nopExporter{
var nopInstance = &nop{
Consumer: consumertest.NewNop(),
}
// nopExporter stores consumed traces and metrics for testing purposes.
type nopExporter struct {
// nop stores consumed traces and metrics for testing purposes.
type nop struct {
component.StartFunc
component.ShutdownFunc
consumertest.Consumer

20
exporter/exporterhelper/logs.go
View File

@ -70,8 +70,8 @@ type logsExporter struct {
consumer.Logs
}
// NewLogsExporter creates an exporter.Logs that records observability metrics and wraps every request with a Span.
func NewLogsExporter(
// NewLogs creates an exporter.Logs that records observability metrics and wraps every request with a Span.
func NewLogs(
ctx context.Context,
set exporter.Settings,
cfg component.Config,
@ -88,9 +88,12 @@ func NewLogsExporter(
internal.WithMarshaler(logsRequestMarshaler), internal.WithUnmarshaler(newLogsRequestUnmarshalerFunc(pusher)),
internal.WithBatchFuncs(mergeLogs, mergeSplitLogs),
}
return NewLogsRequestExporter(ctx, set, requestFromLogs(pusher), append(logsOpts, options...)...)
return NewLogsRequest(ctx, set, requestFromLogs(pusher), append(logsOpts, options...)...)
}
// Deprecated: [v0.112.0] use NewLogs.
var NewLogsExporter = NewLogs
// RequestFromLogsFunc converts plog.Logs data into a user-defined request.
// Experimental: This API is at the early stage of development and may change without backward compatibility
// until https://github.com/open-telemetry/opentelemetry-collector/issues/8122 is resolved.
@ -103,10 +106,10 @@ func requestFromLogs(pusher consumer.ConsumeLogsFunc) RequestFromLogsFunc {
}
}
// NewLogsRequestExporter creates new logs exporter based on custom LogsConverter and RequestSender.
// NewLogsRequest creates new logs exporter based on custom LogsConverter and RequestSender.
// Experimental: This API is at the early stage of development and may change without backward compatibility
// until https://github.com/open-telemetry/opentelemetry-collector/issues/8122 is resolved.
func NewLogsRequestExporter(
func NewLogsRequest(
_ context.Context,
set exporter.Settings,
converter RequestFromLogsFunc,
@ -120,7 +123,7 @@ func NewLogsRequestExporter(
return nil, errNilLogsConverter
}
be, err := internal.NewBaseExporter(set, pipeline.SignalLogs, newLogsExporterWithObservability, options...)
be, err := internal.NewBaseExporter(set, pipeline.SignalLogs, newLogsWithObservability, options...)
if err != nil {
return nil, err
}
@ -146,12 +149,15 @@ func NewLogsRequestExporter(
}, err
}
// Deprecated: [v0.112.0] use NewLogsRequest.
var NewLogsRequestExporter = NewLogsRequest
type logsExporterWithObservability struct {
internal.BaseRequestSender
obsrep *internal.ObsReport
}
func newLogsExporterWithObservability(obsrep *internal.ObsReport) internal.RequestSender {
func newLogsWithObservability(obsrep *internal.ObsReport) internal.RequestSender {
return &logsExporterWithObservability{obsrep: obsrep}
}

148
exporter/exporterhelper/logs_test.go
View File

@ -37,8 +37,8 @@ const (
)
var (
fakeLogsExporterName = component.MustNewIDWithName("fake_logs_exporter", "with_name")
fakeLogsExporterConfig = struct{}{}
fakeLogsName = component.MustNewIDWithName("fake_logs_exporter", "with_name")
fakeLogsConfig = struct{}{}
)
func TestLogsRequest(t *testing.T) {
@ -52,39 +52,39 @@ func TestLogsRequest(t *testing.T) {
)
}
func TestLogsExporter_InvalidName(t *testing.T) {
le, err := NewLogsExporter(context.Background(), exportertest.NewNopSettings(), nil, newPushLogsData(nil))
func TestLogs_InvalidName(t *testing.T) {
le, err := NewLogs(context.Background(), exportertest.NewNopSettings(), nil, newPushLogsData(nil))
require.Nil(t, le)
require.Equal(t, errNilConfig, err)
}
func TestLogsExporter_NilLogger(t *testing.T) {
le, err := NewLogsExporter(context.Background(), exporter.Settings{}, &fakeLogsExporterConfig, newPushLogsData(nil))
func TestLogs_NilLogger(t *testing.T) {
le, err := NewLogs(context.Background(), exporter.Settings{}, &fakeLogsConfig, newPushLogsData(nil))
require.Nil(t, le)
require.Equal(t, errNilLogger, err)
}
func TestLogsRequestExporter_NilLogger(t *testing.T) {
le, err := NewLogsRequestExporter(context.Background(), exporter.Settings{}, (&internal.FakeRequestConverter{}).RequestFromLogsFunc)
func TestLogsRequest_NilLogger(t *testing.T) {
le, err := NewLogsRequest(context.Background(), exporter.Settings{}, (&internal.FakeRequestConverter{}).RequestFromLogsFunc)
require.Nil(t, le)
require.Equal(t, errNilLogger, err)
}
func TestLogsExporter_NilPushLogsData(t *testing.T) {
le, err := NewLogsExporter(context.Background(), exportertest.NewNopSettings(), &fakeLogsExporterConfig, nil)
func TestLogs_NilPushLogsData(t *testing.T) {
le, err := NewLogs(context.Background(), exportertest.NewNopSettings(), &fakeLogsConfig, nil)
require.Nil(t, le)
require.Equal(t, errNilPushLogsData, err)
}
func TestLogsRequestExporter_NilLogsConverter(t *testing.T) {
le, err := NewLogsRequestExporter(context.Background(), exportertest.NewNopSettings(), nil)
func TestLogsRequest_NilLogsConverter(t *testing.T) {
le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(), nil)
require.Nil(t, le)
require.Equal(t, errNilLogsConverter, err)
}
func TestLogsExporter_Default(t *testing.T) {
func TestLogs_Default(t *testing.T) {
ld := plog.NewLogs()
le, err := NewLogsExporter(context.Background(), exportertest.NewNopSettings(), &fakeLogsExporterConfig, newPushLogsData(nil))
le, err := NewLogs(context.Background(), exportertest.NewNopSettings(), &fakeLogsConfig, newPushLogsData(nil))
assert.NotNil(t, le)
require.NoError(t, err)
@ -94,9 +94,9 @@ func TestLogsExporter_Default(t *testing.T) {
assert.NoError(t, le.Shutdown(context.Background()))
}
func TestLogsRequestExporter_Default(t *testing.T) {
func TestLogsRequest_Default(t *testing.T) {
ld := plog.NewLogs()
le, err := NewLogsRequestExporter(context.Background(), exportertest.NewNopSettings(),
le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{}).RequestFromLogsFunc)
assert.NotNil(t, le)
require.NoError(t, err)
@ -107,18 +107,18 @@ func TestLogsRequestExporter_Default(t *testing.T) {
assert.NoError(t, le.Shutdown(context.Background()))
}
func TestLogsExporter_WithCapabilities(t *testing.T) {
func TestLogs_WithCapabilities(t *testing.T) {
capabilities := consumer.Capabilities{MutatesData: true}
le, err := NewLogsExporter(context.Background(), exportertest.NewNopSettings(), &fakeLogsExporterConfig, newPushLogsData(nil), WithCapabilities(capabilities))
le, err := NewLogs(context.Background(), exportertest.NewNopSettings(), &fakeLogsConfig, newPushLogsData(nil), WithCapabilities(capabilities))
require.NoError(t, err)
require.NotNil(t, le)
assert.Equal(t, capabilities, le.Capabilities())
}
func TestLogsRequestExporter_WithCapabilities(t *testing.T) {
func TestLogsRequest_WithCapabilities(t *testing.T) {
capabilities := consumer.Capabilities{MutatesData: true}
le, err := NewLogsRequestExporter(context.Background(), exportertest.NewNopSettings(),
le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{}).RequestFromLogsFunc, WithCapabilities(capabilities))
require.NoError(t, err)
require.NotNil(t, le)
@ -126,36 +126,36 @@ func TestLogsRequestExporter_WithCapabilities(t *testing.T) {
assert.Equal(t, capabilities, le.Capabilities())
}
func TestLogsExporter_Default_ReturnError(t *testing.T) {
func TestLogs_Default_ReturnError(t *testing.T) {
ld := plog.NewLogs()
want := errors.New("my_error")
le, err := NewLogsExporter(context.Background(), exportertest.NewNopSettings(), &fakeLogsExporterConfig, newPushLogsData(want))
le, err := NewLogs(context.Background(), exportertest.NewNopSettings(), &fakeLogsConfig, newPushLogsData(want))
require.NoError(t, err)
require.NotNil(t, le)
require.Equal(t, want, le.ConsumeLogs(context.Background(), ld))
}
func TestLogsRequestExporter_Default_ConvertError(t *testing.T) {
func TestLogsRequest_Default_ConvertError(t *testing.T) {
ld := plog.NewLogs()
want := errors.New("convert_error")
le, err := NewLogsRequestExporter(context.Background(), exportertest.NewNopSettings(),
le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{LogsError: want}).RequestFromLogsFunc)
require.NoError(t, err)
require.NotNil(t, le)
require.Equal(t, consumererror.NewPermanent(want), le.ConsumeLogs(context.Background(), ld))
}
func TestLogsRequestExporter_Default_ExportError(t *testing.T) {
func TestLogsRequest_Default_ExportError(t *testing.T) {
ld := plog.NewLogs()
want := errors.New("export_error")
le, err := NewLogsRequestExporter(context.Background(), exportertest.NewNopSettings(),
le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{RequestError: want}).RequestFromLogsFunc)
require.NoError(t, err)
require.NotNil(t, le)
require.Equal(t, want, le.ConsumeLogs(context.Background(), ld))
}
func TestLogsExporter_WithPersistentQueue(t *testing.T) {
func TestLogs_WithPersistentQueue(t *testing.T) {
qCfg := NewDefaultQueueConfig()
storageID := component.MustNewIDWithName("file_storage", "storage")
qCfg.StorageID = &storageID
@ -163,7 +163,7 @@ func TestLogsExporter_WithPersistentQueue(t *testing.T) {
ts := consumertest.LogsSink{}
set := exportertest.NewNopSettings()
set.ID = component.MustNewIDWithName("test_logs", "with_persistent_queue")
te, err := NewLogsExporter(context.Background(), set, &fakeLogsExporterConfig, ts.ConsumeLogs, WithRetry(rCfg), WithQueue(qCfg))
te, err := NewLogs(context.Background(), set, &fakeLogsConfig, ts.ConsumeLogs, WithRetry(rCfg), WithQueue(qCfg))
require.NoError(t, err)
host := &internal.MockHost{Ext: map[component.ID]component.Component{
@ -179,24 +179,24 @@ func TestLogsExporter_WithPersistentQueue(t *testing.T) {
}, 500*time.Millisecond, 10*time.Millisecond)
}
func TestLogsExporter_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeLogsExporterName)
func TestLogs_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeLogsName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
le, err := NewLogsExporter(context.Background(), exporter.Settings{ID: fakeLogsExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeLogsExporterConfig, newPushLogsData(nil))
le, err := NewLogs(context.Background(), exporter.Settings{ID: fakeLogsName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeLogsConfig, newPushLogsData(nil))
require.NoError(t, err)
require.NotNil(t, le)
checkRecordedMetricsForLogsExporter(t, tt, le, nil)
checkRecordedMetricsForLogs(t, tt, le, nil)
}
func TestLogsExporter_pLogModifiedDownStream_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeLogsExporterName)
func TestLogs_pLogModifiedDownStream_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeLogsName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
le, err := NewLogsExporter(context.Background(), exporter.Settings{ID: fakeLogsExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeLogsExporterConfig, newPushLogsDataModifiedDownstream(nil), WithCapabilities(consumer.Capabilities{MutatesData: true}))
le, err := NewLogs(context.Background(), exporter.Settings{ID: fakeLogsName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeLogsConfig, newPushLogsDataModifiedDownstream(nil), WithCapabilities(consumer.Capabilities{MutatesData: true}))
assert.NotNil(t, le)
require.NoError(t, err)
ld := testdata.GenerateLogs(2)
@ -206,49 +206,49 @@ func TestLogsExporter_pLogModifiedDownStream_WithRecordMetrics(t *testing.T) {
require.NoError(t, tt.CheckExporterLogs(int64(2), 0))
}
func TestLogsRequestExporter_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeLogsExporterName)
func TestLogsRequest_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeLogsName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
le, err := NewLogsRequestExporter(context.Background(),
exporter.Settings{ID: fakeLogsExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()},
le, err := NewLogsRequest(context.Background(),
exporter.Settings{ID: fakeLogsName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()},
(&internal.FakeRequestConverter{}).RequestFromLogsFunc)
require.NoError(t, err)
require.NotNil(t, le)
checkRecordedMetricsForLogsExporter(t, tt, le, nil)
checkRecordedMetricsForLogs(t, tt, le, nil)
}
func TestLogsExporter_WithRecordMetrics_ReturnError(t *testing.T) {
func TestLogs_WithRecordMetrics_ReturnError(t *testing.T) {
want := errors.New("my_error")
tt, err := componenttest.SetupTelemetry(fakeLogsExporterName)
tt, err := componenttest.SetupTelemetry(fakeLogsName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
le, err := NewLogsExporter(context.Background(), exporter.Settings{ID: fakeLogsExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeLogsExporterConfig, newPushLogsData(want))
le, err := NewLogs(context.Background(), exporter.Settings{ID: fakeLogsName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeLogsConfig, newPushLogsData(want))
require.NoError(t, err)
require.NotNil(t, le)
checkRecordedMetricsForLogsExporter(t, tt, le, want)
checkRecordedMetricsForLogs(t, tt, le, want)
}
func TestLogsRequestExporter_WithRecordMetrics_ExportError(t *testing.T) {
func TestLogsRequest_WithRecordMetrics_ExportError(t *testing.T) {
want := errors.New("export_error")
tt, err := componenttest.SetupTelemetry(fakeLogsExporterName)
tt, err := componenttest.SetupTelemetry(fakeLogsName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
le, err := NewLogsRequestExporter(context.Background(), exporter.Settings{ID: fakeLogsExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()},
le, err := NewLogsRequest(context.Background(), exporter.Settings{ID: fakeLogsName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()},
(&internal.FakeRequestConverter{RequestError: want}).RequestFromLogsFunc)
require.NoError(t, err)
require.NotNil(t, le)
checkRecordedMetricsForLogsExporter(t, tt, le, want)
checkRecordedMetricsForLogs(t, tt, le, want)
}
func TestLogsExporter_WithRecordEnqueueFailedMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeLogsExporterName)
func TestLogs_WithRecordEnqueueFailedMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeLogsName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
@ -257,14 +257,14 @@ func TestLogsExporter_WithRecordEnqueueFailedMetrics(t *testing.T) {
qCfg.NumConsumers = 1
qCfg.QueueSize = 2
wantErr := errors.New("some-error")
te, err := NewLogsExporter(context.Background(), exporter.Settings{ID: fakeLogsExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeLogsExporterConfig, newPushLogsData(wantErr), WithRetry(rCfg), WithQueue(qCfg))
te, err := NewLogs(context.Background(), exporter.Settings{ID: fakeLogsName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeLogsConfig, newPushLogsData(wantErr), WithRetry(rCfg), WithQueue(qCfg))
require.NoError(t, err)
require.NotNil(t, te)
md := testdata.GenerateLogs(3)
const numBatches = 7
for i := 0; i < numBatches; i++ {
// errors are checked in the checkExporterEnqueueFailedLogsStats function below.
// errors are checked in the checkEnqueueFailedLogsStats function below.
_ = te.ConsumeLogs(context.Background(), md)
}
@ -272,33 +272,33 @@ func TestLogsExporter_WithRecordEnqueueFailedMetrics(t *testing.T) {
require.NoError(t, tt.CheckExporterEnqueueFailedLogs(int64(15)))
}
func TestLogsExporter_WithSpan(t *testing.T) {
func TestLogs_WithSpan(t *testing.T) {
set := exportertest.NewNopSettings()
sr := new(tracetest.SpanRecorder)
set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
otel.SetTracerProvider(set.TracerProvider)
defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
le, err := NewLogsExporter(context.Background(), set, &fakeLogsExporterConfig, newPushLogsData(nil))
le, err := NewLogs(context.Background(), set, &fakeLogsConfig, newPushLogsData(nil))
require.NoError(t, err)
require.NotNil(t, le)
checkWrapSpanForLogsExporter(t, sr, set.TracerProvider.Tracer("test"), le, nil, 1)
checkWrapSpanForLogs(t, sr, set.TracerProvider.Tracer("test"), le, nil, 1)
}
func TestLogsRequestExporter_WithSpan(t *testing.T) {
func TestLogsRequest_WithSpan(t *testing.T) {
set := exportertest.NewNopSettings()
sr := new(tracetest.SpanRecorder)
set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
otel.SetTracerProvider(set.TracerProvider)
defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
le, err := NewLogsRequestExporter(context.Background(), set, (&internal.FakeRequestConverter{}).RequestFromLogsFunc)
le, err := NewLogsRequest(context.Background(), set, (&internal.FakeRequestConverter{}).RequestFromLogsFunc)
require.NoError(t, err)
require.NotNil(t, le)
checkWrapSpanForLogsExporter(t, sr, set.TracerProvider.Tracer("test"), le, nil, 1)
checkWrapSpanForLogs(t, sr, set.TracerProvider.Tracer("test"), le, nil, 1)
}
func TestLogsExporter_WithSpan_ReturnError(t *testing.T) {
func TestLogs_WithSpan_ReturnError(t *testing.T) {
set := exportertest.NewNopSettings()
sr := new(tracetest.SpanRecorder)
set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
@ -306,13 +306,13 @@ func TestLogsExporter_WithSpan_ReturnError(t *testing.T) {
defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
want := errors.New("my_error")
le, err := NewLogsExporter(context.Background(), set, &fakeLogsExporterConfig, newPushLogsData(want))
le, err := NewLogs(context.Background(), set, &fakeLogsConfig, newPushLogsData(want))
require.NoError(t, err)
require.NotNil(t, le)
checkWrapSpanForLogsExporter(t, sr, set.TracerProvider.Tracer("test"), le, want, 1)
checkWrapSpanForLogs(t, sr, set.TracerProvider.Tracer("test"), le, want, 1)
}
func TestLogsRequestExporter_WithSpan_ReturnError(t *testing.T) {
func TestLogsRequest_WithSpan_ReturnError(t *testing.T) {
set := exportertest.NewNopSettings()
sr := new(tracetest.SpanRecorder)
set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
@ -320,17 +320,17 @@ func TestLogsRequestExporter_WithSpan_ReturnError(t *testing.T) {
defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
want := errors.New("my_error")
le, err := NewLogsRequestExporter(context.Background(), set, (&internal.FakeRequestConverter{RequestError: want}).RequestFromLogsFunc)
le, err := NewLogsRequest(context.Background(), set, (&internal.FakeRequestConverter{RequestError: want}).RequestFromLogsFunc)
require.NoError(t, err)
require.NotNil(t, le)
checkWrapSpanForLogsExporter(t, sr, set.TracerProvider.Tracer("test"), le, want, 1)
checkWrapSpanForLogs(t, sr, set.TracerProvider.Tracer("test"), le, want, 1)
}
func TestLogsExporter_WithShutdown(t *testing.T) {
func TestLogs_WithShutdown(t *testing.T) {
shutdownCalled := false
shutdown := func(context.Context) error { shutdownCalled = true; return nil }
le, err := NewLogsExporter(context.Background(), exportertest.NewNopSettings(), &fakeLogsExporterConfig, newPushLogsData(nil), WithShutdown(shutdown))
le, err := NewLogs(context.Background(), exportertest.NewNopSettings(), &fakeLogsConfig, newPushLogsData(nil), WithShutdown(shutdown))
assert.NotNil(t, le)
assert.NoError(t, err)
@ -338,11 +338,11 @@ func TestLogsExporter_WithShutdown(t *testing.T) {
assert.True(t, shutdownCalled)
}
func TestLogsRequestExporter_WithShutdown(t *testing.T) {
func TestLogsRequest_WithShutdown(t *testing.T) {
shutdownCalled := false
shutdown := func(context.Context) error { shutdownCalled = true; return nil }
le, err := NewLogsRequestExporter(context.Background(), exportertest.NewNopSettings(),
le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{}).RequestFromLogsFunc, WithShutdown(shutdown))
assert.NotNil(t, le)
assert.NoError(t, err)
@ -351,22 +351,22 @@ func TestLogsRequestExporter_WithShutdown(t *testing.T) {
assert.True(t, shutdownCalled)
}
func TestLogsExporter_WithShutdown_ReturnError(t *testing.T) {
func TestLogs_WithShutdown_ReturnError(t *testing.T) {
want := errors.New("my_error")
shutdownErr := func(context.Context) error { return want }
le, err := NewLogsExporter(context.Background(), exportertest.NewNopSettings(), &fakeLogsExporterConfig, newPushLogsData(nil), WithShutdown(shutdownErr))
le, err := NewLogs(context.Background(), exportertest.NewNopSettings(), &fakeLogsConfig, newPushLogsData(nil), WithShutdown(shutdownErr))
assert.NotNil(t, le)
require.NoError(t, err)
assert.Equal(t, want, le.Shutdown(context.Background()))
}
func TestLogsRequestExporter_WithShutdown_ReturnError(t *testing.T) {
func TestLogsRequest_WithShutdown_ReturnError(t *testing.T) {
want := errors.New("my_error")
shutdownErr := func(context.Context) error { return want }
le, err := NewLogsRequestExporter(context.Background(), exportertest.NewNopSettings(),
le, err := NewLogsRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{}).RequestFromLogsFunc, WithShutdown(shutdownErr))
assert.NotNil(t, le)
require.NoError(t, err)
@ -387,7 +387,7 @@ func newPushLogsData(retError error) consumer.ConsumeLogsFunc {
}
}
func checkRecordedMetricsForLogsExporter(t *testing.T, tt componenttest.TestTelemetry, le exporter.Logs, wantError error) {
func checkRecordedMetricsForLogs(t *testing.T, tt componenttest.TestTelemetry, le exporter.Logs, wantError error) {
ld := testdata.GenerateLogs(2)
const numBatches = 7
for i := 0; i < numBatches; i++ {
@ -411,7 +411,7 @@ func generateLogsTraffic(t *testing.T, tracer trace.Tracer, le exporter.Logs, nu
}
}
func checkWrapSpanForLogsExporter(t *testing.T, sr *tracetest.SpanRecorder, tracer trace.Tracer, le exporter.Logs,
func checkWrapSpanForLogs(t *testing.T, sr *tracetest.SpanRecorder, tracer trace.Tracer, le exporter.Logs,
wantError error, numLogRecords int64) { // nolint: unparam
const numRequests = 5
generateLogsTraffic(t, tracer, le, numRequests, wantError)

16
exporter/exporterhelper/metrics.go
View File

@ -70,8 +70,8 @@ type metricsExporter struct {
consumer.Metrics
}
// NewMetricsExporter creates an exporter.Metrics that records observability metrics and wraps every request with a Span.
func NewMetricsExporter(
// NewMetrics creates an exporter.Metrics that records observability metrics and wraps every request with a Span.
func NewMetrics(
ctx context.Context,
set exporter.Settings,
cfg component.Config,
@ -88,9 +88,12 @@ func NewMetricsExporter(
internal.WithMarshaler(metricsRequestMarshaler), internal.WithUnmarshaler(newMetricsRequestUnmarshalerFunc(pusher)),
internal.WithBatchFuncs(mergeMetrics, mergeSplitMetrics),
}
return NewMetricsRequestExporter(ctx, set, requestFromMetrics(pusher), append(metricsOpts, options...)...)
return NewMetricsRequest(ctx, set, requestFromMetrics(pusher), append(metricsOpts, options...)...)
}
// Deprecated: [v0.112.0] use NewMetrics.
var NewMetricsExporter = NewMetrics
// RequestFromMetricsFunc converts pdata.Metrics into a user-defined request.
// Experimental: This API is at the early stage of development and may change without backward compatibility
// until https://github.com/open-telemetry/opentelemetry-collector/issues/8122 is resolved.
@ -103,10 +106,10 @@ func requestFromMetrics(pusher consumer.ConsumeMetricsFunc) RequestFromMetricsFu
}
}
// NewMetricsRequestExporter creates a new metrics exporter based on a custom MetricsConverter and RequestSender.
// NewMetricsRequest creates a new metrics exporter based on a custom MetricsConverter and RequestSender.
// Experimental: This API is at the early stage of development and may change without backward compatibility
// until https://github.com/open-telemetry/opentelemetry-collector/issues/8122 is resolved.
func NewMetricsRequestExporter(
func NewMetricsRequest(
_ context.Context,
set exporter.Settings,
converter RequestFromMetricsFunc,
@ -146,6 +149,9 @@ func NewMetricsRequestExporter(
}, err
}
// Deprecated: [v0.112.0] use NewMetricsRequest.
var NewMetricsRequestExporter = NewMetricsRequest
type metricsSenderWithObservability struct {
internal.BaseRequestSender
obsrep *internal.ObsReport

148
exporter/exporterhelper/metrics_test.go
View File

@ -37,8 +37,8 @@ const (
)
var (
fakeMetricsExporterName = component.MustNewIDWithName("fake_metrics_exporter", "with_name")
fakeMetricsExporterConfig = struct{}{}
fakeMetricsName = component.MustNewIDWithName("fake_metrics_exporter", "with_name")
fakeMetricsConfig = struct{}{}
)
func TestMetricsRequest(t *testing.T) {
@ -52,40 +52,40 @@ func TestMetricsRequest(t *testing.T) {
)
}
func TestMetricsExporter_NilConfig(t *testing.T) {
me, err := NewMetricsExporter(context.Background(), exportertest.NewNopSettings(), nil, newPushMetricsData(nil))
func TestMetrics_NilConfig(t *testing.T) {
me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(), nil, newPushMetricsData(nil))
require.Nil(t, me)
require.Equal(t, errNilConfig, err)
}
func TestMetricsExporter_NilLogger(t *testing.T) {
me, err := NewMetricsExporter(context.Background(), exporter.Settings{}, &fakeMetricsExporterConfig, newPushMetricsData(nil))
func TestMetrics_NilLogger(t *testing.T) {
me, err := NewMetrics(context.Background(), exporter.Settings{}, &fakeMetricsConfig, newPushMetricsData(nil))
require.Nil(t, me)
require.Equal(t, errNilLogger, err)
}
func TestMetricsRequestExporter_NilLogger(t *testing.T) {
me, err := NewMetricsRequestExporter(context.Background(), exporter.Settings{},
func TestMetricsRequest_NilLogger(t *testing.T) {
me, err := NewMetricsRequest(context.Background(), exporter.Settings{},
(&internal.FakeRequestConverter{}).RequestFromMetricsFunc)
require.Nil(t, me)
require.Equal(t, errNilLogger, err)
}
func TestMetricsExporter_NilPushMetricsData(t *testing.T) {
me, err := NewMetricsExporter(context.Background(), exportertest.NewNopSettings(), &fakeMetricsExporterConfig, nil)
func TestMetrics_NilPushMetricsData(t *testing.T) {
me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(), &fakeMetricsConfig, nil)
require.Nil(t, me)
require.Equal(t, errNilPushMetricsData, err)
}
func TestMetricsRequestExporter_NilMetricsConverter(t *testing.T) {
me, err := NewMetricsRequestExporter(context.Background(), exportertest.NewNopSettings(), nil)
func TestMetricsRequest_NilMetricsConverter(t *testing.T) {
me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(), nil)
require.Nil(t, me)
require.Equal(t, errNilMetricsConverter, err)
}
func TestMetricsExporter_Default(t *testing.T) {
func TestMetrics_Default(t *testing.T) {
md := pmetric.NewMetrics()
me, err := NewMetricsExporter(context.Background(), exportertest.NewNopSettings(), &fakeMetricsExporterConfig, newPushMetricsData(nil))
me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(), &fakeMetricsConfig, newPushMetricsData(nil))
require.NoError(t, err)
assert.NotNil(t, me)
@ -95,9 +95,9 @@ func TestMetricsExporter_Default(t *testing.T) {
assert.NoError(t, me.Shutdown(context.Background()))
}
func TestMetricsRequestExporter_Default(t *testing.T) {
func TestMetricsRequest_Default(t *testing.T) {
md := pmetric.NewMetrics()
me, err := NewMetricsRequestExporter(context.Background(), exportertest.NewNopSettings(),
me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{}).RequestFromMetricsFunc)
require.NoError(t, err)
assert.NotNil(t, me)
@ -108,18 +108,18 @@ func TestMetricsRequestExporter_Default(t *testing.T) {
assert.NoError(t, me.Shutdown(context.Background()))
}
func TestMetricsExporter_WithCapabilities(t *testing.T) {
func TestMetrics_WithCapabilities(t *testing.T) {
capabilities := consumer.Capabilities{MutatesData: true}
me, err := NewMetricsExporter(context.Background(), exportertest.NewNopSettings(), &fakeMetricsExporterConfig, newPushMetricsData(nil), WithCapabilities(capabilities))
me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(), &fakeMetricsConfig, newPushMetricsData(nil), WithCapabilities(capabilities))
require.NoError(t, err)
assert.NotNil(t, me)
assert.Equal(t, capabilities, me.Capabilities())
}
func TestMetricsRequestExporter_WithCapabilities(t *testing.T) {
func TestMetricsRequest_WithCapabilities(t *testing.T) {
capabilities := consumer.Capabilities{MutatesData: true}
me, err := NewMetricsRequestExporter(context.Background(), exportertest.NewNopSettings(),
me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{}).RequestFromMetricsFunc, WithCapabilities(capabilities))
require.NoError(t, err)
assert.NotNil(t, me)
@ -127,36 +127,36 @@ func TestMetricsRequestExporter_WithCapabilities(t *testing.T) {
assert.Equal(t, capabilities, me.Capabilities())
}
func TestMetricsExporter_Default_ReturnError(t *testing.T) {
func TestMetrics_Default_ReturnError(t *testing.T) {
md := pmetric.NewMetrics()
want := errors.New("my_error")
me, err := NewMetricsExporter(context.Background(), exportertest.NewNopSettings(), &fakeMetricsExporterConfig, newPushMetricsData(want))
me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(), &fakeMetricsConfig, newPushMetricsData(want))
require.NoError(t, err)
require.NotNil(t, me)
require.Equal(t, want, me.ConsumeMetrics(context.Background(), md))
}
func TestMetricsRequestExporter_Default_ConvertError(t *testing.T) {
func TestMetricsRequest_Default_ConvertError(t *testing.T) {
md := pmetric.NewMetrics()
want := errors.New("convert_error")
me, err := NewMetricsRequestExporter(context.Background(), exportertest.NewNopSettings(),
me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{MetricsError: want}).RequestFromMetricsFunc)
require.NoError(t, err)
require.NotNil(t, me)
require.Equal(t, consumererror.NewPermanent(want), me.ConsumeMetrics(context.Background(), md))
}
func TestMetricsRequestExporter_Default_ExportError(t *testing.T) {
func TestMetricsRequest_Default_ExportError(t *testing.T) {
md := pmetric.NewMetrics()
want := errors.New("export_error")
me, err := NewMetricsRequestExporter(context.Background(), exportertest.NewNopSettings(),
me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{RequestError: want}).RequestFromMetricsFunc)
require.NoError(t, err)
require.NotNil(t, me)
require.Equal(t, want, me.ConsumeMetrics(context.Background(), md))
}
func TestMetricsExporter_WithPersistentQueue(t *testing.T) {
func TestMetrics_WithPersistentQueue(t *testing.T) {
qCfg := NewDefaultQueueConfig()
storageID := component.MustNewIDWithName("file_storage", "storage")
qCfg.StorageID = &storageID
@ -164,7 +164,7 @@ func TestMetricsExporter_WithPersistentQueue(t *testing.T) {
ms := consumertest.MetricsSink{}
set := exportertest.NewNopSettings()
set.ID = component.MustNewIDWithName("test_metrics", "with_persistent_queue")
te, err := NewMetricsExporter(context.Background(), set, &fakeTracesExporterConfig, ms.ConsumeMetrics, WithRetry(rCfg), WithQueue(qCfg))
te, err := NewMetrics(context.Background(), set, &fakeMetricsConfig, ms.ConsumeMetrics, WithRetry(rCfg), WithQueue(qCfg))
require.NoError(t, err)
host := &internal.MockHost{Ext: map[component.ID]component.Component{
@ -180,24 +180,24 @@ func TestMetricsExporter_WithPersistentQueue(t *testing.T) {
}, 500*time.Millisecond, 10*time.Millisecond)
}
func TestMetricsExporter_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeMetricsExporterName)
func TestMetrics_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeMetricsName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
me, err := NewMetricsExporter(context.Background(), exporter.Settings{ID: fakeMetricsExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeMetricsExporterConfig, newPushMetricsData(nil))
me, err := NewMetrics(context.Background(), exporter.Settings{ID: fakeMetricsName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeMetricsConfig, newPushMetricsData(nil))
require.NoError(t, err)
require.NotNil(t, me)
checkRecordedMetricsForMetricsExporter(t, tt, me, nil)
checkRecordedMetricsForMetrics(t, tt, me, nil)
}
func TestMetricsExporter_pMetricModifiedDownStream_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeMetricsExporterName)
func TestMetrics_pMetricModifiedDownStream_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeMetricsName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
me, err := NewMetricsExporter(context.Background(), exporter.Settings{ID: fakeMetricsExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeMetricsExporterConfig, newPushMetricsDataModifiedDownstream(nil), WithCapabilities(consumer.Capabilities{MutatesData: true}))
me, err := NewMetrics(context.Background(), exporter.Settings{ID: fakeMetricsName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeMetricsConfig, newPushMetricsDataModifiedDownstream(nil), WithCapabilities(consumer.Capabilities{MutatesData: true}))
require.NoError(t, err)
require.NotNil(t, me)
md := testdata.GenerateMetrics(2)
@ -207,50 +207,50 @@ func TestMetricsExporter_pMetricModifiedDownStream_WithRecordMetrics(t *testing.
require.NoError(t, tt.CheckExporterMetrics(int64(4), 0))
}
func TestMetricsRequestExporter_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeMetricsExporterName)
func TestMetricsRequest_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeMetricsName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
me, err := NewMetricsRequestExporter(context.Background(),
exporter.Settings{ID: fakeMetricsExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()},
me, err := NewMetricsRequest(context.Background(),
exporter.Settings{ID: fakeMetricsName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()},
(&internal.FakeRequestConverter{}).RequestFromMetricsFunc)
require.NoError(t, err)
require.NotNil(t, me)
checkRecordedMetricsForMetricsExporter(t, tt, me, nil)
checkRecordedMetricsForMetrics(t, tt, me, nil)
}
func TestMetricsExporter_WithRecordMetrics_ReturnError(t *testing.T) {
func TestMetrics_WithRecordMetrics_ReturnError(t *testing.T) {
want := errors.New("my_error")
tt, err := componenttest.SetupTelemetry(fakeMetricsExporterName)
tt, err := componenttest.SetupTelemetry(fakeMetricsName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
me, err := NewMetricsExporter(context.Background(), exporter.Settings{ID: fakeMetricsExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeMetricsExporterConfig, newPushMetricsData(want))
me, err := NewMetrics(context.Background(), exporter.Settings{ID: fakeMetricsName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeMetricsConfig, newPushMetricsData(want))
require.NoError(t, err)
require.NotNil(t, me)
checkRecordedMetricsForMetricsExporter(t, tt, me, want)
checkRecordedMetricsForMetrics(t, tt, me, want)
}
func TestMetricsRequestExporter_WithRecordMetrics_ExportError(t *testing.T) {
func TestMetricsRequest_WithRecordMetrics_ExportError(t *testing.T) {
want := errors.New("my_error")
tt, err := componenttest.SetupTelemetry(fakeMetricsExporterName)
tt, err := componenttest.SetupTelemetry(fakeMetricsName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
me, err := NewMetricsRequestExporter(context.Background(),
exporter.Settings{ID: fakeMetricsExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()},
me, err := NewMetricsRequest(context.Background(),
exporter.Settings{ID: fakeMetricsName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()},
(&internal.FakeRequestConverter{RequestError: want}).RequestFromMetricsFunc)
require.NoError(t, err)
require.NotNil(t, me)
checkRecordedMetricsForMetricsExporter(t, tt, me, want)
checkRecordedMetricsForMetrics(t, tt, me, want)
}
func TestMetricsExporter_WithRecordEnqueueFailedMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeMetricsExporterName)
func TestMetrics_WithRecordEnqueueFailedMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeMetricsName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
@ -259,7 +259,7 @@ func TestMetricsExporter_WithRecordEnqueueFailedMetrics(t *testing.T) {
qCfg.NumConsumers = 1
qCfg.QueueSize = 2
wantErr := errors.New("some-error")
te, err := NewMetricsExporter(context.Background(), exporter.Settings{ID: fakeMetricsExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeMetricsExporterConfig, newPushMetricsData(wantErr), WithRetry(rCfg), WithQueue(qCfg))
te, err := NewMetrics(context.Background(), exporter.Settings{ID: fakeMetricsName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeMetricsConfig, newPushMetricsData(wantErr), WithRetry(rCfg), WithQueue(qCfg))
require.NoError(t, err)
require.NotNil(t, te)
@ -274,33 +274,33 @@ func TestMetricsExporter_WithRecordEnqueueFailedMetrics(t *testing.T) {
require.NoError(t, tt.CheckExporterEnqueueFailedMetrics(int64(10)))
}
func TestMetricsExporter_WithSpan(t *testing.T) {
func TestMetrics_WithSpan(t *testing.T) {
set := exportertest.NewNopSettings()
sr := new(tracetest.SpanRecorder)
set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
otel.SetTracerProvider(set.TracerProvider)
defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
me, err := NewMetricsExporter(context.Background(), set, &fakeMetricsExporterConfig, newPushMetricsData(nil))
me, err := NewMetrics(context.Background(), set, &fakeMetricsConfig, newPushMetricsData(nil))
require.NoError(t, err)
require.NotNil(t, me)
checkWrapSpanForMetricsExporter(t, sr, set.TracerProvider.Tracer("test"), me, nil, 2)
checkWrapSpanForMetrics(t, sr, set.TracerProvider.Tracer("test"), me, nil, 2)
}
func TestMetricsRequestExporter_WithSpan(t *testing.T) {
func TestMetricsRequest_WithSpan(t *testing.T) {
set := exportertest.NewNopSettings()
sr := new(tracetest.SpanRecorder)
set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
otel.SetTracerProvider(set.TracerProvider)
defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
me, err := NewMetricsRequestExporter(context.Background(), set, (&internal.FakeRequestConverter{}).RequestFromMetricsFunc)
me, err := NewMetricsRequest(context.Background(), set, (&internal.FakeRequestConverter{}).RequestFromMetricsFunc)
require.NoError(t, err)
require.NotNil(t, me)
checkWrapSpanForMetricsExporter(t, sr, set.TracerProvider.Tracer("test"), me, nil, 2)
checkWrapSpanForMetrics(t, sr, set.TracerProvider.Tracer("test"), me, nil, 2)
}
func TestMetricsExporter_WithSpan_ReturnError(t *testing.T) {
func TestMetrics_WithSpan_ReturnError(t *testing.T) {
set := exportertest.NewNopSettings()
sr := new(tracetest.SpanRecorder)
set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
@ -308,13 +308,13 @@ func TestMetricsExporter_WithSpan_ReturnError(t *testing.T) {
defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
want := errors.New("my_error")
me, err := NewMetricsExporter(context.Background(), set, &fakeMetricsExporterConfig, newPushMetricsData(want))
me, err := NewMetrics(context.Background(), set, &fakeMetricsConfig, newPushMetricsData(want))
require.NoError(t, err)
require.NotNil(t, me)
checkWrapSpanForMetricsExporter(t, sr, set.TracerProvider.Tracer("test"), me, want, 2)
checkWrapSpanForMetrics(t, sr, set.TracerProvider.Tracer("test"), me, want, 2)
}
func TestMetricsRequestExporter_WithSpan_ExportError(t *testing.T) {
func TestMetricsRequest_WithSpan_ExportError(t *testing.T) {
set := exportertest.NewNopSettings()
sr := new(tracetest.SpanRecorder)
set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
@ -322,17 +322,17 @@ func TestMetricsRequestExporter_WithSpan_ExportError(t *testing.T) {
defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
want := errors.New("my_error")
me, err := NewMetricsRequestExporter(context.Background(), set, (&internal.FakeRequestConverter{RequestError: want}).RequestFromMetricsFunc)
me, err := NewMetricsRequest(context.Background(), set, (&internal.FakeRequestConverter{RequestError: want}).RequestFromMetricsFunc)
require.NoError(t, err)
require.NotNil(t, me)
checkWrapSpanForMetricsExporter(t, sr, set.TracerProvider.Tracer("test"), me, want, 2)
checkWrapSpanForMetrics(t, sr, set.TracerProvider.Tracer("test"), me, want, 2)
}
func TestMetricsExporter_WithShutdown(t *testing.T) {
func TestMetrics_WithShutdown(t *testing.T) {
shutdownCalled := false
shutdown := func(context.Context) error { shutdownCalled = true; return nil }
me, err := NewMetricsExporter(context.Background(), exportertest.NewNopSettings(), &fakeMetricsExporterConfig, newPushMetricsData(nil), WithShutdown(shutdown))
me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(), &fakeMetricsConfig, newPushMetricsData(nil), WithShutdown(shutdown))
assert.NotNil(t, me)
assert.NoError(t, err)
@ -341,11 +341,11 @@ func TestMetricsExporter_WithShutdown(t *testing.T) {
assert.True(t, shutdownCalled)
}
func TestMetricsRequestExporter_WithShutdown(t *testing.T) {
func TestMetricsRequest_WithShutdown(t *testing.T) {
shutdownCalled := false
shutdown := func(context.Context) error { shutdownCalled = true; return nil }
me, err := NewMetricsRequestExporter(context.Background(), exportertest.NewNopSettings(),
me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{}).RequestFromMetricsFunc, WithShutdown(shutdown))
assert.NotNil(t, me)
assert.NoError(t, err)
@ -355,11 +355,11 @@ func TestMetricsRequestExporter_WithShutdown(t *testing.T) {
assert.True(t, shutdownCalled)
}
func TestMetricsExporter_WithShutdown_ReturnError(t *testing.T) {
func TestMetrics_WithShutdown_ReturnError(t *testing.T) {
want := errors.New("my_error")
shutdownErr := func(context.Context) error { return want }
me, err := NewMetricsExporter(context.Background(), exportertest.NewNopSettings(), &fakeMetricsExporterConfig, newPushMetricsData(nil), WithShutdown(shutdownErr))
me, err := NewMetrics(context.Background(), exportertest.NewNopSettings(), &fakeMetricsConfig, newPushMetricsData(nil), WithShutdown(shutdownErr))
assert.NotNil(t, me)
assert.NoError(t, err)
@ -367,11 +367,11 @@ func TestMetricsExporter_WithShutdown_ReturnError(t *testing.T) {
assert.Equal(t, want, me.Shutdown(context.Background()))
}
func TestMetricsRequestExporter_WithShutdown_ReturnError(t *testing.T) {
func TestMetricsRequest_WithShutdown_ReturnError(t *testing.T) {
want := errors.New("my_error")
shutdownErr := func(context.Context) error { return want }
me, err := NewMetricsRequestExporter(context.Background(), exportertest.NewNopSettings(),
me, err := NewMetricsRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{}).RequestFromMetricsFunc, WithShutdown(shutdownErr))
assert.NotNil(t, me)
assert.NoError(t, err)
@ -392,7 +392,7 @@ func newPushMetricsDataModifiedDownstream(retError error) consumer.ConsumeMetric
}
}
func checkRecordedMetricsForMetricsExporter(t *testing.T, tt componenttest.TestTelemetry, me exporter.Metrics, wantError error) {
func checkRecordedMetricsForMetrics(t *testing.T, tt componenttest.TestTelemetry, me exporter.Metrics, wantError error) {
md := testdata.GenerateMetrics(2)
const numBatches = 7
for i := 0; i < numBatches; i++ {
@ -417,7 +417,7 @@ func generateMetricsTraffic(t *testing.T, tracer trace.Tracer, me exporter.Metri
}
}
func checkWrapSpanForMetricsExporter(t *testing.T, sr *tracetest.SpanRecorder, tracer trace.Tracer,
func checkWrapSpanForMetrics(t *testing.T, sr *tracetest.SpanRecorder, tracer trace.Tracer,
me exporter.Metrics, wantError error, numMetricPoints int64) { // nolint: unparam
const numRequests = 5
generateMetricsTraffic(t, tracer, me, numRequests, wantError)

30
exporter/exporterhelper/traces.go
View File

@ -65,13 +65,13 @@ func (req *tracesRequest) ItemsCount() int {
return req.td.SpanCount()
}
type traceExporter struct {
type tracesExporter struct {
*internal.BaseExporter
consumer.Traces
}
// NewTracesExporter creates an exporter.Traces that records observability metrics and wraps every request with a Span.
func NewTracesExporter(
// NewTraces creates an exporter.Traces that records observability metrics and wraps every request with a Span.
func NewTraces(
ctx context.Context,
set exporter.Settings,
cfg component.Config,
@ -88,9 +88,12 @@ func NewTracesExporter(
internal.WithMarshaler(tracesRequestMarshaler), internal.WithUnmarshaler(newTraceRequestUnmarshalerFunc(pusher)),
internal.WithBatchFuncs(mergeTraces, mergeSplitTraces),
}
return NewTracesRequestExporter(ctx, set, requestFromTraces(pusher), append(tracesOpts, options...)...)
return NewTracesRequest(ctx, set, requestFromTraces(pusher), append(tracesOpts, options...)...)
}
// Deprecated: [v0.112.0] use NewTraces.
var NewTracesExporter = NewTraces
// RequestFromTracesFunc converts ptrace.Traces into a user-defined Request.
// Experimental: This API is at the early stage of development and may change without backward compatibility
// until https://github.com/open-telemetry/opentelemetry-collector/issues/8122 is resolved.
@ -103,10 +106,10 @@ func requestFromTraces(pusher consumer.ConsumeTracesFunc) RequestFromTracesFunc
}
}
// NewTracesRequestExporter creates a new traces exporter based on a custom TracesConverter and RequestSender.
// NewTracesRequest creates a new traces exporter based on a custom TracesConverter and RequestSender.
// Experimental: This API is at the early stage of development and may change without backward compatibility
// until https://github.com/open-telemetry/opentelemetry-collector/issues/8122 is resolved.
func NewTracesRequestExporter(
func NewTracesRequest(
_ context.Context,
set exporter.Settings,
converter RequestFromTracesFunc,
@ -120,7 +123,7 @@ func NewTracesRequestExporter(
return nil, errNilTracesConverter
}
be, err := internal.NewBaseExporter(set, pipeline.SignalTraces, newTracesExporterWithObservability, options...)
be, err := internal.NewBaseExporter(set, pipeline.SignalTraces, newTracesWithObservability, options...)
if err != nil {
return nil, err
}
@ -140,22 +143,25 @@ func NewTracesRequestExporter(
return sErr
}, be.ConsumerOptions...)
return &traceExporter{
return &tracesExporter{
BaseExporter: be,
Traces: tc,
}, err
}
type tracesExporterWithObservability struct {
// Deprecated: [v0.112.0] use NewTracesRequest.
var NewTracesRequestExporter = NewTracesRequest
type tracesWithObservability struct {
internal.BaseRequestSender
obsrep *internal.ObsReport
}
func newTracesExporterWithObservability(obsrep *internal.ObsReport) internal.RequestSender {
return &tracesExporterWithObservability{obsrep: obsrep}
func newTracesWithObservability(obsrep *internal.ObsReport) internal.RequestSender {
return &tracesWithObservability{obsrep: obsrep}
}
func (tewo *tracesExporterWithObservability) Send(ctx context.Context, req Request) error {
func (tewo *tracesWithObservability) Send(ctx context.Context, req Request) error {
c := tewo.obsrep.StartTracesOp(ctx)
numTraceSpans := req.ItemsCount()
// Forward the data to the next consumer (this pusher is the next).

150
exporter/exporterhelper/traces_test.go
View File

@ -37,8 +37,8 @@ const (
)
var (
fakeTracesExporterName = component.MustNewIDWithName("fake_traces_exporter", "with_name")
fakeTracesExporterConfig = struct{}{}
fakeTracesName = component.MustNewIDWithName("fake_traces_exporter", "with_name")
fakeTracesConfig = struct{}{}
)
func TestTracesRequest(t *testing.T) {
@ -48,39 +48,39 @@ func TestTracesRequest(t *testing.T) {
assert.EqualValues(t, newTracesRequest(ptrace.NewTraces(), nil), mr.(RequestErrorHandler).OnError(traceErr))
}
func TestTracesExporter_InvalidName(t *testing.T) {
te, err := NewTracesExporter(context.Background(), exportertest.NewNopSettings(), nil, newTraceDataPusher(nil))
func TestTraces_InvalidName(t *testing.T) {
te, err := NewTraces(context.Background(), exportertest.NewNopSettings(), nil, newTraceDataPusher(nil))
require.Nil(t, te)
require.Equal(t, errNilConfig, err)
}
func TestTracesExporter_NilLogger(t *testing.T) {
te, err := NewTracesExporter(context.Background(), exporter.Settings{}, &fakeTracesExporterConfig, newTraceDataPusher(nil))
func TestTraces_NilLogger(t *testing.T) {
te, err := NewTraces(context.Background(), exporter.Settings{}, &fakeTracesConfig, newTraceDataPusher(nil))
require.Nil(t, te)
require.Equal(t, errNilLogger, err)
}
func TestTracesRequestExporter_NilLogger(t *testing.T) {
te, err := NewTracesRequestExporter(context.Background(), exporter.Settings{}, (&internal.FakeRequestConverter{}).RequestFromTracesFunc)
func TestTracesRequest_NilLogger(t *testing.T) {
te, err := NewTracesRequest(context.Background(), exporter.Settings{}, (&internal.FakeRequestConverter{}).RequestFromTracesFunc)
require.Nil(t, te)
require.Equal(t, errNilLogger, err)
}
func TestTracesExporter_NilPushTraceData(t *testing.T) {
te, err := NewTracesExporter(context.Background(), exportertest.NewNopSettings(), &fakeTracesExporterConfig, nil)
func TestTraces_NilPushTraceData(t *testing.T) {
te, err := NewTraces(context.Background(), exportertest.NewNopSettings(), &fakeTracesConfig, nil)
require.Nil(t, te)
require.Equal(t, errNilPushTraceData, err)
}
func TestTracesRequestExporter_NilTracesConverter(t *testing.T) {
te, err := NewTracesRequestExporter(context.Background(), exportertest.NewNopSettings(), nil)
func TestTracesRequest_NilTracesConverter(t *testing.T) {
te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(), nil)
require.Nil(t, te)
require.Equal(t, errNilTracesConverter, err)
}
func TestTracesExporter_Default(t *testing.T) {
func TestTraces_Default(t *testing.T) {
td := ptrace.NewTraces()
te, err := NewTracesExporter(context.Background(), exportertest.NewNopSettings(), &fakeTracesExporterConfig, newTraceDataPusher(nil))
te, err := NewTraces(context.Background(), exportertest.NewNopSettings(), &fakeTracesConfig, newTraceDataPusher(nil))
assert.NotNil(t, te)
require.NoError(t, err)
@ -90,9 +90,9 @@ func TestTracesExporter_Default(t *testing.T) {
assert.NoError(t, te.Shutdown(context.Background()))
}
func TestTracesRequestExporter_Default(t *testing.T) {
func TestTracesRequest_Default(t *testing.T) {
td := ptrace.NewTraces()
te, err := NewTracesRequestExporter(context.Background(), exportertest.NewNopSettings(),
te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{}).RequestFromTracesFunc)
assert.NotNil(t, te)
require.NoError(t, err)
@ -103,18 +103,18 @@ func TestTracesRequestExporter_Default(t *testing.T) {
assert.NoError(t, te.Shutdown(context.Background()))
}
func TestTracesExporter_WithCapabilities(t *testing.T) {
func TestTraces_WithCapabilities(t *testing.T) {
capabilities := consumer.Capabilities{MutatesData: true}
te, err := NewTracesExporter(context.Background(), exportertest.NewNopSettings(), &fakeTracesExporterConfig, newTraceDataPusher(nil), WithCapabilities(capabilities))
te, err := NewTraces(context.Background(), exportertest.NewNopSettings(), &fakeTracesConfig, newTraceDataPusher(nil), WithCapabilities(capabilities))
assert.NotNil(t, te)
require.NoError(t, err)
assert.Equal(t, capabilities, te.Capabilities())
}
func TestTracesRequestExporter_WithCapabilities(t *testing.T) {
func TestTracesRequest_WithCapabilities(t *testing.T) {
capabilities := consumer.Capabilities{MutatesData: true}
te, err := NewTracesRequestExporter(context.Background(), exportertest.NewNopSettings(),
te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{}).RequestFromTracesFunc, WithCapabilities(capabilities))
assert.NotNil(t, te)
require.NoError(t, err)
@ -122,10 +122,10 @@ func TestTracesRequestExporter_WithCapabilities(t *testing.T) {
assert.Equal(t, capabilities, te.Capabilities())
}
func TestTracesExporter_Default_ReturnError(t *testing.T) {
func TestTraces_Default_ReturnError(t *testing.T) {
td := ptrace.NewTraces()
want := errors.New("my_error")
te, err := NewTracesExporter(context.Background(), exportertest.NewNopSettings(), &fakeTracesExporterConfig, newTraceDataPusher(want))
te, err := NewTraces(context.Background(), exportertest.NewNopSettings(), &fakeTracesConfig, newTraceDataPusher(want))
require.NoError(t, err)
require.NotNil(t, te)
@ -133,27 +133,27 @@ func TestTracesExporter_Default_ReturnError(t *testing.T) {
require.Equal(t, want, err)
}
func TestTracesRequestExporter_Default_ConvertError(t *testing.T) {
func TestTracesRequest_Default_ConvertError(t *testing.T) {
td := ptrace.NewTraces()
want := errors.New("convert_error")
te, err := NewTracesRequestExporter(context.Background(), exportertest.NewNopSettings(),
te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{TracesError: want}).RequestFromTracesFunc)
require.NoError(t, err)
require.NotNil(t, te)
require.Equal(t, consumererror.NewPermanent(want), te.ConsumeTraces(context.Background(), td))
}
func TestTracesRequestExporter_Default_ExportError(t *testing.T) {
func TestTracesRequest_Default_ExportError(t *testing.T) {
td := ptrace.NewTraces()
want := errors.New("export_error")
te, err := NewTracesRequestExporter(context.Background(), exportertest.NewNopSettings(),
te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{RequestError: want}).RequestFromTracesFunc)
require.NoError(t, err)
require.NotNil(t, te)
require.Equal(t, want, te.ConsumeTraces(context.Background(), td))
}
func TestTracesExporter_WithPersistentQueue(t *testing.T) {
func TestTraces_WithPersistentQueue(t *testing.T) {
qCfg := NewDefaultQueueConfig()
storageID := component.MustNewIDWithName("file_storage", "storage")
qCfg.StorageID = &storageID
@ -161,7 +161,7 @@ func TestTracesExporter_WithPersistentQueue(t *testing.T) {
ts := consumertest.TracesSink{}
set := exportertest.NewNopSettings()
set.ID = component.MustNewIDWithName("test_traces", "with_persistent_queue")
te, err := NewTracesExporter(context.Background(), set, &fakeTracesExporterConfig, ts.ConsumeTraces, WithRetry(rCfg), WithQueue(qCfg))
te, err := NewTraces(context.Background(), set, &fakeTracesConfig, ts.ConsumeTraces, WithRetry(rCfg), WithQueue(qCfg))
require.NoError(t, err)
host := &internal.MockHost{Ext: map[component.ID]component.Component{
@ -177,24 +177,24 @@ func TestTracesExporter_WithPersistentQueue(t *testing.T) {
}, 500*time.Millisecond, 10*time.Millisecond)
}
func TestTracesExporter_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeTracesExporterName)
func TestTraces_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeTracesName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
te, err := NewTracesExporter(context.Background(), exporter.Settings{ID: fakeTracesExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeTracesExporterConfig, newTraceDataPusher(nil))
te, err := NewTraces(context.Background(), exporter.Settings{ID: fakeTracesName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeTracesConfig, newTraceDataPusher(nil))
require.NoError(t, err)
require.NotNil(t, te)
checkRecordedMetricsForTracesExporter(t, tt, te, nil)
checkRecordedMetricsForTraces(t, tt, te, nil)
}
func TestTracesExporter_pLogModifiedDownStream_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeTracesExporterName)
func TestTraces_pLogModifiedDownStream_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeTracesName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
te, err := NewTracesExporter(context.Background(), exporter.Settings{ID: fakeTracesExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeTracesExporterConfig, newTraceDataPusherModifiedDownstream(nil), WithCapabilities(consumer.Capabilities{MutatesData: true}))
te, err := NewTraces(context.Background(), exporter.Settings{ID: fakeTracesName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeTracesConfig, newTraceDataPusherModifiedDownstream(nil), WithCapabilities(consumer.Capabilities{MutatesData: true}))
assert.NotNil(t, te)
require.NoError(t, err)
td := testdata.GenerateTraces(2)
@ -204,50 +204,50 @@ func TestTracesExporter_pLogModifiedDownStream_WithRecordMetrics(t *testing.T) {
require.NoError(t, tt.CheckExporterTraces(int64(2), 0))
}
func TestTracesRequestExporter_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeTracesExporterName)
func TestTracesRequest_WithRecordMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeTracesName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
te, err := NewTracesRequestExporter(context.Background(),
exporter.Settings{ID: fakeTracesExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()},
te, err := NewTracesRequest(context.Background(),
exporter.Settings{ID: fakeTracesName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()},
(&internal.FakeRequestConverter{}).RequestFromTracesFunc)
require.NoError(t, err)
require.NotNil(t, te)
checkRecordedMetricsForTracesExporter(t, tt, te, nil)
checkRecordedMetricsForTraces(t, tt, te, nil)
}
func TestTracesExporter_WithRecordMetrics_ReturnError(t *testing.T) {
func TestTraces_WithRecordMetrics_ReturnError(t *testing.T) {
want := errors.New("my_error")
tt, err := componenttest.SetupTelemetry(fakeTracesExporterName)
tt, err := componenttest.SetupTelemetry(fakeTracesName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
te, err := NewTracesExporter(context.Background(), exporter.Settings{ID: fakeTracesExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeTracesExporterConfig, newTraceDataPusher(want))
te, err := NewTraces(context.Background(), exporter.Settings{ID: fakeTracesName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeTracesConfig, newTraceDataPusher(want))
require.NoError(t, err)
require.NotNil(t, te)
checkRecordedMetricsForTracesExporter(t, tt, te, want)
checkRecordedMetricsForTraces(t, tt, te, want)
}
func TestTracesRequestExporter_WithRecordMetrics_RequestSenderError(t *testing.T) {
func TestTracesRequest_WithRecordMetrics_RequestSenderError(t *testing.T) {
want := errors.New("export_error")
tt, err := componenttest.SetupTelemetry(fakeTracesExporterName)
tt, err := componenttest.SetupTelemetry(fakeTracesName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
te, err := NewTracesRequestExporter(context.Background(),
exporter.Settings{ID: fakeTracesExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()},
te, err := NewTracesRequest(context.Background(),
exporter.Settings{ID: fakeTracesName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()},
(&internal.FakeRequestConverter{RequestError: want}).RequestFromTracesFunc)
require.NoError(t, err)
require.NotNil(t, te)
checkRecordedMetricsForTracesExporter(t, tt, te, want)
checkRecordedMetricsForTraces(t, tt, te, want)
}
func TestTracesExporter_WithRecordEnqueueFailedMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeTracesExporterName)
func TestTraces_WithRecordEnqueueFailedMetrics(t *testing.T) {
tt, err := componenttest.SetupTelemetry(fakeTracesName)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, tt.Shutdown(context.Background())) })
@ -256,14 +256,14 @@ func TestTracesExporter_WithRecordEnqueueFailedMetrics(t *testing.T) {
qCfg.NumConsumers = 1
qCfg.QueueSize = 2
wantErr := errors.New("some-error")
te, err := NewTracesExporter(context.Background(), exporter.Settings{ID: fakeTracesExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeTracesExporterConfig, newTraceDataPusher(wantErr), WithRetry(rCfg), WithQueue(qCfg))
te, err := NewTraces(context.Background(), exporter.Settings{ID: fakeTracesName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeTracesConfig, newTraceDataPusher(wantErr), WithRetry(rCfg), WithQueue(qCfg))
require.NoError(t, err)
require.NotNil(t, te)
td := testdata.GenerateTraces(2)
const numBatches = 7
for i := 0; i < numBatches; i++ {
// errors are checked in the checkExporterEnqueueFailedTracesStats function below.
// errors are checked in the checkEnqueueFailedTracesStats function below.
_ = te.ConsumeTraces(context.Background(), td)
}
@ -271,35 +271,35 @@ func TestTracesExporter_WithRecordEnqueueFailedMetrics(t *testing.T) {
require.NoError(t, tt.CheckExporterEnqueueFailedTraces(int64(10)))
}
func TestTracesExporter_WithSpan(t *testing.T) {
func TestTraces_WithSpan(t *testing.T) {
set := exportertest.NewNopSettings()
sr := new(tracetest.SpanRecorder)
set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
otel.SetTracerProvider(set.TracerProvider)
defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
te, err := NewTracesExporter(context.Background(), set, &fakeTracesExporterConfig, newTraceDataPusher(nil))
te, err := NewTraces(context.Background(), set, &fakeTracesConfig, newTraceDataPusher(nil))
require.NoError(t, err)
require.NotNil(t, te)
checkWrapSpanForTracesExporter(t, sr, set.TracerProvider.Tracer("test"), te, nil, 1)
checkWrapSpanForTraces(t, sr, set.TracerProvider.Tracer("test"), te, nil, 1)
}
func TestTracesRequestExporter_WithSpan(t *testing.T) {
func TestTracesRequest_WithSpan(t *testing.T) {
set := exportertest.NewNopSettings()
sr := new(tracetest.SpanRecorder)
set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
otel.SetTracerProvider(set.TracerProvider)
defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
te, err := NewTracesRequestExporter(context.Background(), set, (&internal.FakeRequestConverter{}).RequestFromTracesFunc)
te, err := NewTracesRequest(context.Background(), set, (&internal.FakeRequestConverter{}).RequestFromTracesFunc)
require.NoError(t, err)
require.NotNil(t, te)
checkWrapSpanForTracesExporter(t, sr, set.TracerProvider.Tracer("test"), te, nil, 1)
checkWrapSpanForTraces(t, sr, set.TracerProvider.Tracer("test"), te, nil, 1)
}
func TestTracesExporter_WithSpan_ReturnError(t *testing.T) {
func TestTraces_WithSpan_ReturnError(t *testing.T) {
set := exportertest.NewNopSettings()
sr := new(tracetest.SpanRecorder)
set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
@ -307,14 +307,14 @@ func TestTracesExporter_WithSpan_ReturnError(t *testing.T) {
defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
want := errors.New("my_error")
te, err := NewTracesExporter(context.Background(), set, &fakeTracesExporterConfig, newTraceDataPusher(want))
te, err := NewTraces(context.Background(), set, &fakeTracesConfig, newTraceDataPusher(want))
require.NoError(t, err)
require.NotNil(t, te)
checkWrapSpanForTracesExporter(t, sr, set.TracerProvider.Tracer("test"), te, want, 1)
checkWrapSpanForTraces(t, sr, set.TracerProvider.Tracer("test"), te, want, 1)
}
func TestTracesRequestExporter_WithSpan_ExportError(t *testing.T) {
func TestTracesRequest_WithSpan_ExportError(t *testing.T) {
set := exportertest.NewNopSettings()
sr := new(tracetest.SpanRecorder)
set.TracerProvider = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sr))
@ -322,18 +322,18 @@ func TestTracesRequestExporter_WithSpan_ExportError(t *testing.T) {
defer otel.SetTracerProvider(nooptrace.NewTracerProvider())
want := errors.New("export_error")
te, err := NewTracesRequestExporter(context.Background(), set, (&internal.FakeRequestConverter{RequestError: want}).RequestFromTracesFunc)
te, err := NewTracesRequest(context.Background(), set, (&internal.FakeRequestConverter{RequestError: want}).RequestFromTracesFunc)
require.NoError(t, err)
require.NotNil(t, te)
checkWrapSpanForTracesExporter(t, sr, set.TracerProvider.Tracer("test"), te, want, 1)
checkWrapSpanForTraces(t, sr, set.TracerProvider.Tracer("test"), te, want, 1)
}
func TestTracesExporter_WithShutdown(t *testing.T) {
func TestTraces_WithShutdown(t *testing.T) {
shutdownCalled := false
shutdown := func(context.Context) error { shutdownCalled = true; return nil }
te, err := NewTracesExporter(context.Background(), exportertest.NewNopSettings(), &fakeTracesExporterConfig, newTraceDataPusher(nil), WithShutdown(shutdown))
te, err := NewTraces(context.Background(), exportertest.NewNopSettings(), &fakeTracesConfig, newTraceDataPusher(nil), WithShutdown(shutdown))
assert.NotNil(t, te)
assert.NoError(t, err)
@ -342,11 +342,11 @@ func TestTracesExporter_WithShutdown(t *testing.T) {
assert.True(t, shutdownCalled)
}
func TestTracesRequestExporter_WithShutdown(t *testing.T) {
func TestTracesRequest_WithShutdown(t *testing.T) {
shutdownCalled := false
shutdown := func(context.Context) error { shutdownCalled = true; return nil }
te, err := NewTracesRequestExporter(context.Background(), exportertest.NewNopSettings(),
te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{}).RequestFromTracesFunc, WithShutdown(shutdown))
assert.NotNil(t, te)
assert.NoError(t, err)
@ -356,11 +356,11 @@ func TestTracesRequestExporter_WithShutdown(t *testing.T) {
assert.True(t, shutdownCalled)
}
func TestTracesExporter_WithShutdown_ReturnError(t *testing.T) {
func TestTraces_WithShutdown_ReturnError(t *testing.T) {
want := errors.New("my_error")
shutdownErr := func(context.Context) error { return want }
te, err := NewTracesExporter(context.Background(), exportertest.NewNopSettings(), &fakeTracesExporterConfig, newTraceDataPusher(nil), WithShutdown(shutdownErr))
te, err := NewTraces(context.Background(), exportertest.NewNopSettings(), &fakeTracesConfig, newTraceDataPusher(nil), WithShutdown(shutdownErr))
assert.NotNil(t, te)
assert.NoError(t, err)
@ -368,11 +368,11 @@ func TestTracesExporter_WithShutdown_ReturnError(t *testing.T) {
assert.Equal(t, want, te.Shutdown(context.Background()))
}
func TestTracesRequestExporter_WithShutdown_ReturnError(t *testing.T) {
func TestTracesRequest_WithShutdown_ReturnError(t *testing.T) {
want := errors.New("my_error")
shutdownErr := func(context.Context) error { return want }
te, err := NewTracesRequestExporter(context.Background(), exportertest.NewNopSettings(),
te, err := NewTracesRequest(context.Background(), exportertest.NewNopSettings(),
(&internal.FakeRequestConverter{}).RequestFromTracesFunc, WithShutdown(shutdownErr))
assert.NotNil(t, te)
assert.NoError(t, err)
@ -394,7 +394,7 @@ func newTraceDataPusherModifiedDownstream(retError error) consumer.ConsumeTraces
}
}
func checkRecordedMetricsForTracesExporter(t *testing.T, tt componenttest.TestTelemetry, te exporter.Traces, wantError error) {
func checkRecordedMetricsForTraces(t *testing.T, tt componenttest.TestTelemetry, te exporter.Traces, wantError error) {
td := testdata.GenerateTraces(2)
const numBatches = 7
for i := 0; i < numBatches; i++ {
@ -419,7 +419,7 @@ func generateTraceTraffic(t *testing.T, tracer trace.Tracer, te exporter.Traces,
}
}
func checkWrapSpanForTracesExporter(t *testing.T, sr *tracetest.SpanRecorder, tracer trace.Tracer,
func checkWrapSpanForTraces(t *testing.T, sr *tracetest.SpanRecorder, tracer trace.Tracer,
te exporter.Traces, wantError error, numSpans int64) { // nolint: unparam
const numRequests = 5
generateTraceTraffic(t, tracer, te, numRequests, wantError)

24
exporter/exporterprofiles/exporter.go
View File

@ -21,12 +21,18 @@ type Profiles interface {
type Factory interface {
exporter.Factory
// CreateProfilesExporter creates a ProfilesExporter based on this config.
// CreateProfiles creates a Profiles exporter based on this config.
// If the exporter type does not support tracing,
// this function returns the error [pipeline.ErrSignalNotSupported].
CreateProfiles(ctx context.Context, set exporter.Settings, cfg component.Config) (Profiles, error)
// ProfilesStability gets the stability level of the Profiles exporter.
ProfilesStability() component.StabilityLevel
// Deprecated: [v0.112.0] use CreateProfiles.
CreateProfilesExporter(ctx context.Context, set exporter.Settings, cfg component.Config) (Profiles, error)
// ProfilesExporterStability gets the stability level of the ProfilesExporter.
// Deprecated: [v0.112.0] use ProfilesExporterStability.
ProfilesExporterStability() component.StabilityLevel
}
@ -51,14 +57,19 @@ type factoryOpts struct {
// CreateProfilesFunc is the equivalent of Factory.CreateProfiles.
type CreateProfilesFunc func(context.Context, exporter.Settings, component.Config) (Profiles, error)
// CreateProfilesExporter implements Factory.CreateProfiles.
func (f CreateProfilesFunc) CreateProfilesExporter(ctx context.Context, set exporter.Settings, cfg component.Config) (Profiles, error) {
// CreateProfiles implements Factory.CreateProfiles.
func (f CreateProfilesFunc) CreateProfiles(ctx context.Context, set exporter.Settings, cfg component.Config) (Profiles, error) {
if f == nil {
return nil, pipeline.ErrSignalNotSupported
}
return f(ctx, set, cfg)
}
// Deprecated: [v0.112.0] use CreateProfiles.
func (f CreateProfilesFunc) CreateProfilesExporter(ctx context.Context, set exporter.Settings, cfg component.Config) (Profiles, error) {
return f.CreateProfiles(ctx, set, cfg)
}
// WithTraces overrides the default "error not supported" implementation for CreateTraces and the default "undefined" stability level.
func WithTraces(createTraces exporter.CreateTracesFunc, sl component.StabilityLevel) FactoryOption {
return factoryOptionFunc(func(o *factoryOpts) {
@ -94,6 +105,11 @@ type factory struct {
profilesStabilityLevel component.StabilityLevel
}
func (f *factory) ProfilesStability() component.StabilityLevel {
return f.profilesStabilityLevel
}
// Deprecated: [v0.112.0] use ProfilesStability.
func (f *factory) ProfilesExporterStability() component.StabilityLevel {
return f.profilesStabilityLevel
}

10
exporter/exporterprofiles/exporter_test.go
View File

@ -25,17 +25,17 @@ func TestNewFactoryWithProfiles(t *testing.T) {
assert.EqualValues(t, testType, factory.Type())
assert.EqualValues(t, &defaultCfg, factory.CreateDefaultConfig())
assert.Equal(t, component.StabilityLevelDevelopment, factory.ProfilesExporterStability())
_, err := factory.CreateProfilesExporter(context.Background(), exporter.Settings{}, &defaultCfg)
assert.Equal(t, component.StabilityLevelDevelopment, factory.ProfilesStability())
_, err := factory.CreateProfiles(context.Background(), exporter.Settings{}, &defaultCfg)
assert.NoError(t, err)
}
var nopInstance = &nopExporter{
var nopInstance = &nop{
Consumer: consumertest.NewNop(),
}
// nopExporter stores consumed profiles for testing purposes.
type nopExporter struct {
// nop stores consumed profiles for testing purposes.
type nop struct {
component.StartFunc
component.ShutdownFunc
consumertest.Consumer

6
exporter/exportertest/contract_checker.go
View File

@ -110,7 +110,7 @@ func checkMetrics(t *testing.T, params CheckConsumeContractParams, mockReceiver
ctx := context.Background()
var exp exporter.Metrics
var err error
exp, err = params.ExporterFactory.CreateMetricsExporter(ctx, NewNopSettings(), params.ExporterConfig)
exp, err = params.ExporterFactory.CreateMetrics(ctx, NewNopSettings(), params.ExporterConfig)
require.NoError(t, err)
require.NotNil(t, exp)
@ -150,7 +150,7 @@ func checkTraces(t *testing.T, params CheckConsumeContractParams, mockReceiver c
ctx := context.Background()
var exp exporter.Traces
var err error
exp, err = params.ExporterFactory.CreateTracesExporter(ctx, NewNopSettings(), params.ExporterConfig)
exp, err = params.ExporterFactory.CreateTraces(ctx, NewNopSettings(), params.ExporterConfig)
require.NoError(t, err)
require.NotNil(t, exp)
@ -190,7 +190,7 @@ func checkLogs(t *testing.T, params CheckConsumeContractParams, mockReceiver com
ctx := context.Background()
var exp exporter.Logs
var err error
exp, err = params.ExporterFactory.CreateLogsExporter(ctx, NewNopSettings(), params.ExporterConfig)
exp, err = params.ExporterFactory.CreateLogs(ctx, NewNopSettings(), params.ExporterConfig)
require.NoError(t, err)
require.NotNil(t, exp)

32
exporter/exportertest/contract_checker_test.go
View File

@ -33,57 +33,57 @@ type mockReceiver struct {
consumer.Logs
}
// mockExporterFactory is a factory to create exporters sending data to the mockReceiver.
type mockExporterFactory struct {
// mockFactory is a factory to create exporters sending data to the mockReceiver.
type mockFactory struct {
mr *mockReceiver
component.StartFunc
component.ShutdownFunc
}
func (mef *mockExporterFactory) createMockTracesExporter(
func (mef *mockFactory) createMockTraces(
ctx context.Context,
set exporter.Settings,
cfg component.Config,
) (exporter.Traces, error) {
return exporterhelper.NewTracesExporter(ctx, set, cfg,
return exporterhelper.NewTraces(ctx, set, cfg,
mef.mr.Traces.ConsumeTraces,
exporterhelper.WithCapabilities(consumer.Capabilities{MutatesData: false}),
exporterhelper.WithRetry(retryConfig),
)
}
func (mef *mockExporterFactory) createMockMetricsExporter(
func (mef *mockFactory) createMockMetrics(
ctx context.Context,
set exporter.Settings,
cfg component.Config,
) (exporter.Metrics, error) {
return exporterhelper.NewMetricsExporter(ctx, set, cfg,
return exporterhelper.NewMetrics(ctx, set, cfg,
mef.mr.Metrics.ConsumeMetrics,
exporterhelper.WithCapabilities(consumer.Capabilities{MutatesData: false}),
exporterhelper.WithRetry(retryConfig),
)
}
func (mef *mockExporterFactory) createMockLogsExporter(
func (mef *mockFactory) createMockLogs(
ctx context.Context,
set exporter.Settings,
cfg component.Config,
) (exporter.Logs, error) {
return exporterhelper.NewLogsExporter(ctx, set, cfg,
return exporterhelper.NewLogs(ctx, set, cfg,
mef.mr.Logs.ConsumeLogs,
exporterhelper.WithCapabilities(consumer.Capabilities{MutatesData: false}),
exporterhelper.WithRetry(retryConfig),
)
}
func newMockExporterFactory(mr *mockReceiver) exporter.Factory {
mef := &mockExporterFactory{mr: mr}
func newMockFactory(mr *mockReceiver) exporter.Factory {
mef := &mockFactory{mr: mr}
return exporter.NewFactory(
component.MustNewType("pass_through_exporter"),
func() component.Config { return &nopConfig{} },
exporter.WithTraces(mef.createMockTracesExporter, component.StabilityLevelBeta),
exporter.WithMetrics(mef.createMockMetricsExporter, component.StabilityLevelBeta),
exporter.WithLogs(mef.createMockLogsExporter, component.StabilityLevelBeta),
exporter.WithTraces(mef.createMockTraces, component.StabilityLevelBeta),
exporter.WithMetrics(mef.createMockMetrics, component.StabilityLevelBeta),
exporter.WithLogs(mef.createMockLogs, component.StabilityLevelBeta),
)
}
@ -109,7 +109,7 @@ func TestCheckConsumeContractLogs(t *testing.T) {
mr := &mockReceiver{}
params := CheckConsumeContractParams{
T: t,
ExporterFactory: newMockExporterFactory(mr),
ExporterFactory: newMockFactory(mr),
Signal: pipeline.SignalLogs,
ExporterConfig: nopConfig{},
NumberOfTestElements: 10,
@ -123,7 +123,7 @@ func TestCheckConsumeContractMetrics(t *testing.T) {
mr := &mockReceiver{}
CheckConsumeContract(CheckConsumeContractParams{
T: t,
ExporterFactory: newMockExporterFactory(mr),
ExporterFactory: newMockFactory(mr),
Signal: pipeline.SignalMetrics, // Change to the appropriate data type
ExporterConfig: nopConfig{},
NumberOfTestElements: 10,
@ -135,7 +135,7 @@ func TestCheckConsumeContractTraces(t *testing.T) {
mr := &mockReceiver{}
CheckConsumeContract(CheckConsumeContractParams{
T: t,
ExporterFactory: newMockExporterFactory(mr),
ExporterFactory: newMockFactory(mr),
Signal: pipeline.SignalTraces,
ExporterConfig: nopConfig{},
NumberOfTestElements: 10,

24
exporter/exportertest/nop_exporter.go
View File

@ -17,7 +17,7 @@ import (
var nopType = component.MustNewType("nop")
// NewNopSettings returns a new nop settings for Create*Exporter functions.
// NewNopSettings returns a new nop settings for Create* functions.
func NewNopSettings() exporter.Settings {
return exporter.Settings{
ID: component.NewIDWithName(nopType, uuid.NewString()),
@ -31,37 +31,37 @@ func NewNopFactory() exporter.Factory {
return exporterprofiles.NewFactory(
nopType,
func() component.Config { return &nopConfig{} },
exporterprofiles.WithTraces(createTracesExporter, component.StabilityLevelStable),
exporterprofiles.WithMetrics(createMetricsExporter, component.StabilityLevelStable),
exporterprofiles.WithLogs(createLogsExporter, component.StabilityLevelStable),
exporterprofiles.WithProfiles(createProfilesExporter, component.StabilityLevelAlpha),
exporterprofiles.WithTraces(createTraces, component.StabilityLevelStable),
exporterprofiles.WithMetrics(createMetrics, component.StabilityLevelStable),
exporterprofiles.WithLogs(createLogs, component.StabilityLevelStable),
exporterprofiles.WithProfiles(createProfiles, component.StabilityLevelAlpha),
)
}
func createTracesExporter(context.Context, exporter.Settings, component.Config) (exporter.Traces, error) {
func createTraces(context.Context, exporter.Settings, component.Config) (exporter.Traces, error) {
return nopInstance, nil
}
func createMetricsExporter(context.Context, exporter.Settings, component.Config) (exporter.Metrics, error) {
func createMetrics(context.Context, exporter.Settings, component.Config) (exporter.Metrics, error) {
return nopInstance, nil
}
func createLogsExporter(context.Context, exporter.Settings, component.Config) (exporter.Logs, error) {
func createLogs(context.Context, exporter.Settings, component.Config) (exporter.Logs, error) {
return nopInstance, nil
}
func createProfilesExporter(context.Context, exporter.Settings, component.Config) (exporterprofiles.Profiles, error) {
func createProfiles(context.Context, exporter.Settings, component.Config) (exporterprofiles.Profiles, error) {
return nopInstance, nil
}
type nopConfig struct{}
var nopInstance = &nopExporter{
var nopInstance = &nop{
Consumer: consumertest.NewNop(),
}
// nopExporter stores consumed traces, metrics, logs and profiles for testing purposes.
type nopExporter struct {
// nop stores consumed traces, metrics, logs and profiles for testing purposes.
type nop struct {
component.StartFunc
component.ShutdownFunc
consumertest.Consumer

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.CreateTracesExporter(context.Background(), NewNopSettings(), cfg)
traces, err := factory.CreateTraces(context.Background(), NewNopSettings(), 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.CreateMetricsExporter(context.Background(), NewNopSettings(), cfg)
metrics, err := factory.CreateMetrics(context.Background(), NewNopSettings(), 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.CreateLogsExporter(context.Background(), NewNopSettings(), cfg)
logs, err := factory.CreateLogs(context.Background(), NewNopSettings(), 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.(exporterprofiles.Factory).CreateProfilesExporter(context.Background(), NewNopSettings(), cfg)
profiles, err := factory.(exporterprofiles.Factory).CreateProfiles(context.Background(), NewNopSettings(), cfg)
require.NoError(t, err)
assert.NoError(t, profiles.Start(context.Background(), componenttest.NewNopHost()))
assert.NoError(t, profiles.ConsumeProfiles(context.Background(), pprofile.NewProfiles()))

6
exporter/nopexporter/generated_component_test.go
View File

@ -39,21 +39,21 @@ func TestComponentLifecycle(t *testing.T) {
{
name: "logs",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateLogsExporter(ctx, set, cfg)
return factory.CreateLogs(ctx, set, cfg)
},
},
{
name: "metrics",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateMetricsExporter(ctx, set, cfg)
return factory.CreateMetrics(ctx, set, cfg)
},
},
{
name: "traces",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateTracesExporter(ctx, set, cfg)
return factory.CreateTraces(ctx, set, cfg)
},
},
}

16
exporter/nopexporter/nop_exporter.go
View File

@ -17,29 +17,29 @@ func NewFactory() exporter.Factory {
return exporter.NewFactory(
metadata.Type,
func() component.Config { return &struct{}{} },
exporter.WithTraces(createTracesExporter, metadata.TracesStability),
exporter.WithMetrics(createMetricsExporter, metadata.MetricsStability),
exporter.WithLogs(createLogsExporter, metadata.LogsStability),
exporter.WithTraces(createTraces, metadata.TracesStability),
exporter.WithMetrics(createMetrics, metadata.MetricsStability),
exporter.WithLogs(createLogs, metadata.LogsStability),
)
}
func createTracesExporter(context.Context, exporter.Settings, component.Config) (exporter.Traces, error) {
func createTraces(context.Context, exporter.Settings, component.Config) (exporter.Traces, error) {
return nopInstance, nil
}
func createMetricsExporter(context.Context, exporter.Settings, component.Config) (exporter.Metrics, error) {
func createMetrics(context.Context, exporter.Settings, component.Config) (exporter.Metrics, error) {
return nopInstance, nil
}
func createLogsExporter(context.Context, exporter.Settings, component.Config) (exporter.Logs, error) {
func createLogs(context.Context, exporter.Settings, component.Config) (exporter.Logs, error) {
return nopInstance, nil
}
var nopInstance = &nopExporter{
var nopInstance = &nop{
Consumer: consumertest.NewNop(),
}
type nopExporter struct {
type nop struct {
component.StartFunc
component.ShutdownFunc
consumertest.Consumer

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.CreateTracesExporter(context.Background(), exportertest.NewNopSettings(), cfg)
traces, err := factory.CreateTraces(context.Background(), exportertest.NewNopSettings(), 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.CreateMetricsExporter(context.Background(), exportertest.NewNopSettings(), cfg)
metrics, err := factory.CreateMetrics(context.Background(), exportertest.NewNopSettings(), 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.CreateLogsExporter(context.Background(), exportertest.NewNopSettings(), cfg)
logs, err := factory.CreateLogs(context.Background(), exportertest.NewNopSettings(), cfg)
require.NoError(t, err)
assert.NoError(t, logs.Start(context.Background(), componenttest.NewNopHost()))
assert.NoError(t, logs.ConsumeLogs(context.Background(), plog.NewLogs()))

18
exporter/otlpexporter/factory.go
View File

@ -23,9 +23,9 @@ func NewFactory() exporter.Factory {
return exporter.NewFactory(
metadata.Type,
createDefaultConfig,
exporter.WithTraces(createTracesExporter, metadata.TracesStability),
exporter.WithMetrics(createMetricsExporter, metadata.MetricsStability),
exporter.WithLogs(createLogsExporter, metadata.LogsStability),
exporter.WithTraces(createTraces, metadata.TracesStability),
exporter.WithMetrics(createMetrics, metadata.MetricsStability),
exporter.WithLogs(createLogs, metadata.LogsStability),
)
}
@ -48,14 +48,14 @@ func createDefaultConfig() component.Config {
}
}
func createTracesExporter(
func createTraces(
ctx context.Context,
set exporter.Settings,
cfg component.Config,
) (exporter.Traces, error) {
oce := newExporter(cfg, set)
oCfg := cfg.(*Config)
return exporterhelper.NewTracesExporter(ctx, set, cfg,
return exporterhelper.NewTraces(ctx, set, cfg,
oce.pushTraces,
exporterhelper.WithCapabilities(consumer.Capabilities{MutatesData: false}),
exporterhelper.WithTimeout(oCfg.TimeoutConfig),
@ -67,14 +67,14 @@ func createTracesExporter(
)
}
func createMetricsExporter(
func createMetrics(
ctx context.Context,
set exporter.Settings,
cfg component.Config,
) (exporter.Metrics, error) {
oce := newExporter(cfg, set)
oCfg := cfg.(*Config)
return exporterhelper.NewMetricsExporter(ctx, set, cfg,
return exporterhelper.NewMetrics(ctx, set, cfg,
oce.pushMetrics,
exporterhelper.WithCapabilities(consumer.Capabilities{MutatesData: false}),
exporterhelper.WithTimeout(oCfg.TimeoutConfig),
@ -86,14 +86,14 @@ func createMetricsExporter(
)
}
func createLogsExporter(
func createLogs(
ctx context.Context,
set exporter.Settings,
cfg component.Config,
) (exporter.Logs, error) {
oce := newExporter(cfg, set)
oCfg := cfg.(*Config)
return exporterhelper.NewLogsExporter(ctx, set, cfg,
return exporterhelper.NewLogs(ctx, set, cfg,
oce.pushLogs,
exporterhelper.WithCapabilities(consumer.Capabilities{MutatesData: false}),
exporterhelper.WithTimeout(oCfg.TimeoutConfig),

12
exporter/otlpexporter/factory_test.go
View File

@ -36,18 +36,18 @@ func TestCreateDefaultConfig(t *testing.T) {
assert.Equal(t, configcompression.TypeGzip, ocfg.Compression)
}
func TestCreateMetricsExporter(t *testing.T) {
func TestCreateMetrics(t *testing.T) {
factory := NewFactory()
cfg := factory.CreateDefaultConfig().(*Config)
cfg.ClientConfig.Endpoint = testutil.GetAvailableLocalAddress(t)
set := exportertest.NewNopSettings()
oexp, err := factory.CreateMetricsExporter(context.Background(), set, cfg)
oexp, err := factory.CreateMetrics(context.Background(), set, cfg)
require.NoError(t, err)
require.NotNil(t, oexp)
}
func TestCreateTracesExporter(t *testing.T) {
func TestCreateTraces(t *testing.T) {
endpoint := testutil.GetAvailableLocalAddress(t)
tests := []struct {
name string
@ -167,7 +167,7 @@ func TestCreateTracesExporter(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
factory := NewFactory()
set := exportertest.NewNopSettings()
consumer, err := factory.CreateTracesExporter(context.Background(), set, tt.config)
consumer, err := factory.CreateTraces(context.Background(), set, tt.config)
require.NoError(t, err)
assert.NotNil(t, consumer)
err = consumer.Start(context.Background(), componenttest.NewNopHost())
@ -187,13 +187,13 @@ func TestCreateTracesExporter(t *testing.T) {
}
}
func TestCreateLogsExporter(t *testing.T) {
func TestCreateLogs(t *testing.T) {
factory := NewFactory()
cfg := factory.CreateDefaultConfig().(*Config)
cfg.ClientConfig.Endpoint = testutil.GetAvailableLocalAddress(t)
set := exportertest.NewNopSettings()
oexp, err := factory.CreateLogsExporter(context.Background(), set, cfg)
oexp, err := factory.CreateLogs(context.Background(), set, cfg)
require.NoError(t, err)
require.NotNil(t, oexp)
}

6
exporter/otlpexporter/generated_component_test.go
View File

@ -39,21 +39,21 @@ func TestComponentLifecycle(t *testing.T) {
{
name: "logs",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateLogsExporter(ctx, set, cfg)
return factory.CreateLogs(ctx, set, cfg)
},
},
{
name: "metrics",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateMetricsExporter(ctx, set, cfg)
return factory.CreateMetrics(ctx, set, cfg)
},
},
{
name: "traces",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateTracesExporter(ctx, set, cfg)
return factory.CreateTraces(ctx, set, cfg)
},
},
}

14
exporter/otlpexporter/otlp_test.go
View File

@ -254,7 +254,7 @@ func TestSendTraces(t *testing.T) {
logger, observed := observer.New(zap.DebugLevel)
set.TelemetrySettings.Logger = zap.New(logger)
exp, err := factory.CreateTracesExporter(context.Background(), set, cfg)
exp, err := factory.CreateTraces(context.Background(), set, cfg)
require.NoError(t, err)
require.NotNil(t, exp)
@ -366,7 +366,7 @@ func TestSendTracesWhenEndpointHasHttpScheme(t *testing.T) {
cfg.ClientConfig.TLSSetting.InsecureSkipVerify = true
}
set := exportertest.NewNopSettings()
exp, err := factory.CreateTracesExporter(context.Background(), set, cfg)
exp, err := factory.CreateTraces(context.Background(), set, cfg)
require.NoError(t, err)
require.NotNil(t, exp)
@ -426,7 +426,7 @@ func TestSendMetrics(t *testing.T) {
logger, observed := observer.New(zap.DebugLevel)
set.TelemetrySettings.Logger = zap.New(logger)
exp, err := factory.CreateMetricsExporter(context.Background(), set, cfg)
exp, err := factory.CreateMetrics(context.Background(), set, cfg)
require.NoError(t, err)
require.NotNil(t, exp)
defer func() {
@ -524,7 +524,7 @@ func TestSendTraceDataServerDownAndUp(t *testing.T) {
WaitForReady: true,
}
set := exportertest.NewNopSettings()
exp, err := factory.CreateTracesExporter(context.Background(), set, cfg)
exp, err := factory.CreateTraces(context.Background(), set, cfg)
require.NoError(t, err)
require.NotNil(t, exp)
defer func() {
@ -581,7 +581,7 @@ func TestSendTraceDataServerStartWhileRequest(t *testing.T) {
},
}
set := exportertest.NewNopSettings()
exp, err := factory.CreateTracesExporter(context.Background(), set, cfg)
exp, err := factory.CreateTraces(context.Background(), set, cfg)
require.NoError(t, err)
require.NotNil(t, exp)
defer func() {
@ -632,7 +632,7 @@ func TestSendTracesOnResourceExhaustion(t *testing.T) {
},
}
set := exportertest.NewNopSettings()
exp, err := factory.CreateTracesExporter(context.Background(), set, cfg)
exp, err := factory.CreateTraces(context.Background(), set, cfg)
require.NoError(t, err)
require.NotNil(t, exp)
@ -720,7 +720,7 @@ func TestSendLogData(t *testing.T) {
logger, observed := observer.New(zap.DebugLevel)
set.TelemetrySettings.Logger = zap.New(logger)
exp, err := factory.CreateLogsExporter(context.Background(), set, cfg)
exp, err := factory.CreateLogs(context.Background(), set, cfg)
require.NoError(t, err)
require.NotNil(t, exp)
defer func() {

19
exporter/otlphttpexporter/factory.go
View File

@ -25,9 +25,9 @@ func NewFactory() exporter.Factory {
return exporter.NewFactory(
metadata.Type,
createDefaultConfig,
exporter.WithTraces(createTracesExporter, metadata.TracesStability),
exporter.WithMetrics(createMetricsExporter, metadata.MetricsStability),
exporter.WithLogs(createLogsExporter, metadata.LogsStability),
exporter.WithTraces(createTraces, metadata.TracesStability),
exporter.WithMetrics(createMetrics, metadata.MetricsStability),
exporter.WithLogs(createLogs, metadata.LogsStability),
)
}
@ -70,7 +70,7 @@ func composeSignalURL(oCfg *Config, signalOverrideURL string, signalName string,
}
}
func createTracesExporter(
func createTraces(
ctx context.Context,
set exporter.Settings,
cfg component.Config,
@ -86,7 +86,7 @@ func createTracesExporter(
return nil, err
}
return exporterhelper.NewTracesExporter(ctx, set, cfg,
return exporterhelper.NewTraces(ctx, set, cfg,
oce.pushTraces,
exporterhelper.WithStart(oce.start),
exporterhelper.WithCapabilities(consumer.Capabilities{MutatesData: false}),
@ -96,7 +96,7 @@ func createTracesExporter(
exporterhelper.WithQueue(oCfg.QueueConfig))
}
func createMetricsExporter(
func createMetrics(
ctx context.Context,
set exporter.Settings,
cfg component.Config,
@ -112,7 +112,7 @@ func createMetricsExporter(
return nil, err
}
return exporterhelper.NewMetricsExporter(ctx, set, cfg,
return exporterhelper.NewMetrics(ctx, set, cfg,
oce.pushMetrics,
exporterhelper.WithStart(oce.start),
exporterhelper.WithCapabilities(consumer.Capabilities{MutatesData: false}),
@ -122,7 +122,7 @@ func createMetricsExporter(
exporterhelper.WithQueue(oCfg.QueueConfig))
}
func createLogsExporter(
func createLogs(
ctx context.Context,
set exporter.Settings,
cfg component.Config,
@ -132,13 +132,12 @@ func createLogsExporter(
return nil, err
}
oCfg := cfg.(*Config)
oce.logsURL, err = composeSignalURL(oCfg, oCfg.LogsEndpoint, "logs", "v1")
if err != nil {
return nil, err
}
return exporterhelper.NewLogsExporter(ctx, set, cfg,
return exporterhelper.NewLogs(ctx, set, cfg,
oce.pushLogs,
exporterhelper.WithStart(oce.start),
exporterhelper.WithCapabilities(consumer.Capabilities{MutatesData: false}),

12
exporter/otlphttpexporter/factory_test.go
View File

@ -39,13 +39,13 @@ func TestCreateDefaultConfig(t *testing.T) {
assert.Equal(t, configcompression.TypeGzip, ocfg.Compression)
}
func TestCreateMetricsExporter(t *testing.T) {
func TestCreateMetrics(t *testing.T) {
factory := NewFactory()
cfg := factory.CreateDefaultConfig().(*Config)
cfg.ClientConfig.Endpoint = "http://" + testutil.GetAvailableLocalAddress(t)
set := exportertest.NewNopSettings()
oexp, err := factory.CreateMetricsExporter(context.Background(), set, cfg)
oexp, err := factory.CreateMetrics(context.Background(), set, cfg)
require.NoError(t, err)
require.NotNil(t, oexp)
}
@ -63,7 +63,7 @@ func clientConfig(endpoint string, headers map[string]configopaque.String, tlsSe
return clientConfig
}
func TestCreateTracesExporter(t *testing.T) {
func TestCreateTraces(t *testing.T) {
var configCompression configcompression.Type
endpoint := "http://" + testutil.GetAvailableLocalAddress(t)
@ -164,7 +164,7 @@ func TestCreateTracesExporter(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
factory := NewFactory()
set := exportertest.NewNopSettings()
consumer, err := factory.CreateTracesExporter(context.Background(), set, tt.config)
consumer, err := factory.CreateTraces(context.Background(), set, tt.config)
if tt.mustFailOnCreate {
assert.Error(t, err)
@ -187,13 +187,13 @@ func TestCreateTracesExporter(t *testing.T) {
}
}
func TestCreateLogsExporter(t *testing.T) {
func TestCreateLogs(t *testing.T) {
factory := NewFactory()
cfg := factory.CreateDefaultConfig().(*Config)
cfg.ClientConfig.Endpoint = "http://" + testutil.GetAvailableLocalAddress(t)
set := exportertest.NewNopSettings()
oexp, err := factory.CreateLogsExporter(context.Background(), set, cfg)
oexp, err := factory.CreateLogs(context.Background(), set, cfg)
require.NoError(t, err)
require.NotNil(t, oexp)
}

6
exporter/otlphttpexporter/generated_component_test.go
View File

@ -39,21 +39,21 @@ func TestComponentLifecycle(t *testing.T) {
{
name: "logs",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateLogsExporter(ctx, set, cfg)
return factory.CreateLogs(ctx, set, cfg)
},
},
{
name: "metrics",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateMetricsExporter(ctx, set, cfg)
return factory.CreateMetrics(ctx, set, cfg)
},
},
{
name: "traces",
createFn: func(ctx context.Context, set exporter.Settings, cfg component.Config) (component.Component, error) {
return factory.CreateTracesExporter(ctx, set, cfg)
return factory.CreateTraces(ctx, set, cfg)
},
},
}

20
exporter/otlphttpexporter/otlp_test.go
View File

@ -218,7 +218,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 := createTracesExporter(context.Background(), exportertest.NewNopSettings(), cfg)
exp, err := createTraces(context.Background(), exportertest.NewNopSettings(), cfg)
require.NoError(t, err)
// start the exporter
@ -294,7 +294,7 @@ func TestUserAgent(t *testing.T) {
Headers: tt.headers,
},
}
exp, err := createTracesExporter(context.Background(), set, cfg)
exp, err := createTraces(context.Background(), set, cfg)
require.NoError(t, err)
// start the exporter
@ -328,7 +328,7 @@ func TestUserAgent(t *testing.T) {
Headers: tt.headers,
},
}
exp, err := createMetricsExporter(context.Background(), set, cfg)
exp, err := createMetrics(context.Background(), set, cfg)
require.NoError(t, err)
// start the exporter
@ -362,7 +362,7 @@ func TestUserAgent(t *testing.T) {
Headers: tt.headers,
},
}
exp, err := createLogsExporter(context.Background(), set, cfg)
exp, err := createLogs(context.Background(), set, cfg)
require.NoError(t, err)
// start the exporter
@ -478,7 +478,7 @@ func TestPartialSuccess_logs(t *testing.T) {
logger, observed := observer.New(zap.DebugLevel)
set.TelemetrySettings.Logger = zap.New(logger)
exp, err := createLogsExporter(context.Background(), set, cfg)
exp, err := createLogs(context.Background(), set, cfg)
require.NoError(t, err)
// start the exporter
@ -816,7 +816,7 @@ func TestPartialSuccess_traces(t *testing.T) {
set := exportertest.NewNopSettings()
logger, observed := observer.New(zap.DebugLevel)
set.TelemetrySettings.Logger = zap.New(logger)
exp, err := createTracesExporter(context.Background(), set, cfg)
exp, err := createTraces(context.Background(), set, cfg)
require.NoError(t, err)
// start the exporter
@ -856,7 +856,7 @@ func TestPartialSuccess_metrics(t *testing.T) {
set := exportertest.NewNopSettings()
logger, observed := observer.New(zap.DebugLevel)
set.TelemetrySettings.Logger = zap.New(logger)
exp, err := createMetricsExporter(context.Background(), set, cfg)
exp, err := createMetrics(context.Background(), set, cfg)
require.NoError(t, err)
// start the exporter
@ -909,7 +909,7 @@ func TestEncoding(t *testing.T) {
TracesEndpoint: fmt.Sprintf("%s/v1/traces", srv.URL),
Encoding: tt.encoding,
}
exp, err := createTracesExporter(context.Background(), set, cfg)
exp, err := createTraces(context.Background(), set, cfg)
require.NoError(t, err)
// start the exporter
@ -940,7 +940,7 @@ func TestEncoding(t *testing.T) {
MetricsEndpoint: fmt.Sprintf("%s/v1/metrics", srv.URL),
Encoding: tt.encoding,
}
exp, err := createMetricsExporter(context.Background(), set, cfg)
exp, err := createMetrics(context.Background(), set, cfg)
require.NoError(t, err)
// start the exporter
@ -971,7 +971,7 @@ func TestEncoding(t *testing.T) {
LogsEndpoint: fmt.Sprintf("%s/v1/logs", srv.URL),
Encoding: tt.encoding,
}
exp, err := createLogsExporter(context.Background(), set, cfg)
exp, err := createLogs(context.Background(), set, cfg)
require.NoError(t, err)
// start the exporter

46
internal/e2e/otlphttp_test.go
View File

@ -44,27 +44,27 @@ func TestInvalidConfig(t *testing.T) {
}
f := otlphttpexporter.NewFactory()
set := exportertest.NewNopSettings()
_, err := f.CreateTracesExporter(context.Background(), set, config)
_, err := f.CreateTraces(context.Background(), set, config)
require.Error(t, err)
_, err = f.CreateMetricsExporter(context.Background(), set, config)
_, err = f.CreateMetrics(context.Background(), set, config)
require.Error(t, err)
_, err = f.CreateLogsExporter(context.Background(), set, config)
_, err = f.CreateLogs(context.Background(), set, config)
require.Error(t, err)
}
func TestTraceNoBackend(t *testing.T) {
addr := testutil.GetAvailableLocalAddress(t)
exp := startTracesExporter(t, "", fmt.Sprintf("http://%s/v1/traces", addr))
exp := startTraces(t, "", fmt.Sprintf("http://%s/v1/traces", addr))
td := testdata.GenerateTraces(1)
assert.Error(t, exp.ConsumeTraces(context.Background(), td))
}
func TestTraceInvalidUrl(t *testing.T) {
exp := startTracesExporter(t, "http:/\\//this_is_an/*/invalid_url", "")
exp := startTraces(t, "http:/\\//this_is_an/*/invalid_url", "")
td := testdata.GenerateTraces(1)
require.Error(t, exp.ConsumeTraces(context.Background(), td))
exp = startTracesExporter(t, "", "http:/\\//this_is_an/*/invalid_url")
exp = startTraces(t, "", "http:/\\//this_is_an/*/invalid_url")
td = testdata.GenerateTraces(1)
assert.Error(t, exp.ConsumeTraces(context.Background(), td))
}
@ -73,7 +73,7 @@ func TestTraceError(t *testing.T) {
addr := testutil.GetAvailableLocalAddress(t)
startTracesReceiver(t, addr, consumertest.NewErr(errors.New("my_error")))
exp := startTracesExporter(t, "", fmt.Sprintf("http://%s/v1/traces", addr))
exp := startTraces(t, "", fmt.Sprintf("http://%s/v1/traces", addr))
td := testdata.GenerateTraces(1)
assert.Error(t, exp.ConsumeTraces(context.Background(), td))
@ -108,7 +108,7 @@ func TestTraceRoundTrip(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
sink := new(consumertest.TracesSink)
startTracesReceiver(t, addr, sink)
exp := startTracesExporter(t, tt.baseURL, tt.overrideURL)
exp := startTraces(t, tt.baseURL, tt.overrideURL)
td := testdata.GenerateTraces(1)
require.NoError(t, exp.ConsumeTraces(context.Background(), td))
@ -126,7 +126,7 @@ func TestMetricsError(t *testing.T) {
addr := testutil.GetAvailableLocalAddress(t)
startMetricsReceiver(t, addr, consumertest.NewErr(errors.New("my_error")))
exp := startMetricsExporter(t, "", fmt.Sprintf("http://%s/v1/metrics", addr))
exp := startMetrics(t, "", fmt.Sprintf("http://%s/v1/metrics", addr))
md := testdata.GenerateMetrics(1)
assert.Error(t, exp.ConsumeMetrics(context.Background(), md))
@ -161,7 +161,7 @@ func TestMetricsRoundTrip(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
sink := new(consumertest.MetricsSink)
startMetricsReceiver(t, addr, sink)
exp := startMetricsExporter(t, tt.baseURL, tt.overrideURL)
exp := startMetrics(t, tt.baseURL, tt.overrideURL)
md := testdata.GenerateMetrics(1)
require.NoError(t, exp.ConsumeMetrics(context.Background(), md))
@ -179,7 +179,7 @@ func TestLogsError(t *testing.T) {
addr := testutil.GetAvailableLocalAddress(t)
startLogsReceiver(t, addr, consumertest.NewErr(errors.New("my_error")))
exp := startLogsExporter(t, "", fmt.Sprintf("http://%s/v1/logs", addr))
exp := startLogs(t, "", fmt.Sprintf("http://%s/v1/logs", addr))
md := testdata.GenerateLogs(1)
assert.Error(t, exp.ConsumeLogs(context.Background(), md))
@ -214,7 +214,7 @@ func TestLogsRoundTrip(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
sink := new(consumertest.LogsSink)
startLogsReceiver(t, addr, sink)
exp := startLogsExporter(t, tt.baseURL, tt.overrideURL)
exp := startLogs(t, tt.baseURL, tt.overrideURL)
md := testdata.GenerateLogs(1)
require.NoError(t, exp.ConsumeLogs(context.Background(), md))
@ -252,7 +252,7 @@ func TestIssue_4221(t *testing.T) {
}))
defer func() { svr.Close() }()
exp := startTracesExporter(t, "", svr.URL)
exp := startTraces(t, "", svr.URL)
md := ptrace.NewTraces()
rms := md.ResourceSpans().AppendEmpty()
@ -287,37 +287,37 @@ func TestIssue_4221(t *testing.T) {
assert.NoError(t, exp.ConsumeTraces(context.Background(), md))
}
func startTracesExporter(t *testing.T, baseURL string, overrideURL string) exporter.Traces {
func startTraces(t *testing.T, baseURL string, overrideURL string) exporter.Traces {
factory := otlphttpexporter.NewFactory()
cfg := createExporterConfig(baseURL, factory.CreateDefaultConfig())
cfg := createConfig(baseURL, factory.CreateDefaultConfig())
cfg.TracesEndpoint = overrideURL
exp, err := factory.CreateTracesExporter(context.Background(), exportertest.NewNopSettings(), cfg)
exp, err := factory.CreateTraces(context.Background(), exportertest.NewNopSettings(), cfg)
require.NoError(t, err)
startAndCleanup(t, exp)
return exp
}
func startMetricsExporter(t *testing.T, baseURL string, overrideURL string) exporter.Metrics {
func startMetrics(t *testing.T, baseURL string, overrideURL string) exporter.Metrics {
factory := otlphttpexporter.NewFactory()
cfg := createExporterConfig(baseURL, factory.CreateDefaultConfig())
cfg := createConfig(baseURL, factory.CreateDefaultConfig())
cfg.MetricsEndpoint = overrideURL
exp, err := factory.CreateMetricsExporter(context.Background(), exportertest.NewNopSettings(), cfg)
exp, err := factory.CreateMetrics(context.Background(), exportertest.NewNopSettings(), cfg)
require.NoError(t, err)
startAndCleanup(t, exp)
return exp
}
func startLogsExporter(t *testing.T, baseURL string, overrideURL string) exporter.Logs {
func startLogs(t *testing.T, baseURL string, overrideURL string) exporter.Logs {
factory := otlphttpexporter.NewFactory()
cfg := createExporterConfig(baseURL, factory.CreateDefaultConfig())
cfg := createConfig(baseURL, factory.CreateDefaultConfig())
cfg.LogsEndpoint = overrideURL
exp, err := factory.CreateLogsExporter(context.Background(), exportertest.NewNopSettings(), cfg)
exp, err := factory.CreateLogs(context.Background(), exportertest.NewNopSettings(), cfg)
require.NoError(t, err)
startAndCleanup(t, exp)
return exp
}
func createExporterConfig(baseURL string, defaultCfg component.Config) *otlphttpexporter.Config {
func createConfig(baseURL string, defaultCfg component.Config) *otlphttpexporter.Config {
cfg := defaultCfg.(*otlphttpexporter.Config)
cfg.Endpoint = baseURL
cfg.QueueConfig.Enabled = false

6
otelcol/command_components.go
View File

@ -103,9 +103,9 @@ func newComponentsCommand(set CollectorSettings) *cobra.Command {
Name: exp.Type(),
Module: factories.ExporterModules[exp.Type()],
Stability: map[string]string{
"logs": exp.LogsExporterStability().String(),
"metrics": exp.MetricsExporterStability().String(),
"traces": exp.TracesExporterStability().String(),
"logs": exp.LogsStability().String(),
"metrics": exp.MetricsStability().String(),
"traces": exp.TracesStability().String(),
},
})
}

16
service/internal/builders/exporter.go
View File

@ -37,8 +37,8 @@ func (b *ExporterBuilder) CreateTraces(ctx context.Context, set exporter.Setting
return nil, fmt.Errorf("exporter factory not available for: %q", set.ID)
}
logStabilityLevel(set.Logger, f.TracesExporterStability())
return f.CreateTracesExporter(ctx, set, cfg)
logStabilityLevel(set.Logger, f.TracesStability())
return f.CreateTraces(ctx, set, cfg)
}
// CreateMetrics creates a Metrics exporter based on the settings and config.
@ -53,8 +53,8 @@ func (b *ExporterBuilder) CreateMetrics(ctx context.Context, set exporter.Settin
return nil, fmt.Errorf("exporter factory not available for: %q", set.ID)
}
logStabilityLevel(set.Logger, f.MetricsExporterStability())
return f.CreateMetricsExporter(ctx, set, cfg)
logStabilityLevel(set.Logger, f.MetricsStability())
return f.CreateMetrics(ctx, set, cfg)
}
// CreateLogs creates a Logs exporter based on the settings and config.
@ -69,8 +69,8 @@ func (b *ExporterBuilder) CreateLogs(ctx context.Context, set exporter.Settings)
return nil, fmt.Errorf("exporter factory not available for: %q", set.ID)
}
logStabilityLevel(set.Logger, f.LogsExporterStability())
return f.CreateLogsExporter(ctx, set, cfg)
logStabilityLevel(set.Logger, f.LogsStability())
return f.CreateLogs(ctx, set, cfg)
}
// CreateProfiles creates a Profiles exporter based on the settings and config.
@ -90,8 +90,8 @@ func (b *ExporterBuilder) CreateProfiles(ctx context.Context, set exporter.Setti
return nil, pipeline.ErrSignalNotSupported
}
logStabilityLevel(set.Logger, f.ProfilesExporterStability())
return f.CreateProfilesExporter(ctx, set, cfg)
logStabilityLevel(set.Logger, f.ProfilesStability())
return f.CreateProfiles(ctx, set, cfg)
}
func (b *ExporterBuilder) Factory(componentType component.Type) component.Factory {

8
service/internal/builders/exporter_test.go
View File

@ -158,25 +158,25 @@ func TestNewNopExporterConfigsAndFactories(t *testing.T) {
set := exportertest.NewNopSettings()
set.ID = component.NewID(nopType)
traces, err := factory.CreateTracesExporter(context.Background(), set, cfg)
traces, err := factory.CreateTraces(context.Background(), set, cfg)
require.NoError(t, err)
bTraces, err := builder.CreateTraces(context.Background(), set)
require.NoError(t, err)
assert.IsType(t, traces, bTraces)
metrics, err := factory.CreateMetricsExporter(context.Background(), set, cfg)
metrics, err := factory.CreateMetrics(context.Background(), set, cfg)
require.NoError(t, err)
bMetrics, err := builder.CreateMetrics(context.Background(), set)
require.NoError(t, err)
assert.IsType(t, metrics, bMetrics)
logs, err := factory.CreateLogsExporter(context.Background(), set, cfg)
logs, err := factory.CreateLogs(context.Background(), set, cfg)
require.NoError(t, err)
bLogs, err := builder.CreateLogs(context.Background(), set)
require.NoError(t, err)
assert.IsType(t, logs, bLogs)
profiles, err := factory.(exporterprofiles.Factory).CreateProfilesExporter(context.Background(), set, cfg)
profiles, err := factory.(exporterprofiles.Factory).CreateProfiles(context.Background(), set, cfg)
require.NoError(t, err)
bProfiles, err := builder.CreateProfiles(context.Background(), set)
require.NoError(t, err)