Rename component.TraceReceiver to component.TracesReceiver

Fixes open-telemetry#1975

Signed-off-by: Bogdan Drutu <[email protected]>

CHANGELOG.md

@@ -5,6 +5,7 @@
 ## 🛑 Breaking changes 🛑
 
 - Rename consumer.TraceConsumer to consumer.TracesConsumer #1974
+- Rename component.TraceReceiver to component.TracesReceiver #1975
 
 ## v0.13.0 Beta
 

component/componenttest/example_factories.go

@@ -39,10 +39,10 @@ type ExampleReceiver struct {
 	ExtraMapSetting  map[string]string `mapstructure:"extra_map"`
 	ExtraListSetting []string          `mapstructure:"extra_list"`
 
-	// FailTraceCreation causes CreateTraceReceiver to fail. Useful for testing.
+	// FailTraceCreation causes CreateTracesReceiver to fail. Useful for testing.
 	FailTraceCreation bool `mapstructure:"-"`
 
-	// FailMetricsCreation causes CreateTraceReceiver to fail. Useful for testing.
+	// FailMetricsCreation causes CreateMetricsReceiver to fail. Useful for testing.
 	FailMetricsCreation bool `mapstructure:"-"`
 }
 
@@ -79,12 +79,12 @@ func (f *ExampleReceiverFactory) CustomUnmarshaler() component.CustomUnmarshaler
 }
 
 // CreateTraceReceiver creates a trace receiver based on this config.
-func (f *ExampleReceiverFactory) CreateTraceReceiver(
+func (f *ExampleReceiverFactory) CreateTracesReceiver(
 	_ context.Context,
 	_ component.ReceiverCreateParams,
 	cfg configmodels.Receiver,
 	nextConsumer consumer.TracesConsumer,
-) (component.TraceReceiver, error) {
+) (component.TracesReceiver, error) {
 	if cfg.(*ExampleReceiver).FailTraceCreation {
 		return nil, configerror.ErrDataTypeIsNotSupported
 	}
@@ -162,7 +162,7 @@ func (erp *ExampleReceiverProducer) Shutdown(context.Context) error {
 
 // This is the map of already created example receivers for particular configurations.
 // We maintain this map because the ReceiverFactory is asked trace and metric receivers separately
-// when it gets CreateTraceReceiver() and CreateMetricsReceiver() but they must not
+// when it gets CreateTracesReceiver() and CreateMetricsReceiver() but they must not
 // create separate objects, they must use one Receiver object per configuration.
 var exampleReceivers = map[configmodels.Receiver]*ExampleReceiverProducer{}
 
@@ -216,12 +216,12 @@ func (f *MultiProtoReceiverFactory) CreateDefaultConfig() configmodels.Receiver
 }
 
 // CreateTraceReceiver creates a trace receiver based on this config.
-func (f *MultiProtoReceiverFactory) CreateTraceReceiver(
+func (f *MultiProtoReceiverFactory) CreateTracesReceiver(
 	_ context.Context,
 	_ component.ReceiverCreateParams,
 	_ configmodels.Receiver,
 	_ consumer.TracesConsumer,
-) (component.TraceReceiver, error) {
+) (component.TracesReceiver, error) {
 	// Not used for this test, just return nil
 	return nil, nil
 }

component/receiver.go

@@ -28,13 +28,13 @@ type Receiver interface {
 	Component
 }
 
-// A TraceReceiver is an "arbitrary data"-to-"internal format" converter.
+// A TracesReceiver is an "arbitrary data"-to-"internal format" converter.
 // Its purpose is to translate data from the wild into internal trace format.
-// TraceReceiver feeds a consumer.TracesConsumer with data.
+// TracesReceiver feeds a consumer.TracesConsumer with data.
 //
 // For example it could be Zipkin data source which translates
 // Zipkin spans into consumerdata.TraceData.
-type TraceReceiver interface {
+type TracesReceiver interface {
 	Receiver
 }
 
@@ -65,7 +65,7 @@ type ReceiverCreateParams struct {
 	ApplicationStartInfo ApplicationStartInfo
 }
 
-// ReceiverFactory can create TraceReceiver and MetricsReceiver. This is the
+// ReceiverFactory can create TracesReceiver and MetricsReceiver. This is the
 // new factory type that can create new style receivers.
 type ReceiverFactory interface {
 	Factory
@@ -82,8 +82,8 @@ type ReceiverFactory interface {
 	// CreateTraceReceiver creates a trace receiver based on this config.
 	// If the receiver type does not support tracing or if the config is not valid
 	// error will be returned instead.
-	CreateTraceReceiver(ctx context.Context, params ReceiverCreateParams,
-		cfg configmodels.Receiver, nextConsumer consumer.TracesConsumer) (TraceReceiver, error)
+	CreateTracesReceiver(ctx context.Context, params ReceiverCreateParams,
+		cfg configmodels.Receiver, nextConsumer consumer.TracesConsumer) (TracesReceiver, error)
 
 	// CreateMetricsReceiver creates a metrics receiver based on this config.
 	// If the receiver type does not support metrics or if the config is not valid

component/receiver_test.go

@@ -40,7 +40,7 @@ func (f *TestReceiverFactory) CreateDefaultConfig() configmodels.Receiver {
 }
 
 // CreateTraceReceiver creates a trace receiver based on this config.
-func (f *TestReceiverFactory) CreateTraceReceiver(context.Context, ReceiverCreateParams, configmodels.Receiver, consumer.TracesConsumer) (TraceReceiver, error) {
+func (f *TestReceiverFactory) CreateTracesReceiver(context.Context, ReceiverCreateParams, configmodels.Receiver, consumer.TracesConsumer) (TracesReceiver, error) {
 	return nil, configerror.ErrDataTypeIsNotSupported
 }
 

exporter/exporterhelper/factory.go

@@ -48,7 +48,7 @@ type factory struct {
 	createLogsExporter    CreateLogsExporter
 }
 
-// WithTraces overrides the default "error not supported" implementation for CreateTraceReceiver.
+// WithTraces overrides the default "error not supported" implementation for CreateTracesReceiver.
 func WithTraces(createTraceExporter CreateTraceExporter) FactoryOption {
 	return func(o *factory) {
 		o.createTraceExporter = createTraceExporter

exporter/fileexporter/factory.go

@@ -95,6 +95,6 @@ func createExporter(config configmodels.Exporter) (*fileExporter, error) {
 
 // This is the map of already created File exporters for particular configurations.
 // We maintain this map because the Factory is asked trace and metric receivers separately
-// when it gets CreateTraceReceiver() and CreateMetricsReceiver() but they must not
+// when it gets CreateTracesReceiver() and CreateMetricsReceiver() but they must not
 // create separate objects, they must use one Receiver object per configuration.
 var exporters = map[*Config]*fileExporter{}

exporter/opencensusexporter/opencensus_test.go

@@ -40,7 +40,7 @@ func TestSendTraces(t *testing.T) {
 	endpoint := testutil.GetAvailableLocalAddress(t)
 	rCfg.GRPCServerSettings.NetAddr.Endpoint = endpoint
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	recv, err := rFactory.CreateTraceReceiver(context.Background(), params, rCfg, sink)
+	recv, err := rFactory.CreateTracesReceiver(context.Background(), params, rCfg, sink)
 	assert.NoError(t, err)
 	assert.NoError(t, recv.Start(context.Background(), componenttest.NewNopHost()))
 	t.Cleanup(func() {

exporter/otlphttpexporter/otlp_test.go

@@ -278,7 +278,7 @@ func createExporterConfig(baseURL string, defaultCfg configmodels.Exporter) *Con
 func startTraceReceiver(t *testing.T, addr string, next consumer.TracesConsumer) {
 	factory := otlpreceiver.NewFactory()
 	cfg := createReceiverConfig(addr, factory.CreateDefaultConfig())
-	recv, err := factory.CreateTraceReceiver(context.Background(), component.ReceiverCreateParams{Logger: zap.NewNop()}, cfg, next)
+	recv, err := factory.CreateTracesReceiver(context.Background(), component.ReceiverCreateParams{Logger: zap.NewNop()}, cfg, next)
 	require.NoError(t, err)
 	startAndCleanup(t, recv)
 }

receiver/hostmetricsreceiver/factory_test.go

@@ -41,7 +41,7 @@ func TestCreateReceiver(t *testing.T) {
 	factory := NewFactory()
 	cfg := factory.CreateDefaultConfig()
 
-	tReceiver, err := factory.CreateTraceReceiver(context.Background(), creationParams, cfg, nil)
+	tReceiver, err := factory.CreateTracesReceiver(context.Background(), creationParams, cfg, nil)
 
 	assert.Equal(t, err, configerror.ErrDataTypeIsNotSupported)
 	assert.Nil(t, tReceiver)

receiver/jaegerreceiver/factory.go

@@ -144,7 +144,7 @@ func createTraceReceiver(
 	params component.ReceiverCreateParams,
 	cfg configmodels.Receiver,
 	nextConsumer consumer.TracesConsumer,
-) (component.TraceReceiver, error) {
+) (component.TracesReceiver, error) {
 
 	// Convert settings in the source config to configuration struct
 	// that Jaeger receiver understands.

receiver/jaegerreceiver/factory_test.go

@@ -56,7 +56,7 @@ func TestCreateReceiver(t *testing.T) {
 		},
 	}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	tReceiver, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	tReceiver, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 	assert.NoError(t, err, "receiver creation failed")
 	assert.NotNil(t, tReceiver, "receiver creation failed")
 
@@ -77,7 +77,7 @@ func TestCreateDefaultGRPCEndpoint(t *testing.T) {
 		},
 	}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	r, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	r, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 
 	assert.NoError(t, err, "unexpected error creating receiver")
 	assert.Equal(t, 14250, r.(*jReceiver).config.CollectorGRPCPort, "grpc port should be default")
@@ -101,7 +101,7 @@ func TestCreateTLSGPRCEndpoint(t *testing.T) {
 	}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
 
-	_, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	_, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 	assert.NoError(t, err, "tls-enabled receiver creation failed")
 }
 
@@ -113,7 +113,7 @@ func TestCreateInvalidHTTPEndpoint(t *testing.T) {
 		Endpoint: defaultHTTPBindEndpoint,
 	}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	r, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	r, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 
 	assert.NoError(t, err, "unexpected error creating receiver")
 	assert.Equal(t, 14268, r.(*jReceiver).config.CollectorHTTPPort, "http port should be default")
@@ -127,7 +127,7 @@ func TestCreateInvalidThriftBinaryEndpoint(t *testing.T) {
 		Endpoint: defaultThriftBinaryBindEndpoint,
 	}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	r, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	r, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 
 	assert.NoError(t, err, "unexpected error creating receiver")
 	assert.Equal(t, 6832, r.(*jReceiver).config.AgentBinaryThriftPort, "thrift port should be default")
@@ -141,7 +141,7 @@ func TestCreateInvalidThriftCompactEndpoint(t *testing.T) {
 		Endpoint: defaultThriftCompactBindEndpoint,
 	}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	r, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	r, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 
 	assert.NoError(t, err, "unexpected error creating receiver")
 	assert.Equal(t, 6831, r.(*jReceiver).config.AgentCompactThriftPort, "thrift port should be default")
@@ -157,7 +157,7 @@ func TestDefaultAgentRemoteSamplingEndpointAndPort(t *testing.T) {
 	}
 	rCfg.RemoteSampling = &RemoteSamplingConfig{}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	r, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	r, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 
 	assert.NoError(t, err, "create trace receiver should not error")
 	assert.Equal(t, defaultGRPCBindEndpoint, r.(*jReceiver).config.RemoteSamplingClientSettings.Endpoint)
@@ -179,7 +179,7 @@ func TestAgentRemoteSamplingEndpoint(t *testing.T) {
 		},
 	}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	r, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	r, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 
 	assert.NoError(t, err, "create trace receiver should not error")
 	assert.Equal(t, endpoint, r.(*jReceiver).config.RemoteSamplingClientSettings.Endpoint)
@@ -194,7 +194,7 @@ func TestCreateNoPort(t *testing.T) {
 		Endpoint: "localhost:",
 	}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	_, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	_, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 	assert.Error(t, err, "receiver creation with no port number must fail")
 }
 
@@ -206,7 +206,7 @@ func TestCreateLargePort(t *testing.T) {
 		Endpoint: "localhost:65536",
 	}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	_, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	_, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 	assert.Error(t, err, "receiver creation with too large port number must fail")
 }
 
@@ -222,7 +222,7 @@ func TestCreateInvalidHost(t *testing.T) {
 	}
 
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	_, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	_, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 	assert.Error(t, err, "receiver creation with bad hostname must fail")
 }
 
@@ -232,7 +232,7 @@ func TestCreateNoProtocols(t *testing.T) {
 
 	cfg.(*Config).Protocols = Protocols{}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	_, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	_, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 	assert.Error(t, err, "receiver creation with no protocols must fail")
 }
 
@@ -244,7 +244,7 @@ func TestThriftBinaryBadPort(t *testing.T) {
 		Endpoint: "localhost:65536",
 	}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	_, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	_, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 	assert.Error(t, err, "receiver creation with a bad thrift binary port must fail")
 }
 
@@ -257,7 +257,7 @@ func TestThriftCompactBadPort(t *testing.T) {
 	}
 
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	_, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	_, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 	assert.Error(t, err, "receiver creation with a bad thrift compact port must fail")
 }
 
@@ -283,7 +283,7 @@ func TestRemoteSamplingConfigPropagation(t *testing.T) {
 		StrategyFile: strategyFile,
 	}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	r, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	r, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 
 	assert.NoError(t, err, "create trace receiver should not error")
 	assert.Equal(t, endpoint, r.(*jReceiver).config.RemoteSamplingClientSettings.Endpoint)
@@ -305,7 +305,7 @@ func TestRemoteSamplingFileRequiresGRPC(t *testing.T) {
 		StrategyFile: "strategies.json",
 	}
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	_, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
+	_, err := factory.CreateTracesReceiver(context.Background(), params, cfg, nil)
 
 	assert.Error(t, err, "create trace receiver should error")
 }

receiver/jaegerreceiver/trace_receiver.go

@@ -117,7 +117,7 @@ var (
 	}
 )
 
-// newJaegerReceiver creates a TraceReceiver that receives traffic as a Jaeger collector, and
+// newJaegerReceiver creates a TracesReceiver that receives traffic as a Jaeger collector, and
 // also as a Jaeger agent.
 func newJaegerReceiver(
 	instanceName string,

receiver/jaegerreceiver/trace_receiver_test.go

@@ -541,7 +541,7 @@ func TestSamplingStrategiesMutualTLS(t *testing.T) {
 	cfg.Protocols.ThriftHTTP = &confighttp.HTTPServerSettings{
 		Endpoint: fmt.Sprintf("localhost:%d", thriftHTTPPort),
 	}
-	exp, err := factory.CreateTraceReceiver(context.Background(), component.ReceiverCreateParams{Logger: zap.NewNop()}, cfg, consumertest.NewTracesNop())
+	exp, err := factory.CreateTracesReceiver(context.Background(), component.ReceiverCreateParams{Logger: zap.NewNop()}, cfg, consumertest.NewTracesNop())
 	require.NoError(t, err)
 	host := &componenttest.ErrorWaitingHost{}
 	err = exp.Start(context.Background(), host)

receiver/kafkareceiver/factory.go

@@ -97,7 +97,7 @@ func (f *kafkaReceiverFactory) createTraceReceiver(
 	params component.ReceiverCreateParams,
 	cfg configmodels.Receiver,
 	nextConsumer consumer.TracesConsumer,
-) (component.TraceReceiver, error) {
+) (component.TracesReceiver, error) {
 	c := cfg.(*Config)
 	r, err := newReceiver(*c, params, f.unmarshalers, nextConsumer)
 	if err != nil {

receiver/kafkareceiver/factory_test.go

@@ -68,13 +68,13 @@ func TestWithUnmarshallers(t *testing.T) {
 
 	t.Run("custom_encoding", func(t *testing.T) {
 		cfg.Encoding = cum.Encoding()
-		exporter, err := f.CreateTraceReceiver(context.Background(), component.ReceiverCreateParams{}, cfg, nil)
+		exporter, err := f.CreateTracesReceiver(context.Background(), component.ReceiverCreateParams{}, cfg, nil)
 		require.NoError(t, err)
 		require.NotNil(t, exporter)
 	})
 	t.Run("default_encoding", func(t *testing.T) {
 		cfg.Encoding = new(otlpProtoUnmarshaller).Encoding()
-		exporter, err := f.CreateTraceReceiver(context.Background(), component.ReceiverCreateParams{}, cfg, nil)
+		exporter, err := f.CreateTracesReceiver(context.Background(), component.ReceiverCreateParams{}, cfg, nil)
 		require.NoError(t, err)
 		assert.NotNil(t, exporter)
 	})

receiver/opencensusreceiver/factory.go

@@ -60,7 +60,7 @@ func createTraceReceiver(
 	_ component.ReceiverCreateParams,
 	cfg configmodels.Receiver,
 	nextConsumer consumer.TracesConsumer,
-) (component.TraceReceiver, error) {
+) (component.TracesReceiver, error) {
 	r, err := createReceiver(cfg)
 	if err != nil {
 		return nil, err
@@ -116,6 +116,6 @@ func createReceiver(cfg configmodels.Receiver) (*ocReceiver, error) {
 
 // This is the map of already created OpenCensus receivers for particular configurations.
 // We maintain this map because the Factory is asked trace and metric receivers separately
-// when it gets CreateTraceReceiver() and CreateMetricsReceiver() but they must not
+// when it gets CreateTracesReceiver() and CreateMetricsReceiver() but they must not
 // create separate objects, they must use one ocReceiver object per configuration.
 var receivers = map[*Config]*ocReceiver{}

receiver/opencensusreceiver/factory_test.go

@@ -113,7 +113,7 @@ func TestCreateTraceReceiver(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			tr, err := createTraceReceiver(ctx, params, tt.cfg, consumertest.NewTracesNop())
 			if (err != nil) != tt.wantErr {
-				t.Errorf("factory.CreateTraceReceiver() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("factory.CreateTracesReceiver() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if tr != nil {

receiver/otlpreceiver/factory.go

@@ -114,13 +114,13 @@ func customUnmarshaler(componentViperSection *viper.Viper, intoCfg interface{})
 	return nil
 }
 
-// CreateTraceReceiver creates a  trace receiver based on provided config.
+// CreateTracesReceiver creates a  trace receiver based on provided config.
 func createTraceReceiver(
 	ctx context.Context,
 	_ component.ReceiverCreateParams,
 	cfg configmodels.Receiver,
 	nextConsumer consumer.TracesConsumer,
-) (component.TraceReceiver, error) {
+) (component.TracesReceiver, error) {
 	r, err := createReceiver(cfg)
 	if err != nil {
 		return nil, err
@@ -188,6 +188,6 @@ func createReceiver(cfg configmodels.Receiver) (*otlpReceiver, error) {
 
 // This is the map of already created OTLP receivers for particular configurations.
 // We maintain this map because the Factory is asked trace and metric receivers separately
-// when it gets CreateTraceReceiver() and CreateMetricsReceiver() but they must not
+// when it gets CreateTracesReceiver() and CreateMetricsReceiver() but they must not
 // create separate objects, they must use one otlpReceiver object per configuration.
 var receivers = map[*Config]*otlpReceiver{}