chore: fix some naming issues

pkg/sparrow/controller.go

@@ -36,18 +36,18 @@ import (
 // ChecksController is responsible for managing checks.
 type ChecksController struct {
 	db      db.DB
-	metrics metrics.Metrics
+	metrics metrics.Provider
 	checks  runtime.Checks
 	cResult chan checks.ResultDTO
 	cErr    chan error
 	done    chan struct{}
 }
 
 // NewChecksController creates a new ChecksController.
-func NewChecksController(dbase db.DB, mtrcs metrics.Metrics) *ChecksController {
+func NewChecksController(dbase db.DB, m metrics.Provider) *ChecksController {
 	return &ChecksController{
 		db:      dbase,
-		metrics: mtrcs,
+		metrics: m,
 		checks:  runtime.Checks{},
 		cResult: make(chan checks.ResultDTO, 8), //nolint:mnd // Buffered channel to avoid blocking the checks
 		cErr:    make(chan error, 1),

pkg/sparrow/controller_test.go

@@ -42,7 +42,7 @@ func TestRun_CheckRunError(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cc := NewChecksController(db.NewInMemory(), metrics.NewMetrics(metrics.Config{}))
+	cc := NewChecksController(db.NewInMemory(), metrics.New(metrics.Config{}))
 	mockCheck := &checks.CheckMock{
 		NameFunc: func() string { return "mockCheck" },
 		RunFunc: func(ctx context.Context, cResult chan checks.ResultDTO) error {
@@ -82,7 +82,7 @@ func TestRun_CheckRunError(t *testing.T) {
 func TestRun_ContextCancellation(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 
-	cc := NewChecksController(db.NewInMemory(), metrics.NewMetrics(metrics.Config{}))
+	cc := NewChecksController(db.NewInMemory(), metrics.New(metrics.Config{}))
 
 	done := make(chan struct{})
 	go func() {
@@ -206,7 +206,7 @@ func TestChecksController_Reconcile(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			cc := NewChecksController(db.NewInMemory(), metrics.NewMetrics(metrics.Config{}))
+			cc := NewChecksController(db.NewInMemory(), metrics.New(metrics.Config{}))
 
 			for _, c := range tt.checks {
 				cc.checks.Add(c)
@@ -244,7 +244,7 @@ func TestChecksController_RegisterCheck(t *testing.T) {
 		{
 			name: "register one check",
 			setup: func() *ChecksController {
-				return NewChecksController(db.NewInMemory(), metrics.NewMetrics(metrics.Config{}))
+				return NewChecksController(db.NewInMemory(), metrics.New(metrics.Config{}))
 			},
 			check: health.NewCheck(),
 		},
@@ -274,7 +274,7 @@ func TestChecksController_UnregisterCheck(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			cc := NewChecksController(db.NewInMemory(), metrics.NewMetrics(metrics.Config{}))
+			cc := NewChecksController(db.NewInMemory(), metrics.New(metrics.Config{}))
 
 			cc.UnregisterCheck(context.Background(), tt.check)
 

pkg/sparrow/metrics/metrics.go

@@ -31,10 +31,10 @@ import (
 	semconv "go.opentelemetry.io/otel/semconv/v1.24.0"
 )
 
-var _ Metrics = &metrics{}
+var _ Provider = (*manager)(nil)
 
-//go:generate moq -out metrics_moq.go . Metrics
-type Metrics interface {
+//go:generate moq -out metrics_moq.go . Provider
+type Provider interface {
 	// GetRegistry returns the prometheus registry instance
 	// containing the registered prometheus collectors
 	GetRegistry() *prometheus.Registry
@@ -44,34 +44,34 @@ type Metrics interface {
 	Shutdown(ctx context.Context) error
 }
 
-type metrics struct {
+type manager struct {
 	config   Config
 	registry *prometheus.Registry
 	tp       *sdktrace.TracerProvider
 }
 
-// NewMetrics initializes the metrics and returns the PrometheusMetrics
-func NewMetrics(config Config) Metrics {
+// New initializes the metrics and returns the PrometheusMetrics
+func New(config Config) Provider {
 	registry := prometheus.NewRegistry()
 
 	registry.MustRegister(
 		collectors.NewGoCollector(),
 		collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}),
 	)
 
-	return &metrics{
+	return &manager{
 		config:   config,
 		registry: registry,
 	}
 }
 
 // GetRegistry returns the registry to register prometheus metrics
-func (m *metrics) GetRegistry() *prometheus.Registry {
+func (m *manager) GetRegistry() *prometheus.Registry {
 	return m.registry
 }
 
 // InitTracing initializes the OpenTelemetry tracing
-func (m *metrics) InitTracing(ctx context.Context) error {
+func (m *manager) InitTracing(ctx context.Context) error {
 	log := logger.FromContext(ctx)
 	res, err := resource.New(ctx,
 		resource.WithHost(),
@@ -107,13 +107,13 @@ func (m *metrics) InitTracing(ctx context.Context) error {
 }
 
 // Shutdown closes the metrics and tracing
-func (m *metrics) Shutdown(ctx context.Context) error {
+func (m *manager) Shutdown(ctx context.Context) error {
 	log := logger.FromContext(ctx)
 	if m.tp != nil {
 		err := m.tp.Shutdown(ctx)
 		if err != nil {
 			log.ErrorContext(ctx, "Failed to shutdown tracer provider", "error", err)
-			return fmt.Errorf("failed to shutdown tracer provider: %v", err)
+			return fmt.Errorf("failed to shutdown tracer provider: %w", err)
 		}
 	}
 

pkg/sparrow/metrics/metrics_test.go

@@ -29,26 +29,21 @@ import (
 )
 
 func TestPrometheusMetrics_GetRegistry(t *testing.T) {
-	type fields struct {
-		registry *prometheus.Registry
-	}
 	tests := []struct {
-		name   string
-		fields fields
-		want   *prometheus.Registry
+		name     string
+		registry *prometheus.Registry
+		want     *prometheus.Registry
 	}{
 		{
-			name: "simple registry",
-			fields: fields{
-				registry: prometheus.NewRegistry(),
-			},
-			want: prometheus.NewRegistry(),
+			name:     "simple registry",
+			registry: prometheus.NewRegistry(),
+			want:     prometheus.NewRegistry(),
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			m := &metrics{
-				registry: tt.fields.registry,
+			m := &manager{
+				registry: tt.registry,
 			}
 			if got := m.GetRegistry(); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("PrometheusMetrics.GetRegistry() = %v, want %v", got, tt.want)
@@ -58,15 +53,15 @@ func TestPrometheusMetrics_GetRegistry(t *testing.T) {
 }
 
 func TestNewMetrics(t *testing.T) {
-	testMetrics := NewMetrics(Config{})
+	testMetrics := New(Config{})
 	testGauge := prometheus.NewGauge(
 		prometheus.GaugeOpts{
 			Name: "TEST_GAUGE",
 		},
 	)
 
 	t.Run("Register a collector", func(t *testing.T) {
-		testMetrics.(*metrics).registry.MustRegister(
+		testMetrics.(*manager).registry.MustRegister(
 			testGauge,
 		)
 	})
@@ -126,7 +121,7 @@ func TestMetrics_InitTracing(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			m := NewMetrics(tt.config)
+			m := New(tt.config)
 			if err := m.InitTracing(context.Background()); (err != nil) != tt.wantErr {
 				t.Errorf("Metrics.InitTracing() error = %v", err)
 			}

pkg/sparrow/run.go

@@ -51,7 +51,7 @@ type Sparrow struct {
 	// tarMan is the target manager that is used to manage global targets
 	tarMan targets.TargetManager
 	// metrics is used to collect metrics
-	metrics metrics.Metrics
+	metrics metrics.Provider
 	// controller is used to manage the checks
 	controller *ChecksController
 	// cRuntime is used to signal that the runtime configuration has changed
@@ -66,15 +66,15 @@ type Sparrow struct {
 
 // New creates a new sparrow from a given configfile
 func New(cfg *config.Config) *Sparrow {
-	mtrcs := metrics.NewMetrics(cfg.Telemetry)
+	m := metrics.New(cfg.Telemetry)
 	dbase := db.NewInMemory()
 
 	sparrow := &Sparrow{
 		config:     cfg,
 		db:         dbase,
 		api:        api.New(cfg.Api),
-		metrics:    mtrcs,
-		controller: NewChecksController(dbase, mtrcs),
+		metrics:    m,
+		controller: NewChecksController(dbase, m),
 		cRuntime:   make(chan runtime.Config, 1),
 		cErr:       make(chan error, 1),
 		cDone:      make(chan struct{}, 1),