Fix golangci lint errors

internal/cli/metrics_counter.go

@@ -64,7 +64,7 @@ func generateMetricsCounterAction(c *cli.Context) error {
 
 	provider := createMeterProvider(reader, metricsCfg)
 
-	metrics.SimulateCounter(ctx, *provider, metricsCfg, logger)
+	metrics.SimulateCounter(ctx, provider, metricsCfg, logger)
 
 	return nil
 }

internal/cli/metrics_histogram.go

@@ -64,7 +64,7 @@ func generateMetricsHistogramAction(c *cli.Context) error {
 
 	provider := createMeterProvider(reader, metricsCfg)
 
-	metrics.SimulateHistogram(ctx, *provider, metricsCfg, logger)
+	metrics.SimulateHistogram(ctx, provider, metricsCfg, logger)
 
 	return nil
 }

internal/cli/metrics_up_down_counter.go

@@ -64,7 +64,7 @@ func generateMetricsUpDownCounterAction(c *cli.Context) error {
 
 	provider := createMeterProvider(reader, metricsCfg)
 
-	metrics.SimulateUpDownCounter(ctx, *provider, metricsCfg, logger)
+	metrics.SimulateUpDownCounter(ctx, provider, metricsCfg, logger)
 
 	return nil
 }

internal/metrics/counter.go

@@ -11,13 +11,16 @@ import (
 )
 
 // Counter demonstrates how to measure non-decreasing int64s
-func SimulateCounter(ctx context.Context, mp metric.MeterProvider, conf *Config, logger *zap.Logger) {
+func SimulateCounter(ctx context.Context, mp *metric.MeterProvider, conf *Config, logger *zap.Logger) {
 	c := *conf
-	run(conf, logger, counter(mp, c, logger), &mp)
+	err := run(conf, logger, counter(mp, c, logger))
+	if err != nil {
+		logger.Error("failed to run counter", zap.Error(err))
+	}
 }
 
 // counter generates a counter metric
-func counter(mp metric.MeterProvider, c Config, logger *zap.Logger) WorkerFunc {
+func counter(mp *metric.MeterProvider, c Config, logger *zap.Logger) WorkerFunc {
 	return func(ctx context.Context) {
 		name := fmt.Sprintf("%v.metrics.counter", c.ServiceName)
 		logger.Debug("generating counter", zap.String("name", name))

internal/metrics/histogram.go

@@ -12,13 +12,16 @@ import (
 )
 
 // Histogram demonstrates how to record a distribution of individual values
-func SimulateHistogram(ctx context.Context, mp metric.MeterProvider, conf *Config, logger *zap.Logger) {
+func SimulateHistogram(ctx context.Context, mp *metric.MeterProvider, conf *Config, logger *zap.Logger) {
 	c := *conf
-	run(conf, logger, histogram(mp, c, logger), &mp)
+	err := run(conf, logger, histogram(mp, c, logger))
+	if err != nil {
+		logger.Error("failed to run histogram", zap.Error(err))
+	}
 }
 
 // histogram generates a histogram metric
-func histogram(mp metric.MeterProvider, c Config, logger *zap.Logger) WorkerFunc {
+func histogram(mp *metric.MeterProvider, c Config, logger *zap.Logger) WorkerFunc {
 	return func(ctx context.Context) {
 		name := fmt.Sprintf("%v.metrics.histogram", c.ServiceName)
 		durRecorder, _ := mp.Meter(c.ServiceName).Int64Histogram(

internal/metrics/runner.go

@@ -2,14 +2,16 @@ package metrics
 
 import (
 	"context"
+	"fmt"
 
-	"go.opentelemetry.io/otel/sdk/metric"
 	"go.uber.org/zap"
 )
 
 // run is a function that runs a worker
-func run(c *Config, logger *zap.Logger, workerFunc WorkerFunc, mp *metric.MeterProvider) error {
+func run(c *Config, logger *zap.Logger, workerFunc WorkerFunc) error {
 	w := NewWorker(c, logger)
-	w.Run(context.Background(), workerFunc)
+	if err := w.Run(context.Background(), workerFunc); err != nil {
+		return fmt.Errorf("failed to run worker: %w", err)
+	}
 	return nil
 }

internal/metrics/up_down_counter.go

@@ -12,13 +12,16 @@ import (
 )
 
 // SimulateUpDownCounter demonstrates how to measure numbers that can go up and down
-func SimulateUpDownCounter(ctx context.Context, mp metric.MeterProvider, conf *Config, logger *zap.Logger) {
+func SimulateUpDownCounter(ctx context.Context, mp *metric.MeterProvider, conf *Config, logger *zap.Logger) {
 	c := *conf
-	run(conf, logger, upDownCounter(mp, c, logger), &mp)
+	err := run(conf, logger, upDownCounter(mp, c, logger))
+	if err != nil {
+		logger.Error("failed to run up-down-counter", zap.Error(err))
+	}
 }
 
 // upDownCounter generates a up down counter metric
-func upDownCounter(mp metric.MeterProvider, c Config, logger *zap.Logger) WorkerFunc {
+func upDownCounter(mp *metric.MeterProvider, c Config, logger *zap.Logger) WorkerFunc {
 	return func(ctx context.Context) {
 		name := fmt.Sprintf("%v.metrics.up_down_counter", c.ServiceName)
 		counter, _ := mp.Meter(c.ServiceName).Int64UpDownCounter(

internal/metrics/worker.go

@@ -2,6 +2,7 @@ package metrics
 
 import (
 	"context"
+	"fmt"
 	"sync"
 	"time"
 
@@ -12,7 +13,7 @@ import (
 
 type WorkerFunc func(ctx context.Context)
 
-type worker struct {
+type Worker struct {
 	numMetrics     int             // how many metrics the worker has to generate (only when duration==0)
 	totalDuration  time.Duration   // how long to run the test for (overrides `numMetrics`)
 	limitPerSecond rate.Limit      // how many metrics per second to generate
@@ -21,8 +22,8 @@ type worker struct {
 }
 
 // NewWorker creates a new worker
-func NewWorker(c *Config, logger *zap.Logger) *worker {
-	return &worker{
+func NewWorker(c *Config, logger *zap.Logger) *Worker {
+	return &Worker{
 		numMetrics:     c.NumMetrics,
 		totalDuration:  c.TotalDuration,
 		limitPerSecond: rate.Limit(c.Rate),
@@ -32,16 +33,17 @@ func NewWorker(c *Config, logger *zap.Logger) *worker {
 }
 
 // Run runs the worker
-func (w *worker) Run(ctx context.Context, workerFunc WorkerFunc) {
+func (w *Worker) Run(ctx context.Context, workerFunc WorkerFunc) error {
 	if w.totalDuration == 0 {
 		// w.numMetrics = 0
-		w.totalDuration = time.Duration(86400 * time.Second) // 24 hours
+		w.totalDuration = 86400 * time.Second // 24 hours
 	} else if w.numMetrics == 0 {
 		w.logger.Error("either `metrics` or `duration` must be greater than 0")
-		return
+		return fmt.Errorf("either `metrics` or `duration` must be greater than 0")
 	}
 
 	running := atomic.NewBool(true)
+	errChan := make(chan error, 1)
 	for i := 0; i < 1; i++ {
 		w.wg.Add(1)
 
@@ -58,4 +60,12 @@ func (w *worker) Run(ctx context.Context, workerFunc WorkerFunc) {
 		running.Store(false)
 	}
 	w.wg.Wait()
+
+	// Check if there's an error in the error channel
+	select {
+	case err := <-errChan:
+		return err
+	default:
+		return nil
+	}
 }