mirrors/kyverno
mirrors/kyverno
1
0
Fork 0
mirror of https://github.com/kyverno/kyverno.git synced 2025-03-28 18:38:40 +00:00
Code Activity

refactor: metrics package (#3549)

Browse source 
* 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>
This commit is contained in:
Charles-Edouard Brétéché 2022-04-06 20:14:13 +02:00 • committed by GitHub
parent ae89aabb56
commit 98598e33cf
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
23 changed files with 119 additions and 373 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
api/kyverno/v1/policy_interface.go
View file

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

20
pkg/metrics/admissionrequests/admissionRequests.go
View file

@ -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)
}

13
pkg/metrics/admissionrequests/parsers.go
View file

@ -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)
}

9
pkg/metrics/admissionrequests/types.go
View file

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

20
pkg/metrics/admissionreviewduration/admissionReviewDuration.go
View file

@ -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)
}

13
pkg/metrics/admissionreviewduration/parsers.go
View file

@ -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)
}

9
pkg/metrics/admissionreviewduration/types.go
View file

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

27
pkg/metrics/parsers.go
View file

@ -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
}

13
pkg/metrics/policychanges/parsers.go
View file

@ -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)
}

41
pkg/metrics/policychanges/policyChanges.go
View file

@ -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 {
switch inputPolicy := policy.(type) {
case *kyverno.ClusterPolicy:
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()
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)
func RegisterPolicy(pc *metrics.PromConfig, policy kyverno.PolicyInterface, policyChangeType PolicyChangeType) error {
name, namespace, policyType, backgroundMode, validationMode, err := metrics.GetPolicyInfos(policy)
if err != nil {
return err
}
if err = registerPolicyChangesMetric(pc, validationMode, policyType, backgroundMode, namespace, name, policyChangeType); err != nil {
return err
}
return nil
}

8
pkg/metrics/policychanges/types.go
View file

@ -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

27
pkg/metrics/policyexecutionduration/parsers.go
View file

@ -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
}
}

33
pkg/metrics/policyexecutionduration/policyExecutionDuration.go
View file

@ -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 {
policyValidationMode, err := metrics.ParsePolicyValidationMode(policy.GetSpec().GetValidationFailureAction())
func ProcessEngineResponse(pc *metrics.PromConfig, policy kyverno.PolicyInterface, engineResponse response.EngineResponse, executionCause metrics.RuleExecutionCause, generateRuleLatencyType string, resourceRequestOperation metrics.ResourceRequestOperation) error {
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 := pc.registerPolicyExecutionDurationMetric(
policyValidationMode,
if err := registerPolicyExecutionDurationMetric(
pc,
validationMode,
policyType,
policyBackgroundMode,
policyNamespace, policyName,
backgroundMode,
namespace, name,
resourceKind, resourceNamespace,
resourceRequestOperation,
ruleName,

9
pkg/metrics/policyexecutionduration/types.go
View file

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

27
pkg/metrics/policyresults/parsers.go
View file

@ -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
}
}

32
pkg/metrics/policyresults/policyResults.go
View file

@ -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 {
policyValidationMode, err := metrics.ParsePolicyValidationMode(policy.GetSpec().GetValidationFailureAction())
func ProcessEngineResponse(pc *metrics.PromConfig, policy kyverno.PolicyInterface, engineResponse response.EngineResponse, executionCause metrics.RuleExecutionCause, resourceRequestOperation metrics.ResourceRequestOperation) error {
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 := pc.registerPolicyResultsMetric(
policyValidationMode,
if err := registerPolicyResultsMetric(
pc,
validationMode,
policyType,
policyBackgroundMode,
policyNamespace, policyName,
backgroundMode,
namespace, name,
resourceKind, resourceNamespace,
resourceRequestOperation,
ruleName,

9
pkg/metrics/policyresults/types.go
View file

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

10
pkg/metrics/policyruleinfo/parsers.go
View file

@ -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)
}

117
pkg/metrics/policyruleinfo/policyRuleInfo.go
View file

@ -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 {
switch inputPolicy := policy.(type) {
case *kyverno.ClusterPolicy:
policyValidationMode, err := metrics.ParsePolicyValidationMode(inputPolicy.Spec.GetValidationFailureAction())
if err != nil {
func AddPolicy(pc *metrics.PromConfig, policy kyverno.PolicyInterface) error {
name, namespace, policyType, backgroundMode, validationMode, err := metrics.GetPolicyInfos(policy)
if err != nil {
return err
}
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
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)
}
return nil
}
if err = pc.registerPolicyRuleInfoMetric(policyValidationMode, policyType, policyBackgroundMode, policyNamespace, policyName, ruleName, ruleType, PolicyRuleCreated, ready); err != nil {
return err
}
}
return nil
case *kyverno.Policy:
policyValidationMode, err := metrics.ParsePolicyValidationMode(inputPolicy.Spec.GetValidationFailureAction())
if err != nil {
func RemovePolicy(pc *metrics.PromConfig, policy kyverno.PolicyInterface) error {
name, namespace, policyType, backgroundMode, validationMode, err := metrics.GetPolicyInfos(policy)
if err != nil {
return err
}
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, 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)
}
}
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)
}
return nil
}

8
pkg/metrics/policyruleinfo/types.go
View file

@ -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

4
pkg/policy/existing.go
View file

@ -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())
}
}

18
pkg/policy/metrics.go
View file

@ -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)
}

24
pkg/webhooks/metrics.go
View file

@ -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)
})
}