refactor: metrics package (#3549)

* refactor: use BackgroundProcessingEnabled method

Signed-off-by: Charles-Edouard Brétéché <charled.breteche@gmail.com>

* refactor: webhooks metrics reporting

Signed-off-by: Charles-Edouard Brétéché <charled.breteche@gmail.com>

* refactor: metrics package

Signed-off-by: Charles-Edouard Brétéché <charled.breteche@gmail.com>

api/kyverno/v1/policy_interface.go

@@ -17,4 +17,5 @@ type PolicyInterface interface {
 	Validate(sets.String) field.ErrorList
 	GetKind() string
 	CreateDeepCopy() PolicyInterface
+	IsReady() bool
 }

pkg/metrics/admissionrequests/admissionRequests.go

@@ -9,7 +9,8 @@ import (
 	prom "github.com/prometheus/client_golang/prometheus"
 )
 
-func (pc PromConfig) registerAdmissionRequestsMetric(
+func registerAdmissionRequestsMetric(
+	pc *metrics.PromConfig,
 	resourceKind, resourceNamespace string,
 	resourceRequestOperation metrics.ResourceRequestOperation,
 ) error {
@@ -30,14 +31,13 @@ func (pc PromConfig) registerAdmissionRequestsMetric(
 	return nil
 }
 
-func (pc PromConfig) ProcessEngineResponses(engineResponses []*response.EngineResponse, resourceRequestOperation metrics.ResourceRequestOperation) error {
+func ProcessEngineResponses(pc *metrics.PromConfig, engineResponses []*response.EngineResponse, resourceRequestOperation metrics.ResourceRequestOperation) error {
 	if len(engineResponses) == 0 {
 		return nil
 	}
 	resourceNamespace, resourceKind := engineResponses[0].PolicyResponse.Resource.Namespace, engineResponses[0].PolicyResponse.Resource.Kind
-	totalValidateRulesCount, totalMutateRulesCount, totalGenerateRulesCount := 0, 0, 0
+	validateRulesCount, mutateRulesCount, generateRulesCount := 0, 0, 0
 	for _, e := range engineResponses {
-		validateRulesCount, mutateRulesCount, generateRulesCount := 0, 0, 0
 		for _, rule := range e.PolicyResponse.Rules {
 			switch rule.Type {
 			case "Validation":
@@ -48,17 +48,9 @@ func (pc PromConfig) ProcessEngineResponses(engineResponses []*response.EngineRe
 				generateRulesCount++
 			}
 		}
-		// no rules triggered
-		if validateRulesCount+mutateRulesCount+generateRulesCount == 0 {
-			continue
-		}
-
-		totalValidateRulesCount += validateRulesCount
-		totalMutateRulesCount += mutateRulesCount
-		totalGenerateRulesCount += generateRulesCount
 	}
-	if totalValidateRulesCount+totalMutateRulesCount+totalGenerateRulesCount == 0 {
+	if validateRulesCount == 0 && mutateRulesCount == 0 && generateRulesCount == 0 {
 		return nil
 	}
-	return pc.registerAdmissionRequestsMetric(resourceKind, resourceNamespace, resourceRequestOperation)
+	return registerAdmissionRequestsMetric(pc, resourceKind, resourceNamespace, resourceRequestOperation)
 }

pkg/metrics/admissionrequests/parsers.go

@@ -1,13 +0,0 @@
-package admissionrequests
-
-import (
-	"github.com/kyverno/kyverno/pkg/metrics"
-)
-
-func ParsePromMetrics(pm metrics.PromMetrics) PromMetrics {
-	return PromMetrics(pm)
-}
-
-func ParsePromConfig(pc metrics.PromConfig) PromConfig {
-	return PromConfig(pc)
-}

pkg/metrics/admissionrequests/types.go

@@ -1,9 +0,0 @@
-package admissionrequests
-
-import (
-	"github.com/kyverno/kyverno/pkg/metrics"
-)
-
-type PromMetrics metrics.PromMetrics
-
-type PromConfig metrics.PromConfig

pkg/metrics/admissionreviewduration/admissionReviewDuration.go

@@ -9,7 +9,8 @@ import (
 	prom "github.com/prometheus/client_golang/prometheus"
 )
 
-func (pc PromConfig) registerAdmissionReviewDurationMetric(
+func registerAdmissionReviewDurationMetric(
+	pc *metrics.PromConfig,
 	resourceKind, resourceNamespace string,
 	resourceRequestOperation metrics.ResourceRequestOperation,
 	admissionRequestLatency float64,
@@ -31,14 +32,13 @@ func (pc PromConfig) registerAdmissionReviewDurationMetric(
 	return nil
 }
 
-func (pc PromConfig) ProcessEngineResponses(engineResponses []*response.EngineResponse, admissionReviewLatencyDuration int64, resourceRequestOperation metrics.ResourceRequestOperation) error {
+func ProcessEngineResponses(pc *metrics.PromConfig, engineResponses []*response.EngineResponse, admissionReviewLatencyDuration int64, resourceRequestOperation metrics.ResourceRequestOperation) error {
 	if len(engineResponses) == 0 {
 		return nil
 	}
 	resourceNamespace, resourceKind := engineResponses[0].PolicyResponse.Resource.Namespace, engineResponses[0].PolicyResponse.Resource.Kind
-	totalValidateRulesCount, totalMutateRulesCount, totalGenerateRulesCount := 0, 0, 0
+	validateRulesCount, mutateRulesCount, generateRulesCount := 0, 0, 0
 	for _, e := range engineResponses {
-		validateRulesCount, mutateRulesCount, generateRulesCount := 0, 0, 0
 		for _, rule := range e.PolicyResponse.Rules {
 			switch rule.Type {
 			case "Validation":
@@ -49,18 +49,10 @@ func (pc PromConfig) ProcessEngineResponses(engineResponses []*response.EngineRe
 				generateRulesCount++
 			}
 		}
-		// no rules triggered
-		if validateRulesCount+mutateRulesCount+generateRulesCount == 0 {
-			continue
-		}
-
-		totalValidateRulesCount += validateRulesCount
-		totalMutateRulesCount += mutateRulesCount
-		totalGenerateRulesCount += generateRulesCount
 	}
-	if totalValidateRulesCount+totalMutateRulesCount+totalGenerateRulesCount == 0 {
+	if validateRulesCount == 0 && mutateRulesCount == 0 && generateRulesCount == 0 {
 		return nil
 	}
 	admissionReviewLatencyDurationInSeconds := float64(admissionReviewLatencyDuration) / float64(1000*1000*1000)
-	return pc.registerAdmissionReviewDurationMetric(resourceKind, resourceNamespace, resourceRequestOperation, admissionReviewLatencyDurationInSeconds)
+	return registerAdmissionReviewDurationMetric(pc, resourceKind, resourceNamespace, resourceRequestOperation, admissionReviewLatencyDurationInSeconds)
 }

pkg/metrics/admissionreviewduration/parsers.go

@@ -1,13 +0,0 @@
-package admissionreviewduration
-
-import (
-	"github.com/kyverno/kyverno/pkg/metrics"
-)
-
-func ParsePromMetrics(pm metrics.PromMetrics) PromMetrics {
-	return PromMetrics(pm)
-}
-
-func ParsePromConfig(pc metrics.PromConfig) PromConfig {
-	return PromConfig(pc)
-}

pkg/metrics/admissionreviewduration/types.go

@@ -1,9 +0,0 @@
-package admissionreviewduration
-
-import (
-	"github.com/kyverno/kyverno/pkg/metrics"
-)
-
-type PromMetrics metrics.PromMetrics
-
-type PromConfig metrics.PromConfig

pkg/metrics/parsers.go

@@ -5,6 +5,7 @@ import (
 	"reflect"
 
 	kyverno "github.com/kyverno/kyverno/api/kyverno/v1"
+	"github.com/kyverno/kyverno/pkg/engine/response"
 )
 
 func ParsePolicyValidationMode(validationFailureAction kyverno.ValidationFailureAction) (PolicyValidationMode, error) {
@@ -52,3 +53,29 @@ func ParseResourceRequestOperation(requestOperationStr string) (ResourceRequestO
 		return "", fmt.Errorf("unknown request operation made by resource: %s. Allowed requests: 'CREATE', 'UPDATE', 'DELETE', 'CONNECT'", requestOperationStr)
 	}
 }
+
+func ParseRuleTypeFromEngineRuleResponse(rule response.RuleResponse) RuleType {
+	switch rule.Type {
+	case "Validation":
+		return Validate
+	case "Mutation":
+		return Mutate
+	case "Generation":
+		return Generate
+	default:
+		return EmptyRuleType
+	}
+}
+
+func GetPolicyInfos(policy kyverno.PolicyInterface) (string, string, PolicyType, PolicyBackgroundMode, PolicyValidationMode, error) {
+	name := policy.GetName()
+	namespace := ""
+	policyType := Cluster
+	if policy.IsNamespaced() {
+		namespace = policy.GetNamespace()
+		policyType = Namespaced
+	}
+	backgroundMode := ParsePolicyBackgroundMode(policy)
+	validationMode, err := ParsePolicyValidationMode(policy.GetSpec().GetValidationFailureAction())
+	return name, namespace, policyType, backgroundMode, validationMode, err
+}

pkg/metrics/policychanges/parsers.go

@@ -1,13 +0,0 @@
-package policychanges
-
-import (
-	"github.com/kyverno/kyverno/pkg/metrics"
-)
-
-func ParsePromMetrics(pm metrics.PromMetrics) PromMetrics {
-	return PromMetrics(pm)
-}
-
-func ParsePromConfig(pc metrics.PromConfig) PromConfig {
-	return PromConfig(pc)
-}

pkg/metrics/policychanges/policyChanges.go

@@ -9,7 +9,8 @@ import (
 	prom "github.com/prometheus/client_golang/prometheus"
 )
 
-func (pc PromConfig) registerPolicyChangesMetric(
+func registerPolicyChangesMetric(
+	pc *metrics.PromConfig,
 	policyValidationMode metrics.PolicyValidationMode,
 	policyType metrics.PolicyType,
 	policyBackgroundMode metrics.PolicyBackgroundMode,
@@ -39,35 +40,13 @@ func (pc PromConfig) registerPolicyChangesMetric(
 	return nil
 }
 
-func (pc PromConfig) RegisterPolicy(policy interface{}, policyChangeType PolicyChangeType) error {
+func RegisterPolicy(pc *metrics.PromConfig, policy kyverno.PolicyInterface, policyChangeType PolicyChangeType) error {
-	switch inputPolicy := policy.(type) {
+	name, namespace, policyType, backgroundMode, validationMode, err := metrics.GetPolicyInfos(policy)
-	case *kyverno.ClusterPolicy:
+	if err != nil {
-		policyValidationMode, err := metrics.ParsePolicyValidationMode(inputPolicy.Spec.GetValidationFailureAction())
+		return err
-		if err != nil {
-			return err
-		}
-		policyBackgroundMode := metrics.ParsePolicyBackgroundMode(inputPolicy)
-		policyType := metrics.Cluster
-		policyNamespace := "" // doesn't matter for cluster policy
-		policyName := inputPolicy.GetName()
-		if err = pc.registerPolicyChangesMetric(policyValidationMode, policyType, policyBackgroundMode, policyNamespace, policyName, policyChangeType); err != nil {
-			return err
-		}
-		return nil
-	case *kyverno.Policy:
-		policyValidationMode, err := metrics.ParsePolicyValidationMode(inputPolicy.Spec.GetValidationFailureAction())
-		if err != nil {
-			return err
-		}
-		policyBackgroundMode := metrics.ParsePolicyBackgroundMode(inputPolicy)
-		policyType := metrics.Namespaced
-		policyNamespace := inputPolicy.GetNamespace()
-		policyName := inputPolicy.GetName()
-		if err = pc.registerPolicyChangesMetric(policyValidationMode, policyType, policyBackgroundMode, policyNamespace, policyName, policyChangeType); err != nil {
-			return err
-		}
-		return nil
-	default:
-		return fmt.Errorf("wrong input type provided %T. Only kyverno.Policy and kyverno.ClusterPolicy allowed", inputPolicy)
 	}
+	if err = registerPolicyChangesMetric(pc, validationMode, policyType, backgroundMode, namespace, name, policyChangeType); err != nil {
+		return err
+	}
+	return nil
 }

pkg/metrics/policychanges/types.go

@@ -1,9 +1,5 @@
 package policychanges
 
-import (
-	"github.com/kyverno/kyverno/pkg/metrics"
-)
-
 type PolicyChangeType string
 
 const (
@@ -11,7 +7,3 @@ const (
 	PolicyUpdated PolicyChangeType = "updated"
 	PolicyDeleted PolicyChangeType = "deleted"
 )
-
-type PromMetrics metrics.PromMetrics
-
-type PromConfig metrics.PromConfig

pkg/metrics/policyexecutionduration/parsers.go

@@ -1,27 +0,0 @@
-package policyexecutionduration
-
-import (
-	"github.com/kyverno/kyverno/pkg/engine/response"
-	"github.com/kyverno/kyverno/pkg/metrics"
-)
-
-func ParsePromMetrics(pm metrics.PromMetrics) PromMetrics {
-	return PromMetrics(pm)
-}
-
-func ParsePromConfig(pc metrics.PromConfig) PromConfig {
-	return PromConfig(pc)
-}
-
-func ParseRuleTypeFromEngineRuleResponse(rule response.RuleResponse) metrics.RuleType {
-	switch rule.Type {
-	case "Validation":
-		return metrics.Validate
-	case "Mutation":
-		return metrics.Mutate
-	case "Generation":
-		return metrics.Generate
-	default:
-		return metrics.EmptyRuleType
-	}
-}

pkg/metrics/policyexecutionduration/policyExecutionDuration.go

@@ -10,7 +10,8 @@ import (
 	prom "github.com/prometheus/client_golang/prometheus"
 )
 
-func (pc PromConfig) registerPolicyExecutionDurationMetric(
+func registerPolicyExecutionDurationMetric(
+	pc *metrics.PromConfig,
 	policyValidationMode metrics.PolicyValidationMode,
 	policyType metrics.PolicyType,
 	policyBackgroundMode metrics.PolicyBackgroundMode,
@@ -59,31 +60,18 @@ func (pc PromConfig) registerPolicyExecutionDurationMetric(
 
 //policy - policy related data
 //engineResponse - resource and rule related data
-func (pc PromConfig) ProcessEngineResponse(policy kyverno.PolicyInterface, engineResponse response.EngineResponse, executionCause metrics.RuleExecutionCause, generateRuleLatencyType string, resourceRequestOperation metrics.ResourceRequestOperation) error {
+func ProcessEngineResponse(pc *metrics.PromConfig, policy kyverno.PolicyInterface, engineResponse response.EngineResponse, executionCause metrics.RuleExecutionCause, generateRuleLatencyType string, resourceRequestOperation metrics.ResourceRequestOperation) error {
-	policyValidationMode, err := metrics.ParsePolicyValidationMode(policy.GetSpec().GetValidationFailureAction())
+	name, namespace, policyType, backgroundMode, validationMode, err := metrics.GetPolicyInfos(policy)
 	if err != nil {
 		return err
 	}
-	policyType := metrics.Namespaced
-	policyBackgroundMode := metrics.ParsePolicyBackgroundMode(policy)
-	policyNamespace := policy.GetNamespace()
-	if policyNamespace == "" {
-		policyNamespace = "-"
-		policyType = metrics.Cluster
-	}
-	policyName := policy.GetName()
-
 	resourceSpec := engineResponse.PolicyResponse.Resource
-
 	resourceKind := resourceSpec.Kind
 	resourceNamespace := resourceSpec.Namespace
-
 	ruleResponses := engineResponse.PolicyResponse.Rules
-
 	for _, rule := range ruleResponses {
 		ruleName := rule.Name
-		ruleType := ParseRuleTypeFromEngineRuleResponse(rule)
+		ruleType := metrics.ParseRuleTypeFromEngineRuleResponse(rule)
-
 		var ruleResult metrics.RuleResult
 		switch rule.Status {
 		case response.RuleStatusPass:
@@ -99,14 +87,13 @@ func (pc PromConfig) ProcessEngineResponse(policy kyverno.PolicyInterface, engin
 		default:
 			ruleResult = metrics.Fail
 		}
-
 		ruleExecutionLatencyInSeconds := float64(rule.RuleStats.ProcessingTime) / float64(1000*1000*1000)
-
+		if err := registerPolicyExecutionDurationMetric(
-		if err := pc.registerPolicyExecutionDurationMetric(
+			pc,
-			policyValidationMode,
+			validationMode,
 			policyType,
-			policyBackgroundMode,
+			backgroundMode,
-			policyNamespace, policyName,
+			namespace, name,
 			resourceKind, resourceNamespace,
 			resourceRequestOperation,
 			ruleName,

pkg/metrics/policyexecutionduration/types.go

@@ -1,9 +0,0 @@
-package policyexecutionduration
-
-import (
-	"github.com/kyverno/kyverno/pkg/metrics"
-)
-
-type PromMetrics metrics.PromMetrics
-
-type PromConfig metrics.PromConfig

pkg/metrics/policyresults/parsers.go

@@ -1,27 +0,0 @@
-package policyresults
-
-import (
-	"github.com/kyverno/kyverno/pkg/engine/response"
-	"github.com/kyverno/kyverno/pkg/metrics"
-)
-
-func ParsePromMetrics(pm metrics.PromMetrics) PromMetrics {
-	return PromMetrics(pm)
-}
-
-func ParsePromConfig(pc metrics.PromConfig) PromConfig {
-	return PromConfig(pc)
-}
-
-func ParseRuleTypeFromEngineRuleResponse(rule response.RuleResponse) metrics.RuleType {
-	switch rule.Type {
-	case "Validation":
-		return metrics.Validate
-	case "Mutation":
-		return metrics.Mutate
-	case "Generation":
-		return metrics.Generate
-	default:
-		return metrics.EmptyRuleType
-	}
-}

pkg/metrics/policyresults/policyResults.go

@@ -10,7 +10,8 @@ import (
 	prom "github.com/prometheus/client_golang/prometheus"
 )
 
-func (pc PromConfig) registerPolicyResultsMetric(
+func registerPolicyResultsMetric(
+	pc *metrics.PromConfig,
 	policyValidationMode metrics.PolicyValidationMode,
 	policyType metrics.PolicyType,
 	policyBackgroundMode metrics.PolicyBackgroundMode,
@@ -53,31 +54,18 @@ func (pc PromConfig) registerPolicyResultsMetric(
 
 //policy - policy related data
 //engineResponse - resource and rule related data
-func (pc PromConfig) ProcessEngineResponse(policy kyverno.PolicyInterface, engineResponse response.EngineResponse, executionCause metrics.RuleExecutionCause, resourceRequestOperation metrics.ResourceRequestOperation) error {
+func ProcessEngineResponse(pc *metrics.PromConfig, policy kyverno.PolicyInterface, engineResponse response.EngineResponse, executionCause metrics.RuleExecutionCause, resourceRequestOperation metrics.ResourceRequestOperation) error {
-	policyValidationMode, err := metrics.ParsePolicyValidationMode(policy.GetSpec().GetValidationFailureAction())
+	name, namespace, policyType, backgroundMode, validationMode, err := metrics.GetPolicyInfos(policy)
 	if err != nil {
 		return err
 	}
-	policyType := metrics.Namespaced
-	policyBackgroundMode := metrics.ParsePolicyBackgroundMode(policy)
-	policyNamespace := policy.GetNamespace()
-	if policyNamespace == "" {
-		policyNamespace = "-"
-		policyType = metrics.Cluster
-	}
-	policyName := policy.GetName()
-
 	resourceSpec := engineResponse.PolicyResponse.Resource
-
 	resourceKind := resourceSpec.Kind
 	resourceNamespace := resourceSpec.Namespace
-
 	ruleResponses := engineResponse.PolicyResponse.Rules
-
 	for _, rule := range ruleResponses {
 		ruleName := rule.Name
-		ruleType := ParseRuleTypeFromEngineRuleResponse(rule)
+		ruleType := metrics.ParseRuleTypeFromEngineRuleResponse(rule)
-
 		var ruleResult metrics.RuleResult
 		switch rule.Status {
 		case response.RuleStatusPass:
@@ -93,12 +81,12 @@ func (pc PromConfig) ProcessEngineResponse(policy kyverno.PolicyInterface, engin
 		default:
 			ruleResult = metrics.Fail
 		}
-
+		if err := registerPolicyResultsMetric(
-		if err := pc.registerPolicyResultsMetric(
+			pc,
-			policyValidationMode,
+			validationMode,
 			policyType,
-			policyBackgroundMode,
+			backgroundMode,
-			policyNamespace, policyName,
+			namespace, name,
 			resourceKind, resourceNamespace,
 			resourceRequestOperation,
 			ruleName,

pkg/metrics/policyresults/types.go

@@ -1,9 +0,0 @@
-package policyresults
-
-import (
-	"github.com/kyverno/kyverno/pkg/metrics"
-)
-
-type PromMetrics metrics.PromMetrics
-
-type PromConfig metrics.PromConfig

pkg/metrics/policyruleinfo/parsers.go

@@ -2,8 +2,6 @@ package policyruleinfo
 
 import (
 	"fmt"
-
-	"github.com/kyverno/kyverno/pkg/metrics"
 )
 
 func ParsePolicyRuleInfoMetricChangeType(change string) (PolicyRuleInfoMetricChangeType, error) {
@@ -15,11 +13,3 @@ func ParsePolicyRuleInfoMetricChangeType(change string) (PolicyRuleInfoMetricCha
 	}
 	return "", fmt.Errorf("wrong policy rule count metric change type found %s. Allowed: '%s', '%s'", change, "created", "deleted")
 }
-
-func ParsePromMetrics(pm metrics.PromMetrics) PromMetrics {
-	return PromMetrics(pm)
-}
-
-func ParsePromConfig(pc metrics.PromConfig) PromConfig {
-	return PromConfig(pc)
-}

pkg/metrics/policyruleinfo/policyRuleInfo.go

@@ -10,7 +10,8 @@ import (
 	prom "github.com/prometheus/client_golang/prometheus"
 )
 
-func (pc PromConfig) registerPolicyRuleInfoMetric(
+func registerPolicyRuleInfoMetric(
+	pc *metrics.PromConfig,
 	policyValidationMode metrics.PolicyValidationMode,
 	policyType metrics.PolicyType,
 	policyBackgroundMode metrics.PolicyBackgroundMode,
@@ -28,7 +29,6 @@ func (pc PromConfig) registerPolicyRuleInfoMetric(
 	default:
 		return fmt.Errorf("unknown metric change type found:  %s", metricChangeType)
 	}
-
 	includeNamespaces, excludeNamespaces := pc.Config.GetIncludeNamespaces(), pc.Config.GetExcludeNamespaces()
 	if (policyNamespace != "" && policyNamespace != "-") && utils.ContainsString(excludeNamespaces, policyNamespace) {
 		pc.Log.Info(fmt.Sprintf("Skipping the registration of kyverno_policy_rule_info_total metric as the operation belongs to the namespace '%s' which is one of 'namespaces.exclude' %+v in values.yaml", policyNamespace, excludeNamespaces))
@@ -38,16 +38,13 @@ func (pc PromConfig) registerPolicyRuleInfoMetric(
 		pc.Log.Info(fmt.Sprintf("Skipping the registration of kyverno_policy_rule_info_total metric as the operation belongs to the namespace '%s' which is not one of 'namespaces.include' %+v in values.yaml", policyNamespace, includeNamespaces))
 		return nil
 	}
-
 	if policyType == metrics.Cluster {
 		policyNamespace = "-"
 	}
-
 	status := "false"
 	if ready {
 		status = "true"
 	}
-
 	pc.Metrics.PolicyRuleInfo.With(prom.Labels{
 		"policy_validation_mode": string(policyValidationMode),
 		"policy_type":            string(policyType),
@@ -58,99 +55,37 @@ func (pc PromConfig) registerPolicyRuleInfoMetric(
 		"rule_type":              string(ruleType),
 		"status_ready":           status,
 	}).Set(metricValue)
-
 	return nil
 }
 
-func (pc PromConfig) AddPolicy(policy interface{}) error {
+func AddPolicy(pc *metrics.PromConfig, policy kyverno.PolicyInterface) error {
-	switch inputPolicy := policy.(type) {
+	name, namespace, policyType, backgroundMode, validationMode, err := metrics.GetPolicyInfos(policy)
-	case *kyverno.ClusterPolicy:
+	if err != nil {
-		policyValidationMode, err := metrics.ParsePolicyValidationMode(inputPolicy.Spec.GetValidationFailureAction())
+		return err
-		if err != nil {
+	}
+	ready := policy.IsReady()
+	for _, rule := range autogen.ComputeRules(policy) {
+		ruleName := rule.Name
+		ruleType := metrics.ParseRuleType(rule)
+		if err = registerPolicyRuleInfoMetric(pc, validationMode, policyType, backgroundMode, namespace, name, ruleName, ruleType, PolicyRuleCreated, ready); err != nil {
 			return err
 		}
-		policyBackgroundMode := metrics.ParsePolicyBackgroundMode(inputPolicy)
+	}
-		policyType := metrics.Cluster
+	return nil
-		policyNamespace := "" // doesn't matter for cluster policy
+}
-		policyName := inputPolicy.GetName()
-		ready := inputPolicy.IsReady()
-		// registering the metrics on a per-rule basis
-		for _, rule := range autogen.ComputeRules(inputPolicy) {
-			ruleName := rule.Name
-			ruleType := metrics.ParseRuleType(rule)
 
-			if err = pc.registerPolicyRuleInfoMetric(policyValidationMode, policyType, policyBackgroundMode, policyNamespace, policyName, ruleName, ruleType, PolicyRuleCreated, ready); err != nil {
+func RemovePolicy(pc *metrics.PromConfig, policy kyverno.PolicyInterface) error {
-				return err
+	name, namespace, policyType, backgroundMode, validationMode, err := metrics.GetPolicyInfos(policy)
-			}
+	if err != nil {
-		}
+		return err
-		return nil
+	}
-	case *kyverno.Policy:
+	ready := policy.IsReady()
-		policyValidationMode, err := metrics.ParsePolicyValidationMode(inputPolicy.Spec.GetValidationFailureAction())
+	for _, rule := range autogen.ComputeRules(policy) {
-		if err != nil {
+		ruleName := rule.Name
+		ruleType := metrics.ParseRuleType(rule)
+		if err = registerPolicyRuleInfoMetric(pc, validationMode, policyType, backgroundMode, namespace, name, ruleName, ruleType, PolicyRuleDeleted, ready); err != nil {
 			return err
 		}
-		policyBackgroundMode := metrics.ParsePolicyBackgroundMode(inputPolicy)
-		policyType := metrics.Namespaced
-		policyNamespace := inputPolicy.GetNamespace()
-		policyName := inputPolicy.GetName()
-		ready := inputPolicy.IsReady()
-		// registering the metrics on a per-rule basis
-		for _, rule := range autogen.ComputeRules(inputPolicy) {
-			ruleName := rule.Name
-			ruleType := metrics.ParseRuleType(rule)
-
-			if err = pc.registerPolicyRuleInfoMetric(policyValidationMode, policyType, policyBackgroundMode, policyNamespace, policyName, ruleName, ruleType, PolicyRuleCreated, ready); err != nil {
-				return err
-			}
-		}
-		return nil
-	default:
-		return fmt.Errorf("wrong input type provided %T. Only kyverno.Policy and kyverno.ClusterPolicy allowed", inputPolicy)
 	}
-}
+	return nil
-
-func (pc PromConfig) RemovePolicy(policy interface{}) error {
-	switch inputPolicy := policy.(type) {
-	case *kyverno.ClusterPolicy:
-		for _, rule := range autogen.ComputeRules(inputPolicy) {
-			policyValidationMode, err := metrics.ParsePolicyValidationMode(inputPolicy.Spec.GetValidationFailureAction())
-			if err != nil {
-				return err
-			}
-			policyBackgroundMode := metrics.ParsePolicyBackgroundMode(inputPolicy)
-			policyType := metrics.Cluster
-			policyNamespace := "" // doesn't matter for cluster policy
-			policyName := inputPolicy.GetName()
-			ruleName := rule.Name
-			ruleType := metrics.ParseRuleType(rule)
-			ready := inputPolicy.IsReady()
-
-			if err = pc.registerPolicyRuleInfoMetric(policyValidationMode, policyType, policyBackgroundMode, policyNamespace, policyName, ruleName, ruleType, PolicyRuleDeleted, ready); err != nil {
-				return err
-			}
-		}
-		return nil
-	case *kyverno.Policy:
-		for _, rule := range autogen.ComputeRules(inputPolicy) {
-			policyValidationMode, err := metrics.ParsePolicyValidationMode(inputPolicy.Spec.GetValidationFailureAction())
-			if err != nil {
-				return err
-			}
-			policyBackgroundMode := metrics.ParsePolicyBackgroundMode(inputPolicy)
-			policyType := metrics.Namespaced
-			policyNamespace := inputPolicy.GetNamespace()
-			policyName := inputPolicy.GetName()
-			ruleName := rule.Name
-			ruleType := metrics.ParseRuleType(rule)
-			ready := inputPolicy.IsReady()
-
-			if err = pc.registerPolicyRuleInfoMetric(policyValidationMode, policyType, policyBackgroundMode, policyNamespace, policyName, ruleName, ruleType, PolicyRuleDeleted, ready); err != nil {
-				return err
-			}
-		}
-		return nil
-	default:
-		return fmt.Errorf("wrong input type provided %T. Only kyverno.Policy and kyverno.ClusterPolicy allowed", inputPolicy)
-	}
-
 }

pkg/metrics/policyruleinfo/types.go

@@ -1,16 +1,8 @@
 package policyruleinfo
 
-import (
-	"github.com/kyverno/kyverno/pkg/metrics"
-)
-
 type PolicyRuleInfoMetricChangeType string
 
 const (
 	PolicyRuleCreated PolicyRuleInfoMetricChangeType = "created"
 	PolicyRuleDeleted PolicyRuleInfoMetricChangeType = "deleted"
 )
-
-type PromMetrics metrics.PromMetrics
-
-type PromConfig metrics.PromConfig

pkg/policy/existing.go

@@ -62,13 +62,13 @@ func (pc *PolicyController) applyAndReportPerNamespace(policy kyverno.PolicyInte
 }
 
 func (pc *PolicyController) registerPolicyResultsMetricValidation(logger logr.Logger, policy kyverno.PolicyInterface, engineResponse response.EngineResponse) {
-	if err := policyResults.ParsePromConfig(*pc.promConfig).ProcessEngineResponse(policy, engineResponse, metrics.BackgroundScan, metrics.ResourceCreated); err != nil {
+	if err := policyResults.ProcessEngineResponse(pc.promConfig, policy, engineResponse, metrics.BackgroundScan, metrics.ResourceCreated); err != nil {
 		logger.Error(err, "error occurred while registering kyverno_policy_results_total metrics for the above policy", "name", policy.GetName())
 	}
 }
 
 func (pc *PolicyController) registerPolicyExecutionDurationMetricValidate(logger logr.Logger, policy kyverno.PolicyInterface, engineResponse response.EngineResponse) {
-	if err := policyExecutionDuration.ParsePromConfig(*pc.promConfig).ProcessEngineResponse(policy, engineResponse, metrics.BackgroundScan, "", metrics.ResourceCreated); err != nil {
+	if err := policyExecutionDuration.ProcessEngineResponse(pc.promConfig, policy, engineResponse, metrics.BackgroundScan, "", metrics.ResourceCreated); err != nil {
 		logger.Error(err, "error occurred while registering kyverno_policy_execution_duration_seconds metrics for the above policy", "name", policy.GetName())
 	}
 }

pkg/policy/metrics.go

@@ -10,7 +10,7 @@ import (
 )
 
 func (pc *PolicyController) registerPolicyRuleInfoMetricAddPolicy(logger logr.Logger, p kyverno.PolicyInterface) {
-	err := policyRuleInfoMetric.ParsePromConfig(*pc.promConfig).AddPolicy(p)
+	err := policyRuleInfoMetric.AddPolicy(pc.promConfig, p)
 	if err != nil {
 		logger.Error(err, "error occurred while registering kyverno_policy_rule_info_total metrics for the above policy's creation", "name", p.GetName())
 	}
@@ -18,26 +18,26 @@ func (pc *PolicyController) registerPolicyRuleInfoMetricAddPolicy(logger logr.Lo
 
 func (pc *PolicyController) registerPolicyRuleInfoMetricUpdatePolicy(logger logr.Logger, oldP, curP kyverno.PolicyInterface) {
 	// removing the old rules associated metrics
-	err := policyRuleInfoMetric.ParsePromConfig(*pc.promConfig).RemovePolicy(oldP)
+	err := policyRuleInfoMetric.RemovePolicy(pc.promConfig, oldP)
 	if err != nil {
 		logger.Error(err, "error occurred while registering kyverno_policy_rule_info_total metrics for the above policy's updation", "name", oldP.GetName())
 	}
 	// adding the new rules associated metrics
-	err = policyRuleInfoMetric.ParsePromConfig(*pc.promConfig).AddPolicy(curP)
+	err = policyRuleInfoMetric.AddPolicy(pc.promConfig, curP)
 	if err != nil {
 		logger.Error(err, "error occurred while registering kyverno_policy_rule_info_total metrics for the above policy's updation", "name", oldP.GetName())
 	}
 }
 
 func (pc *PolicyController) registerPolicyRuleInfoMetricDeletePolicy(logger logr.Logger, p kyverno.PolicyInterface) {
-	err := policyRuleInfoMetric.ParsePromConfig(*pc.promConfig).RemovePolicy(p)
+	err := policyRuleInfoMetric.RemovePolicy(pc.promConfig, p)
 	if err != nil {
 		logger.Error(err, "error occurred while registering kyverno_policy_rule_info_total metrics for the above policy's deletion", "name", p.GetName())
 	}
 }
 
 func (pc *PolicyController) registerPolicyChangesMetricAddPolicy(logger logr.Logger, p kyverno.PolicyInterface) {
-	err := policyChangesMetric.ParsePromConfig(*pc.promConfig).RegisterPolicy(p, policyChangesMetric.PolicyCreated)
+	err := policyChangesMetric.RegisterPolicy(pc.promConfig, p, policyChangesMetric.PolicyCreated)
 	if err != nil {
 		logger.Error(err, "error occurred while registering kyverno_policy_changes_total metrics for the above policy's creation", "name", p.GetName())
 	}
@@ -49,13 +49,13 @@ func (pc *PolicyController) registerPolicyChangesMetricUpdatePolicy(logger logr.
 	if reflect.DeepEqual(oldSpec, curSpec) {
 		return
 	}
-	err := policyChangesMetric.ParsePromConfig(*pc.promConfig).RegisterPolicy(oldP, policyChangesMetric.PolicyUpdated)
+	err := policyChangesMetric.RegisterPolicy(pc.promConfig, oldP, policyChangesMetric.PolicyUpdated)
 	if err != nil {
 		logger.Error(err, "error occurred while registering kyverno_policy_changes_total metrics for the above policy's updation", "name", oldP.GetName())
 	}
 	// curP will require a new kyverno_policy_changes_total metric if the above update involved change in the following fields:
 	if curSpec.BackgroundProcessingEnabled() != oldSpec.BackgroundProcessingEnabled() || curSpec.GetValidationFailureAction() != oldSpec.GetValidationFailureAction() {
-		err = policyChangesMetric.ParsePromConfig(*pc.promConfig).RegisterPolicy(curP, policyChangesMetric.PolicyUpdated)
+		err = policyChangesMetric.RegisterPolicy(pc.promConfig, curP, policyChangesMetric.PolicyUpdated)
 		if err != nil {
 			logger.Error(err, "error occurred while registering kyverno_policy_changes_total metrics for the above policy's updation", "name", curP.GetName())
 		}
@@ -63,14 +63,14 @@ func (pc *PolicyController) registerPolicyChangesMetricUpdatePolicy(logger logr.
 }
 
 func (pc *PolicyController) registerPolicyChangesMetricDeletePolicy(logger logr.Logger, p kyverno.PolicyInterface) {
-	err := policyChangesMetric.ParsePromConfig(*pc.promConfig).RegisterPolicy(p, policyChangesMetric.PolicyDeleted)
+	err := policyChangesMetric.RegisterPolicy(pc.promConfig, p, policyChangesMetric.PolicyDeleted)
 	if err != nil {
 		logger.Error(err, "error occurred while registering kyverno_policy_changes_total metrics for the above policy's deletion", "name", p.GetName())
 	}
 }
 
 func (pc *PolicyController) registerPolicyRuleInfoMetricDeleteNsPolicy(logger logr.Logger, p *kyverno.Policy) {
-	err := policyRuleInfoMetric.ParsePromConfig(*pc.promConfig).RemovePolicy(p)
+	err := policyRuleInfoMetric.RemovePolicy(pc.promConfig, p)
 	if err != nil {
 		logger.Error(err, "error occurred while registering kyverno_policy_rule_info_total metrics for the above policy's deletion", "name", p.Name)
 	}

pkg/webhooks/metrics.go

@@ -30,7 +30,7 @@ func registerMetric(logger logr.Logger, m string, requestOperation string, r rep
 
 func (ws *WebhookServer) registerAdmissionReviewDurationMetricMutate(logger logr.Logger, requestOperation string, engineResponses []*response.EngineResponse, admissionReviewLatencyDuration int64) {
 	registerMetric(logger, "kyverno_admission_review_duration_seconds", requestOperation, func(op metrics.ResourceRequestOperation) error {
-		return admissionReviewDuration.ParsePromConfig(*ws.promConfig).ProcessEngineResponses(engineResponses, admissionReviewLatencyDuration, op)
+		return admissionReviewDuration.ProcessEngineResponses(ws.promConfig, engineResponses, admissionReviewLatencyDuration, op)
 	})
 }
 
@@ -38,13 +38,13 @@ func (ws *WebhookServer) registerAdmissionReviewDurationMetricGenerate(logger lo
 	defer close(*latencyReceiver)
 	defer close(*engineResponsesReceiver)
 	registerMetric(logger, "kyverno_admission_review_duration_seconds", requestOperation, func(op metrics.ResourceRequestOperation) error {
-		return admissionReviewDuration.ParsePromConfig(*ws.promConfig).ProcessEngineResponses(<-(*engineResponsesReceiver), <-(*latencyReceiver), op)
+		return admissionReviewDuration.ProcessEngineResponses(ws.promConfig, <-(*engineResponsesReceiver), <-(*latencyReceiver), op)
 	})
 }
 
 func registerAdmissionReviewDurationMetricValidate(logger logr.Logger, promConfig *metrics.PromConfig, requestOperation string, engineResponses []*response.EngineResponse, admissionReviewLatencyDuration int64) {
 	registerMetric(logger, "kyverno_admission_review_duration_seconds", requestOperation, func(op metrics.ResourceRequestOperation) error {
-		return admissionReviewDuration.ParsePromConfig(*promConfig).ProcessEngineResponses(engineResponses, admissionReviewLatencyDuration, op)
+		return admissionReviewDuration.ProcessEngineResponses(promConfig, engineResponses, admissionReviewLatencyDuration, op)
 	})
 }
 
@@ -52,20 +52,20 @@ func registerAdmissionReviewDurationMetricValidate(logger logr.Logger, promConfi
 
 func (ws *WebhookServer) registerAdmissionRequestsMetricMutate(logger logr.Logger, requestOperation string, engineResponses []*response.EngineResponse) {
 	registerMetric(logger, "kyverno_admission_requests_total", requestOperation, func(op metrics.ResourceRequestOperation) error {
-		return admissionRequests.ParsePromConfig(*ws.promConfig).ProcessEngineResponses(engineResponses, op)
+		return admissionRequests.ProcessEngineResponses(ws.promConfig, engineResponses, op)
 	})
 }
 
 func (ws *WebhookServer) registerAdmissionRequestsMetricGenerate(logger logr.Logger, requestOperation string, engineResponsesReceiver *chan []*response.EngineResponse) {
 	defer close(*engineResponsesReceiver)
 	registerMetric(logger, "kyverno_admission_requests_total", requestOperation, func(op metrics.ResourceRequestOperation) error {
-		return admissionRequests.ParsePromConfig(*ws.promConfig).ProcessEngineResponses(<-(*engineResponsesReceiver), op)
+		return admissionRequests.ProcessEngineResponses(ws.promConfig, <-(*engineResponsesReceiver), op)
 	})
 }
 
 func registerAdmissionRequestsMetricValidate(logger logr.Logger, promConfig *metrics.PromConfig, requestOperation string, engineResponses []*response.EngineResponse) {
 	registerMetric(logger, "kyverno_admission_requests_total", requestOperation, func(op metrics.ResourceRequestOperation) error {
-		return admissionRequests.ParsePromConfig(*promConfig).ProcessEngineResponses(engineResponses, op)
+		return admissionRequests.ProcessEngineResponses(promConfig, engineResponses, op)
 	})
 }
 
@@ -73,19 +73,19 @@ func registerAdmissionRequestsMetricValidate(logger logr.Logger, promConfig *met
 
 func (ws *WebhookServer) registerPolicyResultsMetricMutation(logger logr.Logger, requestOperation string, policy kyverno.PolicyInterface, engineResponse response.EngineResponse) {
 	registerMetric(logger, "kyverno_policy_results_total", requestOperation, func(op metrics.ResourceRequestOperation) error {
-		return policyResults.ParsePromConfig(*ws.promConfig).ProcessEngineResponse(policy, engineResponse, metrics.AdmissionRequest, op)
+		return policyResults.ProcessEngineResponse(ws.promConfig, policy, engineResponse, metrics.AdmissionRequest, op)
 	})
 }
 
 func registerPolicyResultsMetricValidation(logger logr.Logger, promConfig *metrics.PromConfig, requestOperation string, policy v1.PolicyInterface, engineResponse response.EngineResponse) {
 	registerMetric(logger, "kyverno_policy_results_total", requestOperation, func(op metrics.ResourceRequestOperation) error {
-		return policyResults.ParsePromConfig(*promConfig).ProcessEngineResponse(policy, engineResponse, metrics.AdmissionRequest, op)
+		return policyResults.ProcessEngineResponse(promConfig, policy, engineResponse, metrics.AdmissionRequest, op)
 	})
 }
 
 func (ws *WebhookServer) registerPolicyResultsMetricGeneration(logger logr.Logger, requestOperation string, policy kyverno.PolicyInterface, engineResponse response.EngineResponse) {
 	registerMetric(logger, "kyverno_policy_results_total", requestOperation, func(op metrics.ResourceRequestOperation) error {
-		return policyResults.ParsePromConfig(*ws.promConfig).ProcessEngineResponse(policy, engineResponse, metrics.AdmissionRequest, op)
+		return policyResults.ProcessEngineResponse(ws.promConfig, policy, engineResponse, metrics.AdmissionRequest, op)
 	})
 }
 
@@ -93,18 +93,18 @@ func (ws *WebhookServer) registerPolicyResultsMetricGeneration(logger logr.Logge
 
 func (ws *WebhookServer) registerPolicyExecutionDurationMetricMutate(logger logr.Logger, requestOperation string, policy kyverno.PolicyInterface, engineResponse response.EngineResponse) {
 	registerMetric(logger, "kyverno_policy_execution_duration_seconds", requestOperation, func(op metrics.ResourceRequestOperation) error {
-		return policyExecutionDuration.ParsePromConfig(*ws.promConfig).ProcessEngineResponse(policy, engineResponse, metrics.AdmissionRequest, "", op)
+		return policyExecutionDuration.ProcessEngineResponse(ws.promConfig, policy, engineResponse, metrics.AdmissionRequest, "", op)
 	})
 }
 
 func registerPolicyExecutionDurationMetricValidate(logger logr.Logger, promConfig *metrics.PromConfig, requestOperation string, policy v1.PolicyInterface, engineResponse response.EngineResponse) {
 	registerMetric(logger, "kyverno_policy_execution_duration_seconds", requestOperation, func(op metrics.ResourceRequestOperation) error {
-		return policyExecutionDuration.ParsePromConfig(*promConfig).ProcessEngineResponse(policy, engineResponse, metrics.AdmissionRequest, "", op)
+		return policyExecutionDuration.ProcessEngineResponse(promConfig, policy, engineResponse, metrics.AdmissionRequest, "", op)
 	})
 }
 
 func (ws *WebhookServer) registerPolicyExecutionDurationMetricGenerate(logger logr.Logger, requestOperation string, policy kyverno.PolicyInterface, engineResponse response.EngineResponse) {
 	registerMetric(logger, "kyverno_policy_execution_duration_seconds", requestOperation, func(op metrics.ResourceRequestOperation) error {
-		return policyExecutionDuration.ParsePromConfig(*ws.promConfig).ProcessEngineResponse(policy, engineResponse, metrics.AdmissionRequest, "", op)
+		return policyExecutionDuration.ProcessEngineResponse(ws.promConfig, policy, engineResponse, metrics.AdmissionRequest, "", op)
 	})
 }