Pass Logger to metric receiver settings

pkg/promotel/README.md

@@ -86,7 +86,7 @@ func main() {
 	exporter, _ := promotel.NewMetricExporter(exporterConfig, logger) 
 	receiverConfig, _ := promotel.NewDefaultReceiverConfig()
     // Fetches metrics data directly from DefaultGatherer without making HTTP requests to 127.0.0.1:8888
-	receiver, _ := promotel.NewMetricReceiver(receiverConfig, prometheus.DefaultGatherer, exporter.Consumer().ConsumeMetrics, logger)
+	receiver, _ := promotel.NewMetricReceiver(receiverConfig, prometheus.DefaultGatherer, exporter.Export, logger)
 	fmt.Println("Starting promotel pipeline")
 	exporter.Start(context.Background())
 	receiver.Start(context.Background())

pkg/promotel/exporter.go

@@ -46,13 +46,9 @@ func (me *metricExporter) Export(ctx context.Context, md pmetric.Metrics) error
 func NewMetricExporter(config ExporterConfig, logger logger.Logger) (MetricExporter, error) {
 	factory := otlpexporter.NewFactory()
 	// Creates a metrics receiver with the context, settings, config, and consumer
-	settings, err := internal.NewExporterSettings()
-	if err != nil {
-		return nil, err
-	}
 	exporter, err := factory.CreateMetrics(
 		context.Background(),
-		settings,
+		internal.NewExporterSettings(logger),
 		config)
 	if err != nil {
 		return nil, err

pkg/promotel/internal/settings.go

@@ -5,26 +5,25 @@ import (
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/exporter"
 	"go.opentelemetry.io/collector/receiver"
-	"go.uber.org/zap"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
 )
 
 var defaultComponentType = component.MustNewType("nop")
 
 // NewReceiverSettings returns a new settings for factory.CreateMetrics function
-func NewReceiverSettings() (receiver.Settings, error) {
-	l, err := zap.NewProduction()
+func NewReceiverSettings(lggr logger.Logger) receiver.Settings {
 	return receiver.Settings{
 		ID:                component.NewIDWithName(defaultComponentType, uuid.NewString()),
-		TelemetrySettings: NewTelemetrySettings(l),
+		TelemetrySettings: NewTelemetrySettings(lggr),
 		BuildInfo:         component.NewDefaultBuildInfo(),
-	}, err
+	}
 }
 
-func NewExporterSettings() (exporter.Settings, error) {
-	l, err := zap.NewProduction()
+func NewExporterSettings(lggr logger.Logger) exporter.Settings {
 	return exporter.Settings{
 		ID:                component.NewIDWithName(defaultComponentType, uuid.NewString()),
-		TelemetrySettings: NewTelemetrySettings(l),
+		TelemetrySettings: NewTelemetrySettings(lggr),
 		BuildInfo:         component.NewDefaultBuildInfo(),
-	}, err
+	}
 }

pkg/promotel/internal/telemetry.go

@@ -7,19 +7,32 @@ import (
 	noopmetric "go.opentelemetry.io/otel/metric/noop"
 	nooptrace "go.opentelemetry.io/otel/trace/noop"
 	"go.uber.org/zap"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
 )
 
 // NewTelemetrySettings returns a new telemetry settings for Create* functions.
-func NewTelemetrySettings(logger *zap.Logger) component.TelemetrySettings {
-	l := zap.NewNop()
-	if logger != nil {
-		l = logger
-	}
+func NewTelemetrySettings(lggr logger.Logger) component.TelemetrySettings {
 	return component.TelemetrySettings{
-		Logger:         l,
+		Logger:         mustZapLogger(lggr),
 		TracerProvider: nooptrace.NewTracerProvider(),
 		MeterProvider:  noopmetric.NewMeterProvider(),
 		MetricsLevel:   configtelemetry.LevelNone,
 		Resource:       pcommon.NewResource(),
 	}
 }
+
+type zapGetter interface {
+	ToZapLogger(lggr logger.Logger) *zap.Logger
+}
+
+func mustZapLogger(lggr logger.Logger) *zap.Logger {
+	if g, ok := lggr.(zapGetter); ok {
+		return g.ToZapLogger(lggr)
+	}
+	l, err := zap.NewProduction()
+	if err != nil {
+		return zap.NewNop()
+	}
+	return l
+}

pkg/promotel/promotel_test.go

@@ -8,7 +8,6 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	dto "github.com/prometheus/client_model/go"
-	"go.opentelemetry.io/collector/consumer"
 	"go.opentelemetry.io/collector/pdata/pmetric"
 	"go.uber.org/zap"
 
@@ -18,9 +17,10 @@ import (
 
 func TestExample(t *testing.T) {
 	var (
-		g         = prometheus.DefaultGatherer
-		r         = prometheus.DefaultRegisterer
-		logger, _ = logger.New()
+		g = prometheus.DefaultGatherer
+		r = prometheus.DefaultRegisterer
+		// todo: use logger.TestObserved
+		logger = logger.Test(t)
 	)
 
 	go reportMetrics(r, logger)
@@ -125,7 +125,7 @@ func startMetricReceiver(g prometheus.Gatherer, r prometheus.Registerer, logger
 
 	// Gather metrics via promotel
 	// MetricReceiver fetches metrics from prometheus.Gatherer, then converts it to OTel format and writes formatted metrics to stdout
-	receiver, err := promotel.NewMetricReceiver(config, g, r, consumer.ConsumeMetricsFunc(next), logger)
+	receiver, err := promotel.NewMetricReceiver(config, g, r, logger, next)
 	if err != nil {
 		logger.Fatal("Failed to create debug metric receiver", zap.Error(err))
 	}

pkg/promotel/receiver.go

@@ -27,6 +27,7 @@ type metricReceiver struct {
 	factory  receiver.Factory
 	host     component.Host
 	receiver receiver.Metrics
+	logger   logger.Logger
 }
 
 func (p *metricReceiver) Start(ctx context.Context) error {
@@ -37,34 +38,30 @@ func (p *metricReceiver) Close() error {
 	return p.receiver.Shutdown(context.Background())
 }
 
-func NewMetricReceiver(config ReceiverConfig, g prometheus.Gatherer, r prometheus.Registerer, consumerFunc consumer.ConsumeMetricsFunc, logger logger.Logger) (Runnable, error) {
+func NewMetricReceiver(config ReceiverConfig, g prometheus.Gatherer, r prometheus.Registerer, logger logger.Logger, next NextFunc) (Runnable, error) {
 	factory := prometheusreceiver.NewFactoryWithOptions(
 		prometheusreceiver.WithGatherer(g),
 		prometheusreceiver.WithRegisterer(r),
 	)
-	settings, err := internal.NewReceiverSettings()
-	if err != nil {
-		return nil, err
-	}
 	// Creates a metrics receiver with the context, settings, config, and consumer
 	receiver, err := factory.CreateMetrics(
 		context.Background(),
-		settings,
+		internal.NewReceiverSettings(logger),
 		config,
-		internal.NewConsumer(consumerFunc))
+		internal.NewConsumer(consumer.ConsumeMetricsFunc(next)))
 	if err != nil {
 		return nil, err
 	}
 	// Creates a no-operation host for the receiver
 	host := internal.NewNopHost()
-	return &metricReceiver{factory, host, receiver}, nil
+	return &metricReceiver{factory, host, receiver, logger}, nil
 }
 
 func NewDebugMetricReceiver(config ReceiverConfig, g prometheus.Gatherer, r prometheus.Registerer, logger logger.Logger) (MetricReceiver, error) {
 	debugExporter := internal.NewDebugExporter(logger)
 	// Creates a no-operation consumer
-	return NewMetricReceiver(config, g, r, func(_ context.Context, md pmetric.Metrics) error {
+	return NewMetricReceiver(config, g, r, logger, func(_ context.Context, md pmetric.Metrics) error {
 		// Writes metrics data to stdout
 		return debugExporter.Export(md)
-	}, logger)
+	})
 }

pkg/promotel/receiver_test.go

@@ -46,7 +46,7 @@ func TestMetricReceiver(t *testing.T) {
 	testConfig, err := promotel.LoadTestConfig(configFile, "withOnlyScrape")
 	require.NoError(t, err)
 	noopConsumerFunc := func(context.Context, pmetric.Metrics) error { return nil }
-	receiver, err := promotel.NewMetricReceiver(testConfig, prometheus.DefaultGatherer, prometheus.DefaultRegisterer, noopConsumerFunc, nil)
+	receiver, err := promotel.NewMetricReceiver(testConfig, prometheus.DefaultGatherer, prometheus.DefaultRegisterer, nil, noopConsumerFunc)
 	require.NoError(t, err)
 	require.NoError(t, receiver.Start(context.Background()))
 	require.NoError(t, receiver.Close())