diff --git a/CHANGELOG.md b/CHANGELOG.md
index fe1aa6db5d8..96e00ad2f6b 100644
--- a/CHANGELOG.md
+++ b/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
 
diff --git a/component/componenttest/example_factories.go b/component/componenttest/example_factories.go
index 32f309efe48..ea66b53766b 100644
--- a/component/componenttest/example_factories.go
+++ b/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
 }
diff --git a/component/receiver.go b/component/receiver.go
index 20cc138762c..a0cd40dc889 100644
--- a/component/receiver.go
+++ b/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
diff --git a/component/receiver_test.go b/component/receiver_test.go
index a05e4cb6075..ee844afd4c2 100644
--- a/component/receiver_test.go
+++ b/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
 }
 
diff --git a/exporter/exporterhelper/factory.go b/exporter/exporterhelper/factory.go
index 4e907130abf..2cbe146df57 100644
--- a/exporter/exporterhelper/factory.go
+++ b/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
diff --git a/exporter/fileexporter/factory.go b/exporter/fileexporter/factory.go
index 5fefe86e205..5ac892a901b 100644
--- a/exporter/fileexporter/factory.go
+++ b/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{}
diff --git a/exporter/opencensusexporter/opencensus_test.go b/exporter/opencensusexporter/opencensus_test.go
index a5ffdb13535..07178aa7dad 100644
--- a/exporter/opencensusexporter/opencensus_test.go
+++ b/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() {
diff --git a/exporter/otlphttpexporter/otlp_test.go b/exporter/otlphttpexporter/otlp_test.go
index 3e939bb1be4..eb5ab1f1417 100644
--- a/exporter/otlphttpexporter/otlp_test.go
+++ b/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)
 }
diff --git a/receiver/hostmetricsreceiver/factory_test.go b/receiver/hostmetricsreceiver/factory_test.go
index 062356180e6..01c68000bb2 100644
--- a/receiver/hostmetricsreceiver/factory_test.go
+++ b/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)
diff --git a/receiver/jaegerreceiver/factory.go b/receiver/jaegerreceiver/factory.go
index 8b1c2789197..63bab9078e4 100644
--- a/receiver/jaegerreceiver/factory.go
+++ b/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.
diff --git a/receiver/jaegerreceiver/factory_test.go b/receiver/jaegerreceiver/factory_test.go
index cbb56a7f160..b143b746e76 100644
--- a/receiver/jaegerreceiver/factory_test.go
+++ b/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")
 }
diff --git a/receiver/jaegerreceiver/trace_receiver.go b/receiver/jaegerreceiver/trace_receiver.go
index 3d30fcfb2a2..8dfd37add62 100644
--- a/receiver/jaegerreceiver/trace_receiver.go
+++ b/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,
diff --git a/receiver/jaegerreceiver/trace_receiver_test.go b/receiver/jaegerreceiver/trace_receiver_test.go
index 6800ce38dcf..c319efc7274 100644
--- a/receiver/jaegerreceiver/trace_receiver_test.go
+++ b/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)
diff --git a/receiver/kafkareceiver/factory.go b/receiver/kafkareceiver/factory.go
index 762c70e2ea5..f6cd6ee65ad 100644
--- a/receiver/kafkareceiver/factory.go
+++ b/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 {
diff --git a/receiver/kafkareceiver/factory_test.go b/receiver/kafkareceiver/factory_test.go
index c094815bbb0..3922cbfe3b4 100644
--- a/receiver/kafkareceiver/factory_test.go
+++ b/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)
 	})
diff --git a/receiver/opencensusreceiver/factory.go b/receiver/opencensusreceiver/factory.go
index 7116d4f7086..484e37dcbc4 100644
--- a/receiver/opencensusreceiver/factory.go
+++ b/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{}
diff --git a/receiver/opencensusreceiver/factory_test.go b/receiver/opencensusreceiver/factory_test.go
index bf9d1293dba..fe70a32e447 100644
--- a/receiver/opencensusreceiver/factory_test.go
+++ b/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 {
diff --git a/receiver/otlpreceiver/factory.go b/receiver/otlpreceiver/factory.go
index 4ccbdee42eb..60659cd6ee0 100644
--- a/receiver/otlpreceiver/factory.go
+++ b/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{}
diff --git a/receiver/otlpreceiver/factory_test.go b/receiver/otlpreceiver/factory_test.go
index 59758d47857..60ea0b9094b 100644
--- a/receiver/otlpreceiver/factory_test.go
+++ b/receiver/otlpreceiver/factory_test.go
@@ -50,7 +50,7 @@ func TestCreateReceiver(t *testing.T) {
 	config.HTTP.Endpoint = testutil.GetAvailableLocalAddress(t)
 
 	creationParams := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	tReceiver, err := factory.CreateTraceReceiver(context.Background(), creationParams, cfg, new(consumertest.TracesSink))
+	tReceiver, err := factory.CreateTracesReceiver(context.Background(), creationParams, cfg, new(consumertest.TracesSink))
 	assert.NotNil(t, tReceiver)
 	assert.NoError(t, err)
 
@@ -131,7 +131,7 @@ func TestCreateTraceReceiver(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			sink := new(consumertest.TracesSink)
-			tr, err := factory.CreateTraceReceiver(ctx, creationParams, tt.cfg, sink)
+			tr, err := factory.CreateTracesReceiver(ctx, creationParams, tt.cfg, sink)
 			assert.NoError(t, err)
 			require.NotNil(t, tr)
 			if tt.wantErr {
diff --git a/receiver/otlpreceiver/otlp_test.go b/receiver/otlpreceiver/otlp_test.go
index 38a78b8de55..f21cb548245 100644
--- a/receiver/otlpreceiver/otlp_test.go
+++ b/receiver/otlpreceiver/otlp_test.go
@@ -749,7 +749,7 @@ func newReceiver(t *testing.T, factory component.ReceiverFactory, cfg *Config, t
 	require.NoError(t, err)
 	if tc != nil {
 		params := component.ReceiverCreateParams{}
-		_, err := factory.CreateTraceReceiver(context.Background(), params, cfg, tc)
+		_, err := factory.CreateTracesReceiver(context.Background(), params, cfg, tc)
 		require.NoError(t, err)
 	}
 	if mc != nil {
diff --git a/receiver/receiverhelper/factory.go b/receiver/receiverhelper/factory.go
index 8284577d0df..206b2777275 100644
--- a/receiver/receiverhelper/factory.go
+++ b/receiver/receiverhelper/factory.go
@@ -59,8 +59,8 @@ func WithLogs(createLogsReceiver CreateLogsReceiver) FactoryOption {
 // CreateDefaultConfig is the equivalent of component.ReceiverFactory.CreateDefaultConfig()
 type CreateDefaultConfig func() configmodels.Receiver
 
-// CreateTraceReceiver is the equivalent of component.ReceiverFactory.CreateTraceReceiver()
-type CreateTraceReceiver func(context.Context, component.ReceiverCreateParams, configmodels.Receiver, consumer.TracesConsumer) (component.TraceReceiver, error)
+// CreateTraceReceiver is the equivalent of component.ReceiverFactory.CreateTracesReceiver()
+type CreateTraceReceiver func(context.Context, component.ReceiverCreateParams, configmodels.Receiver, consumer.TracesConsumer) (component.TracesReceiver, error)
 
 // CreateMetricsReceiver is the equivalent of component.ReceiverFactory.CreateMetricsReceiver()
 type CreateMetricsReceiver func(context.Context, component.ReceiverCreateParams, configmodels.Receiver, consumer.MetricsConsumer) (component.MetricsReceiver, error)
@@ -108,12 +108,12 @@ func (f *factory) CreateDefaultConfig() configmodels.Receiver {
 	return f.createDefaultConfig()
 }
 
-// CreateTraceReceiver creates a component.TraceReceiver based on this config.
-func (f *factory) CreateTraceReceiver(
+// CreateTraceReceiver creates a component.TracesReceiver based on this config.
+func (f *factory) CreateTracesReceiver(
 	ctx context.Context,
 	params component.ReceiverCreateParams,
 	cfg configmodels.Receiver,
-	nextConsumer consumer.TracesConsumer) (component.TraceReceiver, error) {
+	nextConsumer consumer.TracesConsumer) (component.TracesReceiver, error) {
 	if f.createTraceReceiver != nil {
 		return f.createTraceReceiver(ctx, params, cfg, nextConsumer)
 	}
diff --git a/receiver/receiverhelper/factory_test.go b/receiver/receiverhelper/factory_test.go
index ce624d7a3ec..a215cd6d060 100644
--- a/receiver/receiverhelper/factory_test.go
+++ b/receiver/receiverhelper/factory_test.go
@@ -42,7 +42,7 @@ func TestNewFactory(t *testing.T) {
 	assert.EqualValues(t, defaultCfg, factory.CreateDefaultConfig())
 	_, ok := factory.(component.ConfigUnmarshaler)
 	assert.False(t, ok)
-	_, err := factory.CreateTraceReceiver(context.Background(), component.ReceiverCreateParams{}, defaultCfg, nil)
+	_, err := factory.CreateTracesReceiver(context.Background(), component.ReceiverCreateParams{}, defaultCfg, nil)
 	assert.Error(t, err)
 	_, err = factory.CreateMetricsReceiver(context.Background(), component.ReceiverCreateParams{}, defaultCfg, nil)
 	assert.Error(t, err)
@@ -65,7 +65,7 @@ func TestNewFactory_WithConstructors(t *testing.T) {
 	assert.True(t, ok)
 	assert.Equal(t, errors.New("my error"), fu.Unmarshal(nil, nil))
 
-	_, err := factory.CreateTraceReceiver(context.Background(), component.ReceiverCreateParams{}, defaultCfg, nil)
+	_, err := factory.CreateTracesReceiver(context.Background(), component.ReceiverCreateParams{}, defaultCfg, nil)
 	assert.NoError(t, err)
 
 	_, err = factory.CreateMetricsReceiver(context.Background(), component.ReceiverCreateParams{}, defaultCfg, nil)
@@ -79,7 +79,7 @@ func defaultConfig() configmodels.Receiver {
 	return defaultCfg
 }
 
-func createTraceReceiver(context.Context, component.ReceiverCreateParams, configmodels.Receiver, consumer.TracesConsumer) (component.TraceReceiver, error) {
+func createTraceReceiver(context.Context, component.ReceiverCreateParams, configmodels.Receiver, consumer.TracesConsumer) (component.TracesReceiver, error) {
 	return nil, nil
 }
 
diff --git a/receiver/zipkinreceiver/factory.go b/receiver/zipkinreceiver/factory.go
index 5a3e2a5faf9..a61d1470bc5 100644
--- a/receiver/zipkinreceiver/factory.go
+++ b/receiver/zipkinreceiver/factory.go
@@ -61,7 +61,7 @@ func createTraceReceiver(
 	_ component.ReceiverCreateParams,
 	cfg configmodels.Receiver,
 	nextConsumer consumer.TracesConsumer,
-) (component.TraceReceiver, error) {
+) (component.TracesReceiver, error) {
 	rCfg := cfg.(*Config)
 	return New(rCfg, nextConsumer)
 }
diff --git a/service/builder/receivers_builder.go b/service/builder/receivers_builder.go
index 8a9ca18aca4..48724359f07 100644
--- a/service/builder/receivers_builder.go
+++ b/service/builder/receivers_builder.go
@@ -186,7 +186,7 @@ func (rb *ReceiversBuilder) attachReceiverToPipelines(
 	switch dataType {
 	case configmodels.TracesDataType:
 		junction := buildFanoutTraceConsumer(builtPipelines)
-		createdReceiver, err = factory.CreateTraceReceiver(ctx, creationParams, config, junction)
+		createdReceiver, err = factory.CreateTracesReceiver(ctx, creationParams, config, junction)
 
 	case configmodels.MetricsDataType:
 		junction := buildFanoutMetricConsumer(builtPipelines)
@@ -220,11 +220,11 @@ func (rb *ReceiversBuilder) attachReceiverToPipelines(
 	if rcv.receiver != nil {
 		// The receiver was previously created for this config. This can happen if the
 		// same receiver type supports more than one data type. In that case we expect
-		// that CreateTraceReceiver and CreateMetricsReceiver return the same value.
+		// that CreateTracesReceiver and CreateMetricsReceiver return the same value.
 		if rcv.receiver != createdReceiver {
 			return fmt.Errorf(
 				"factory for %q is implemented incorrectly: "+
-					"CreateTraceReceiver and CreateMetricsReceiver must return the same "+
+					"CreateTracesReceiver and CreateMetricsReceiver must return the same "+
 					"receiver pointer when creating receivers of different data types",
 				config.Name(),
 			)
diff --git a/testbed/testbed/receivers.go b/testbed/testbed/receivers.go
index b4d905cbe92..bcbd38fa54e 100644
--- a/testbed/testbed/receivers.go
+++ b/testbed/testbed/receivers.go
@@ -83,7 +83,7 @@ func (mb *DataReceiverBase) GetExporters() map[configmodels.DataType]map[configm
 // OCDataReceiver implements OpenCensus format receiver.
 type OCDataReceiver struct {
 	DataReceiverBase
-	traceReceiver   component.TraceReceiver
+	traceReceiver   component.TracesReceiver
 	metricsReceiver component.MetricsReceiver
 }
 
@@ -105,7 +105,7 @@ func (or *OCDataReceiver) Start(tc consumer.TracesConsumer, mc consumer.MetricsC
 	cfg.NetAddr = confignet.NetAddr{Endpoint: fmt.Sprintf("localhost:%d", or.Port), Transport: "tcp"}
 	var err error
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	if or.traceReceiver, err = factory.CreateTraceReceiver(context.Background(), params, cfg, tc); err != nil {
+	if or.traceReceiver, err = factory.CreateTracesReceiver(context.Background(), params, cfg, tc); err != nil {
 		return err
 	}
 	if or.metricsReceiver, err = factory.CreateMetricsReceiver(context.Background(), params, cfg, mc); err != nil {
@@ -142,7 +142,7 @@ func (or *OCDataReceiver) ProtocolName() string {
 // JaegerDataReceiver implements Jaeger format receiver.
 type JaegerDataReceiver struct {
 	DataReceiverBase
-	receiver component.TraceReceiver
+	receiver component.TracesReceiver
 }
 
 var _ DataReceiver = (*JaegerDataReceiver)(nil)
@@ -162,7 +162,7 @@ func (jr *JaegerDataReceiver) Start(tc consumer.TracesConsumer, _ consumer.Metri
 	}
 	var err error
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	jr.receiver, err = factory.CreateTraceReceiver(context.Background(), params, cfg, tc)
+	jr.receiver, err = factory.CreateTracesReceiver(context.Background(), params, cfg, tc)
 	if err != nil {
 		return err
 	}
@@ -189,7 +189,7 @@ func (jr *JaegerDataReceiver) ProtocolName() string {
 // OTLPDataReceiver implements OTLP format receiver.
 type OTLPDataReceiver struct {
 	DataReceiverBase
-	traceReceiver   component.TraceReceiver
+	traceReceiver   component.TracesReceiver
 	metricsReceiver component.MetricsReceiver
 	logReceiver     component.LogsReceiver
 }
@@ -213,7 +213,7 @@ func (or *OTLPDataReceiver) Start(tc consumer.TracesConsumer, mc consumer.Metric
 	cfg.HTTP = nil
 	var err error
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
-	if or.traceReceiver, err = factory.CreateTraceReceiver(context.Background(), params, cfg, tc); err != nil {
+	if or.traceReceiver, err = factory.CreateTracesReceiver(context.Background(), params, cfg, tc); err != nil {
 		return err
 	}
 	if or.metricsReceiver, err = factory.CreateMetricsReceiver(context.Background(), params, cfg, mc); err != nil {
@@ -257,7 +257,7 @@ func (or *OTLPDataReceiver) ProtocolName() string {
 // ZipkinDataReceiver implements Zipkin format receiver.
 type ZipkinDataReceiver struct {
 	DataReceiverBase
-	receiver component.TraceReceiver
+	receiver component.TracesReceiver
 }
 
 var _ DataReceiver = (*ZipkinDataReceiver)(nil)
@@ -276,7 +276,7 @@ func (zr *ZipkinDataReceiver) Start(tc consumer.TracesConsumer, _ consumer.Metri
 
 	params := component.ReceiverCreateParams{Logger: zap.NewNop()}
 	var err error
-	zr.receiver, err = factory.CreateTraceReceiver(context.Background(), params, cfg, tc)
+	zr.receiver, err = factory.CreateTracesReceiver(context.Background(), params, cfg, tc)
 
 	if err != nil {
 		return err