Switch Jaeger receiver to internal data model

Translation was replicated from existing jaeger -> OC -> internal logic.

receiver/jaegerreceiver/factory.go

@@ -111,9 +111,9 @@ func (f *Factory) CreateDefaultConfig() configmodels.Receiver {
 // CreateTraceReceiver creates a trace receiver based on provided config.
 func (f *Factory) CreateTraceReceiver(
  ctx context.Context,
- logger *zap.Logger,
+ params component.ReceiverCreateParams,
  cfg configmodels.Receiver,
- nextConsumer consumer.TraceConsumerOld,
+ nextConsumer consumer.TraceConsumer,
 ) (component.TraceReceiver, error) {
 
  // Convert settings in the source config to Configuration struct
@@ -130,6 +130,7 @@ func (f *Factory) CreateTraceReceiver(
 
  config := Configuration{}
  var grpcServerOptions []grpc.ServerOption
+ logger := params.Logger
 
  // Set ports
  if protoGRPC != nil && protoGRPC.IsEnabled() {
@@ -213,14 +214,15 @@ func (f *Factory) CreateTraceReceiver(
  }
 
  // Create the receiver.
- return New(rCfg.Name(), &config, nextConsumer, logger)
+ return New(rCfg.Name(), &config, nextConsumer, params)
 }
 
 // CreateMetricsReceiver creates a metrics receiver based on provided config.
 func (f *Factory) CreateMetricsReceiver(
- logger *zap.Logger,
- cfg configmodels.Receiver,
- consumer consumer.MetricsConsumerOld,
+ _ context.Context,
+ _ component.ReceiverCreateParams,
+ _ configmodels.Receiver,
+ _ consumer.MetricsConsumer,
 ) (component.MetricsReceiver, error) {
  return nil, configerror.ErrDataTypeIsNotSupported
 }

receiver/jaegerreceiver/factory_test.go

@@ -22,6 +22,7 @@ import (
  "github.com/stretchr/testify/assert"
  "go.uber.org/zap"
 
+ "github.com/open-telemetry/opentelemetry-collector/component"
  "github.com/open-telemetry/opentelemetry-collector/config"
  "github.com/open-telemetry/opentelemetry-collector/config/configcheck"
  "github.com/open-telemetry/opentelemetry-collector/config/configerror"
@@ -48,11 +49,12 @@ func TestCreateReceiver(t *testing.T) {
  // have to enable at least one protocol for the jaeger receiver to be created
  cfg.(*Config).Protocols[protoGRPC], _ = defaultsForProtocol(protoGRPC)
 
- tReceiver, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ tReceiver, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
  assert.NoError(t, err, "receiver creation failed")
  assert.NotNil(t, tReceiver, "receiver creation failed")
 
- mReceiver, err := factory.CreateMetricsReceiver(zap.NewNop(), cfg, nil)
+ mReceiver, err := factory.CreateMetricsReceiver(context.Background(), params, cfg, nil)
  assert.Equal(t, err, configerror.ErrDataTypeIsNotSupported)
  assert.Nil(t, mReceiver)
 }
@@ -64,7 +66,8 @@ func TestCreateDefaultGRPCEndpoint(t *testing.T) {
  rCfg := cfg.(*Config)
 
  rCfg.Protocols[protoGRPC], _ = defaultsForProtocol(protoGRPC)
- r, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ r, err := factory.CreateTraceReceiver(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")
@@ -77,14 +80,15 @@ func TestCreateTLSGPRCEndpoint(t *testing.T) {
 
  rCfg.Protocols[protoGRPC], _ = defaultsForProtocol(protoGRPC)
  rCfg.Protocols[protoGRPC].TLSCredentials = &receiver.TLSCredentials{}
- _, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ _, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
  assert.Error(t, err, "tls-enabled receiver creation with no credentials must fail")
 
  rCfg.Protocols[protoGRPC].TLSCredentials = &receiver.TLSCredentials{
  CertFile: "./testdata/certificate.pem",
  KeyFile: "./testdata/key.pem",
  }
- _, err = factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ _, err = factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
  assert.NoError(t, err, "tls-enabled receiver creation failed")
 }
 
@@ -94,7 +98,8 @@ func TestCreateInvalidHTTPEndpoint(t *testing.T) {
  rCfg := cfg.(*Config)
 
  rCfg.Protocols[protoThriftHTTP], _ = defaultsForProtocol(protoThriftHTTP)
- r, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ r, err := factory.CreateTraceReceiver(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")
@@ -106,7 +111,8 @@ func TestCreateInvalidThriftBinaryEndpoint(t *testing.T) {
  rCfg := cfg.(*Config)
 
  rCfg.Protocols[protoThriftBinary], _ = defaultsForProtocol(protoThriftBinary)
- r, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ r, err := factory.CreateTraceReceiver(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")
@@ -118,7 +124,8 @@ func TestCreateInvalidThriftCompactEndpoint(t *testing.T) {
  rCfg := cfg.(*Config)
 
  rCfg.Protocols[protoThriftCompact], _ = defaultsForProtocol(protoThriftCompact)
- r, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ r, err := factory.CreateTraceReceiver(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")
@@ -134,7 +141,8 @@ func TestDefaultAgentRemoteSamplingHTTPPort(t *testing.T) {
  rCfg.RemoteSampling = &RemoteSamplingConfig{
  FetchEndpoint: endpoint,
  }
- r, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ r, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
 
  assert.NoError(t, err, "create trace receiver should not error")
  assert.Equal(t, endpoint, r.(*jReceiver).config.RemoteSamplingEndpoint)
@@ -151,7 +159,8 @@ func TestCreateNoPort(t *testing.T) {
  Endpoint: "localhost:",
  },
  }
- _, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ _, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
  assert.Error(t, err, "receiver creation with no port number must fail")
 }
 
@@ -165,7 +174,8 @@ func TestCreateLargePort(t *testing.T) {
  Endpoint: "localhost:65536",
  },
  }
- _, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ _, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
  assert.Error(t, err, "receiver creation with too large port number must fail")
 }
 
@@ -179,7 +189,8 @@ func TestCreateInvalidHost(t *testing.T) {
  Endpoint: "1234",
  },
  }
- _, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ _, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
  assert.Error(t, err, "receiver creation with bad hostname must fail")
 }
 
@@ -190,7 +201,8 @@ func TestCreateNoProtocols(t *testing.T) {
 
  rCfg.Protocols = make(map[string]*receiver.SecureReceiverSettings)
 
- _, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ _, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
  assert.Error(t, err, "receiver creation with no protocols must fail")
 }
 
@@ -205,7 +217,8 @@ func TestThriftBinaryBadPort(t *testing.T) {
  },
  }
 
- _, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ _, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
  assert.Error(t, err, "receiver creation with a bad thrift binary port must fail")
 }
 
@@ -220,7 +233,8 @@ func TestThriftCompactBadPort(t *testing.T) {
  },
  }
 
- _, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ _, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
  assert.Error(t, err, "receiver creation with a bad thrift compact port must fail")
 }
 
@@ -238,7 +252,8 @@ func TestRemoteSamplingConfigPropagation(t *testing.T) {
  HostEndpoint: fmt.Sprintf("localhost:%d", hostPort),
  StrategyFile: strategyFile,
  }
- r, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ r, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
 
  assert.NoError(t, err, "create trace receiver should not error")
  assert.Equal(t, endpoint, r.(*jReceiver).config.RemoteSamplingEndpoint)
@@ -256,7 +271,8 @@ func TestRemoteSamplingFileRequiresGRPC(t *testing.T) {
  rCfg.RemoteSampling = &RemoteSamplingConfig{
  StrategyFile: strategyFile,
  }
- _, err := factory.CreateTraceReceiver(context.Background(), zap.NewNop(), cfg, nil)
+ params := component.ReceiverCreateParams{Logger: zap.NewNop()}
+ _, err := factory.CreateTraceReceiver(context.Background(), params, cfg, nil)
 
  assert.Error(t, err, "create trace receiver should error")
 }