feat(metrics-operator): introduce SkipVerifyCertificate parameter

Signed-off-by: odubajDT <[email protected]>

metrics-operator/api/v1/keptnmetricsprovider_types.go

@@ -35,6 +35,10 @@ type KeptnMetricsProviderSpec struct {
 	// SecretKeyRef defines an optional secret for access credentials to the metrics provider.
 	// +optional
 	SecretKeyRef corev1.SecretKeySelector `json:"secretKeyRef,omitempty"`
+	// SkipVerifyCertificate skips verification of the cerificate
+	// +kubebuilder:default:=false
+	// +optional
+	SkipVerifyCertificate bool `json:"skipVerifyCertificate,omitempty"`
 }
 
 // +kubebuilder:object:root=true

metrics-operator/config/crd/bases/metrics.keptn.sh_keptnmetricsproviders.yaml

@@ -63,6 +63,10 @@ spec:
                 - key
                 type: object
                 x-kubernetes-map-type: atomic
+              skipVerifyCertificate:
+                default: false
+                description: SkipVerifyCertificate skips verification of the cerificate
+                type: boolean
               targetServer:
                 description: TargetServer defines URL (including port and protocol)
                   at which the metrics provider is reachable.

metrics-operator/controllers/analysis/objectives_evaluator.go

@@ -11,7 +11,7 @@ import (
 
 //go:generate moq -pkg fake -skip-ensure -out ./fake/evaluator_mock.go . IObjectivesEvaluator
 type IObjectivesEvaluator interface {
-	Evaluate(ctx context.Context, providerType string, obj chan metricstypes.ProviderRequest)
+	Evaluate(ctx context.Context, metricsProvider *metricsapi.KeptnMetricsProvider, obj chan metricstypes.ProviderRequest)
 }
 
 type ObjectivesEvaluator struct {
@@ -23,8 +23,8 @@ type ObjectivesEvaluator struct {
 	cancel  context.CancelFunc
 }
 
-func (oe ObjectivesEvaluator) Evaluate(ctx context.Context, providerType string, obj chan metricstypes.ProviderRequest) {
-	provider, err := oe.ProviderFactory(providerType, oe.log, oe.Client)
+func (oe ObjectivesEvaluator) Evaluate(ctx context.Context, metricsProvider *metricsapi.KeptnMetricsProvider, obj chan metricstypes.ProviderRequest) {
+	provider, err := oe.ProviderFactory(metricsProvider, oe.log, oe.Client)
 	if err != nil {
 		oe.log.Error(err, "Failed to get the correct Provider")
 		oe.cancel()
@@ -44,7 +44,7 @@ func (oe ObjectivesEvaluator) Evaluate(ctx context.Context, providerType string,
 			Value:     value,
 			ErrMsg:    strErr,
 		}
-		oe.log.Info("provider", "id:", providerType, "finished job:", o.Objective.AnalysisValueTemplateRef.Name, "result:", result)
+		oe.log.Info("provider", "id:", metricsProvider.Spec.Type, "finished job:", o.Objective.AnalysisValueTemplateRef.Name, "result:", result)
 		oe.results <- result
 	}
 }

metrics-operator/controllers/analysis/objectives_evaluator_test.go

@@ -20,15 +20,13 @@ func TestEvaluate(t *testing.T) {
 	// Define test cases
 	testCases := []struct {
 		name            string
-		providerType    string
 		mockProvider    providers.KeptnSLIProvider
 		providerRequest metricstypes.ProviderRequest
 		expectedResult  metricsapi.ProviderResult
 		expectedError   string
 	}{
 		{
-			name:         "SuccessfulEvaluation",
-			providerType: "mockProvider",
+			name: "SuccessfulEvaluation",
 			mockProvider: &fake2.KeptnSLIProviderMock{
 				FetchAnalysisValueFunc: func(ctx context.Context, query string, spec metricsapi.Analysis, provider *metricsapi.KeptnMetricsProvider) (string, error) {
 					return "10", nil
@@ -56,8 +54,7 @@ func TestEvaluate(t *testing.T) {
 			expectedError: "",
 		},
 		{
-			name:         "FailedEvaluation",
-			providerType: "mockProvider",
+			name: "FailedEvaluation",
 			mockProvider: &fake2.KeptnSLIProviderMock{
 				FetchAnalysisValueFunc: func(ctx context.Context, query string, spec metricsapi.Analysis, provider *metricsapi.KeptnMetricsProvider) (string, error) {
 					return "", fmt.Errorf("something bad")
@@ -88,7 +85,7 @@ func TestEvaluate(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			mockProviderFactory := func(providerType string, log logr.Logger, client client.Client) (providers.KeptnSLIProvider, error) {
+			mockProviderFactory := func(metricsProvider *metricsapi.KeptnMetricsProvider, log logr.Logger, client client.Client) (providers.KeptnSLIProvider, error) {
 				// Define your mock provider implementation
 				return tc.mockProvider, nil
 			}
@@ -115,7 +112,7 @@ func TestEvaluate(t *testing.T) {
 				objChan <- tc.providerRequest
 				close(objChan)
 			}()
-			objectivesEvaluator.Evaluate(ctx, tc.providerType, objChan)
+			objectivesEvaluator.Evaluate(ctx, tc.providerRequest.Provider, objChan)
 			close(objectivesEvaluator.results)
 			result := <-objectivesEvaluator.results
 

metrics-operator/controllers/analysis/provider_selector.go

@@ -39,7 +39,12 @@ func (ps ProvidersPool) StartProviders(ctx context.Context, numJobs int) {
 	for _, provider := range providers.SupportedProviders {
 		channel := make(chan metricstypes.ProviderRequest, numJobs)
 		ps.providers[provider] = channel
-		go ps.Evaluate(ctx, provider, channel)
+		metricsProvider := &metricsapi.KeptnMetricsProvider{
+			Spec: metricsapi.KeptnMetricsProviderSpec{
+				Type: provider,
+			},
+		}
+		go ps.Evaluate(ctx, metricsProvider, channel)
 	}
 }
 

metrics-operator/controllers/analysis/provider_selector_test.go

@@ -251,7 +251,7 @@ func TestProvidersPool_StartProviders(t *testing.T) {
 	resChan := make(chan metricsapi.ProviderResult)
 	// Create a mock IObjectivesEvaluator, Client, and Logger for testing
 	mockEvaluator := &fake.IObjectivesEvaluatorMock{
-		EvaluateFunc: func(ctx context.Context, providerType string, obj chan metricstypes.ProviderRequest) {
+		EvaluateFunc: func(ctx context.Context, metricsProvider *metricsapi.KeptnMetricsProvider, obj chan metricstypes.ProviderRequest) {
 		},
 	}
 

metrics-operator/controllers/common/providers/provider.go

@@ -2,6 +2,7 @@ package providers
 
 import (
 	"context"
+	"crypto/tls"
 	"fmt"
 	"net/http"
 	"strings"
@@ -23,19 +24,25 @@ type KeptnSLIProvider interface {
 	FetchAnalysisValue(ctx context.Context, query string, spec metricsapi.Analysis, provider *metricsapi.KeptnMetricsProvider) (string, error)
 }
 
-type ProviderFactory func(providerType string, log logr.Logger, k8sClient client.Client) (KeptnSLIProvider, error)
+type ProviderFactory func(provider *metricsapi.KeptnMetricsProvider, log logr.Logger, k8sClient client.Client) (KeptnSLIProvider, error)
 
 // NewProvider is a factory method that chooses the right implementation of KeptnSLIProvider
-func NewProvider(providerType string, log logr.Logger, k8sClient client.Client) (KeptnSLIProvider, error) {
+func NewProvider(provider *metricsapi.KeptnMetricsProvider, log logr.Logger, k8sClient client.Client) (KeptnSLIProvider, error) {
 
-	switch strings.ToLower(providerType) {
+	switch strings.ToLower(provider.Spec.Type) {
 	case PrometheusProviderType, ThanosProviderType, CortexProviderType:
 		return prometheus.NewPrometheusProvider(log, k8sClient), nil
 	case DynatraceProviderType:
 		return &dynatrace.KeptnDynatraceProvider{
-			HttpClient: http.Client{},
-			Log:        log,
-			K8sClient:  k8sClient,
+			HttpClient: http.Client{
+				Transport: &http.Transport{
+					TLSClientConfig: &tls.Config{
+						InsecureSkipVerify: provider.Spec.SkipVerifyCertificate,
+					},
+				},
+			},
+			Log:       log,
+			K8sClient: k8sClient,
 		}, nil
 	case DynatraceDQLProviderType:
 		return dynatrace.NewKeptnDynatraceDQLProvider(
@@ -44,11 +51,17 @@ func NewProvider(providerType string, log logr.Logger, k8sClient client.Client)
 		), nil
 	case DataDogProviderType:
 		return &datadog.KeptnDataDogProvider{
-			Log:        log,
-			HttpClient: http.Client{},
-			K8sClient:  k8sClient,
+			Log: log,
+			HttpClient: http.Client{
+				Transport: &http.Transport{
+					TLSClientConfig: &tls.Config{
+						InsecureSkipVerify: provider.Spec.SkipVerifyCertificate,
+					},
+				},
+			},
+			K8sClient: k8sClient,
 		}, nil
 	default:
-		return nil, fmt.Errorf("provider %s not supported", providerType)
+		return nil, fmt.Errorf("provider %s not supported", provider.Spec.Type)
 	}
 }

metrics-operator/controllers/common/providers/provider_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/go-logr/logr"
+	metricsapi "github.com/keptn/lifecycle-toolkit/metrics-operator/api/v1"
 	"github.com/keptn/lifecycle-toolkit/metrics-operator/controllers/common/fake"
 	"github.com/keptn/lifecycle-toolkit/metrics-operator/controllers/common/providers/datadog"
 	"github.com/keptn/lifecycle-toolkit/metrics-operator/controllers/common/providers/dynatrace"
@@ -13,50 +14,78 @@ import (
 
 func TestFactory(t *testing.T) {
 	tests := []struct {
-		providerType string
-		provider     interface{}
-		err          bool
+		metricsProvider metricsapi.KeptnMetricsProvider
+		provider        interface{}
+		err             bool
 	}{
 		{
-			providerType: PrometheusProviderType,
-			provider:     &prometheus.KeptnPrometheusProvider{},
-			err:          false,
+			metricsProvider: metricsapi.KeptnMetricsProvider{
+				Spec: metricsapi.KeptnMetricsProviderSpec{
+					Type: PrometheusProviderType,
+				},
+			},
+			provider: &prometheus.KeptnPrometheusProvider{},
+			err:      false,
 		},
 		{
-			providerType: ThanosProviderType,
-			provider:     &prometheus.KeptnPrometheusProvider{},
-			err:          false,
+			metricsProvider: metricsapi.KeptnMetricsProvider{
+				Spec: metricsapi.KeptnMetricsProviderSpec{
+					Type: ThanosProviderType,
+				},
+			},
+			provider: &prometheus.KeptnPrometheusProvider{},
+			err:      false,
 		},
 		{
-			providerType: CortexProviderType,
-			provider:     &prometheus.KeptnPrometheusProvider{},
-			err:          false,
+			metricsProvider: metricsapi.KeptnMetricsProvider{
+				Spec: metricsapi.KeptnMetricsProviderSpec{
+					Type: CortexProviderType,
+				},
+			},
+			provider: &prometheus.KeptnPrometheusProvider{},
+			err:      false,
 		},
 		{
-			providerType: DynatraceProviderType,
-			provider:     &dynatrace.KeptnDynatraceProvider{},
-			err:          false,
+			metricsProvider: metricsapi.KeptnMetricsProvider{
+				Spec: metricsapi.KeptnMetricsProviderSpec{
+					Type: DynatraceProviderType,
+				},
+			},
+			provider: &dynatrace.KeptnDynatraceProvider{},
+			err:      false,
 		},
 		{
-			providerType: DynatraceDQLProviderType,
-			provider:     dynatrace.NewKeptnDynatraceDQLProvider(fake.NewClient()),
-			err:          false,
+			metricsProvider: metricsapi.KeptnMetricsProvider{
+				Spec: metricsapi.KeptnMetricsProviderSpec{
+					Type: DynatraceDQLProviderType,
+				},
+			},
+			provider: dynatrace.NewKeptnDynatraceDQLProvider(fake.NewClient()),
+			err:      false,
 		},
 		{
-			providerType: DataDogProviderType,
-			provider:     &datadog.KeptnDataDogProvider{},
-			err:          false,
+			metricsProvider: metricsapi.KeptnMetricsProvider{
+				Spec: metricsapi.KeptnMetricsProviderSpec{
+					Type: DataDogProviderType,
+				},
+			},
+			provider: &datadog.KeptnDataDogProvider{},
+			err:      false,
 		},
 		{
-			providerType: "invalid",
-			provider:     nil,
-			err:          true,
+			metricsProvider: metricsapi.KeptnMetricsProvider{
+				Spec: metricsapi.KeptnMetricsProviderSpec{
+					Type: "invalid",
+				},
+			},
+			provider: nil,
+			err:      true,
 		},
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.providerType, func(t *testing.T) {
-			p, e := NewProvider(tt.providerType, logr.Logger{}, nil)
+		t.Run(tt.metricsProvider.Spec.Type, func(t *testing.T) {
+			p, e := NewProvider(&tt.metricsProvider, logr.Logger{}, nil)
 			require.IsType(t, tt.provider, p)
 			if tt.err {
 				require.NotNil(t, e)