fix: add missing error handler

cmd/create.go

@@ -49,30 +49,31 @@ cluster provisioning process spinning up the services, and validates the livenes
 
 		hostedZoneName := viper.GetString("aws.hostedzonename")
 
-		// Instantiates a SegmentIO client to send messages to the segment API.
-		segmentIOClient := analytics.New(pkg.SegmentIOWriteKey)
+		var telemetryHandler handlers.TelemetryHandler
+		if globalFlags.UseTelemetry {
+			// Instantiates a SegmentIO client to send messages to the segment API.
+			segmentIOClient := analytics.New(pkg.SegmentIOWriteKey)
+
+			// SegmentIO library works with queue that is based on timing, we explicit close the http client connection
+			// to force flush in case there is still some pending message in the SegmentIO library queue.
+			defer func(segmentIOClient analytics.Client) {
+				err := segmentIOClient.Close()
+				if err != nil {
+					log.Println(err)
+				}
+			}(segmentIOClient)
 
-		// SegmentIO library works with queue that is based on timing, we explicit close the http client connection
-		// to force flush in case there is still some pending message in the SegmentIO library queue.
-		defer func(segmentIOClient analytics.Client) {
-			err := segmentIOClient.Close()
+			telemetryDomain, err := domain.NewTelemetry(
+				pkg.MetricMgmtClusterInstallStarted,
+				hostedZoneName,
+				configs.K1Version,
+			)
 			if err != nil {
 				log.Println(err)
 			}
-		}(segmentIOClient)
-
-		telemetryDomain, err := domain.NewTelemetry(
-			pkg.MetricMgmtClusterInstallStarted,
-			hostedZoneName,
-			configs.K1Version,
-		)
-		if err != nil {
-			log.Println(err)
-		}
-		telemetryService := services.NewSegmentIoService(segmentIOClient)
-		telemetryHandler := handlers.NewTelemetryHandler(telemetryService)
+			telemetryService := services.NewSegmentIoService(segmentIOClient)
+			telemetryHandler := handlers.NewTelemetryHandler(telemetryService)
 
-		if globalFlags.UseTelemetry {
 			err = telemetryHandler.SendCountMetric(telemetryDomain)
 			if err != nil {
 				log.Println(err)
@@ -146,12 +147,15 @@ cluster provisioning process spinning up the services, and validates the livenes
 
 		log.Println("sending mgmt cluster install completed metric")
 
-		installCompletedTelemetry, err := domain.NewTelemetry(
-			pkg.MetricMgmtClusterInstallCompleted,
-			hostedZoneName,
-			configs.K1Version,
-		)
 		if globalFlags.UseTelemetry {
+			installCompletedTelemetry, err := domain.NewTelemetry(
+				pkg.MetricMgmtClusterInstallCompleted,
+				hostedZoneName,
+				configs.K1Version,
+			)
+			if err != nil {
+				log.Println(err)
+			}
 			err = telemetryHandler.SendCountMetric(installCompletedTelemetry)
 			if err != nil {
 				log.Println(err)

cmd/init.go

@@ -1,13 +1,13 @@
 package cmd
 
 import (
-	"github.com/kubefirst/kubefirst/internal/domain"
 	"log"
 	"strings"
 	"time"
 
 	"github.com/kubefirst/kubefirst/configs"
 	"github.com/kubefirst/kubefirst/internal/aws"
+	"github.com/kubefirst/kubefirst/internal/domain"
 	"github.com/kubefirst/kubefirst/internal/downloadManager"
 	"github.com/kubefirst/kubefirst/internal/flagset"
 	"github.com/kubefirst/kubefirst/internal/handlers"
@@ -94,31 +94,33 @@ validated and configured.`,
 
 		log.Println("sending init started metric")
 
-		// Instantiates a SegmentIO client to use send messages to the segment API.
-		segmentIOClient := analytics.New(pkg.SegmentIOWriteKey)
+		var telemetryHandler handlers.TelemetryHandler
+		if globalFlags.UseTelemetry {
+
+			// Instantiates a SegmentIO client to use send messages to the segment API.
+			segmentIOClient := analytics.New(pkg.SegmentIOWriteKey)
 
-		// SegmentIO library works with queue that is based on timing, we explicit close the http client connection
-		// to force flush in case there is still some pending message in the SegmentIO library queue.
-		defer func(segmentIOClient analytics.Client) {
-			err := segmentIOClient.Close()
+			// SegmentIO library works with queue that is based on timing, we explicit close the http client connection
+			// to force flush in case there is still some pending message in the SegmentIO library queue.
+			defer func(segmentIOClient analytics.Client) {
+				err := segmentIOClient.Close()
+				if err != nil {
+					log.Println(err)
+				}
+			}(segmentIOClient)
+
+			// validate telemetryDomain data
+			telemetryDomain, err := domain.NewTelemetry(
+				pkg.MetricInitStarted,
+				awsFlags.HostedZoneName,
+				configs.K1Version,
+			)
 			if err != nil {
 				log.Println(err)
 			}
-		}(segmentIOClient)
-
-		// validate telemetryDomain data
-		telemetryDomain, err := domain.NewTelemetry(
-			pkg.MetricInitStarted,
-			awsFlags.HostedZoneName,
-			configs.K1Version,
-		)
-		if err != nil {
-			log.Println(err)
-		}
-		telemetryService := services.NewSegmentIoService(segmentIOClient)
-		telemetryHandler := handlers.NewTelemetryHandler(telemetryService)
+			telemetryService := services.NewSegmentIoService(segmentIOClient)
+			telemetryHandler = handlers.NewTelemetryHandler(telemetryService)
 
-		if globalFlags.UseTelemetry {
 			err = telemetryHandler.SendCountMetric(telemetryDomain)
 			if err != nil {
 				log.Println(err)
@@ -209,12 +211,15 @@ validated and configured.`,
 
 		log.Println("sending init completed metric")
 
-		telemetryInitCompleted, err := domain.NewTelemetry(
-			pkg.MetricInitCompleted,
-			awsFlags.HostedZoneName,
-			configs.K1Version,
-		)
 		if globalFlags.UseTelemetry {
+			telemetryInitCompleted, err := domain.NewTelemetry(
+				pkg.MetricInitCompleted,
+				awsFlags.HostedZoneName,
+				configs.K1Version,
+			)
+			if err != nil {
+				log.Println(err)
+			}
 			err = telemetryHandler.SendCountMetric(telemetryInitCompleted)
 			if err != nil {
 				log.Println(err)

internal/domain/telemetry.go

@@ -14,18 +14,18 @@ type Telemetry struct {
 
 // NewTelemetry is the Telemetry domain. When instantiating new Telemetries, we're able to validate domain specific
 // values. In this way, domain, handlers and services can work in isolation, and Domain host business logic.
-func NewTelemetry(metricName string, domain string, CLIVersion string) (*Telemetry, error) {
+func NewTelemetry(metricName string, domain string, CLIVersion string) (Telemetry, error) {
 
 	if len(metricName) == 0 {
-		return nil, errors.New("unable to create metric, missing metric name")
+		return Telemetry{}, errors.New("unable to create metric, missing metric name")
 	}
 
 	domain, err := pkg.RemoveSubDomain(domain)
 	if err != nil {
-		return nil, err
+		return Telemetry{}, err
 	}
 
-	return &Telemetry{
+	return Telemetry{
 		MetricName: metricName,
 		Domain:     domain,
 		CLIVersion: CLIVersion,

internal/domain/telemetry_test.go

@@ -17,7 +17,7 @@ func TestNewTelemetry(t *testing.T) {
 	tests := []struct {
 		name    string
 		args    args
-		want    *Telemetry
+		want    Telemetry
 		wantErr bool
 	}{
 		{
@@ -27,7 +27,7 @@ func TestNewTelemetry(t *testing.T) {
 				domain:     "https://example.com",
 				CLIVersion: "0.0.0",
 			},
-			want:    &validTelemetry,
+			want:    validTelemetry,
 			wantErr: false,
 		},
 		{
@@ -37,7 +37,7 @@ func TestNewTelemetry(t *testing.T) {
 				domain:     "https://example-com",
 				CLIVersion: "0.0.0",
 			},
-			want:    nil,
+			want:    Telemetry{},
 			wantErr: true,
 		},
 		{
@@ -47,7 +47,7 @@ func TestNewTelemetry(t *testing.T) {
 				domain:     "",
 				CLIVersion: "0.0.0",
 			},
-			want:    nil,
+			want:    Telemetry{},
 			wantErr: true,
 		},
 		{
@@ -57,7 +57,7 @@ func TestNewTelemetry(t *testing.T) {
 				domain:     "example.com",
 				CLIVersion: "0.0.0",
 			},
-			want:    nil,
+			want:    Telemetry{},
 			wantErr: true,
 		},
 	}

internal/handlers/telemetry.go

@@ -18,7 +18,7 @@ func NewTelemetryHandler(service services.SegmentIoService) TelemetryHandler {
 }
 
 // SendCountMetric validate and handles the metric request to the metric service.
-func (handler TelemetryHandler) SendCountMetric(telemetry *domain.Telemetry) error {
+func (handler TelemetryHandler) SendCountMetric(telemetry domain.Telemetry) error {
 
 	err := handler.service.EnqueueCountMetric(
 		telemetry.MetricName,

internal/handlers/telemetry_test.go

@@ -56,7 +56,7 @@ func TestTelemetryHandler_SendCountMetric(t *testing.T) {
 		service services.SegmentIoService
 	}
 	type args struct {
-		telemetry *domain.Telemetry
+		telemetry domain.Telemetry
 	}
 	tests := []struct {
 		name    string
@@ -67,7 +67,7 @@ func TestTelemetryHandler_SendCountMetric(t *testing.T) {
 		{
 			name:    "valid telemetry",
 			fields:  fields{service: mockedService},
-			args:    args{telemetry: &validTelemetry},
+			args:    args{telemetry: validTelemetry},
 			wantErr: false,
 		},
 	}