From 4ccec04bfa82d64e19d9b60c639fa4f2fa4b5b97 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Charles-Edouard=20Br=C3=A9t=C3=A9ch=C3=A9?= Date: Tue, 22 Nov 2022 15:26:49 +0100 Subject: [PATCH] feat: add discovery support in instrumented clients (#5437) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat: add discovery support in instrumented clients Signed-off-by: Charles-Edouard Brétéché * fix tracing Signed-off-by: Charles-Edouard Brétéché Signed-off-by: Charles-Edouard Brétéché --- hack/main.go | 68 ++++-- pkg/clients/kube/clientset.generated.go | 107 ++++----- .../kube/corev1/events/resource.generated.go | 61 +++++ .../kube/corev1/pods/resource.generated.go | 18 ++ .../corev1/services/resource.generated.go | 9 + .../kube/discovery/resource.generated.go | 219 ++++++++++++++++++ .../events/resource.generated.go | 39 ++++ pkg/clients/kyverno/clientset.generated.go | 25 +- .../kyverno/discovery/resource.generated.go | 219 ++++++++++++++++++ 9 files changed, 680 insertions(+), 85 deletions(-) create mode 100644 pkg/clients/kube/discovery/resource.generated.go create mode 100644 pkg/clients/kyverno/discovery/resource.generated.go diff --git a/hack/main.go b/hack/main.go index 03f60dc93e..166f1ff158 100644 --- a/hack/main.go +++ b/hack/main.go @@ -94,6 +94,10 @@ func (c *withTracing) {{ $operation.Method.Name }}( {{- if $operation.HasContext }} ctx, span := tracing.StartSpan( arg0, + {{- else }} + _, span := tracing.StartSpan( + context.TODO(), + {{- end }} "", fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, {{ Quote $operation.Method.Name }}), attribute.String("client", c.client), @@ -101,6 +105,7 @@ func (c *withTracing) {{ $operation.Method.Name }}( attribute.String("operation", {{ Quote $operation.Method.Name }}), ) defer span.End() + {{- if $operation.HasContext }} arg0 = ctx {{- end }} {{ range $i, $ret := Returns $operation.Method }}ret{{ $i }}{{ if not $ret.IsLast -}},{{- end }} {{ end }} := c.inner.{{ $operation.Method.Name }}( @@ -112,7 +117,7 @@ func (c *withTracing) {{ $operation.Method.Name }}( {{- end -}} {{- end -}} ) - {{- if $operation.HasContext }} + {{- if $operation.HasError }} {{- range $i, $ret := Returns $operation.Method }} {{- if $ret.IsError }} if ret{{ $i }} != nil { @@ -194,21 +199,28 @@ import ( {{- range $package := Packages .Target.Type }} {{ Pkg $package }} {{ Quote $package }} {{- end }} + {{- range $resourceMethod, $resource := .Target.Resources }} + {{ ToLower $resourceMethod.Name }} "github.com/kyverno/kyverno/{{ $.Folder }}/{{ ToLower $resourceMethod.Name }}" + {{- end }} {{- range $clientMethod, $client := .Target.Clients }} {{ ToLower $clientMethod.Name }} "github.com/kyverno/kyverno/{{ $.Folder }}/{{ ToLower $clientMethod.Name }}" {{- end }} ) type clientset struct { - inner {{ GoType .Target }} + {{- range $resourceMethod, $resource := .Target.Resources }} + {{ ToLower $resourceMethod.Name }} {{ GoType $resource.Type }} + {{- end }} {{- range $clientMethod, $client := .Target.Clients }} {{ ToLower $clientMethod.Name }} {{ GoType $client.Type }} {{- end }} } -func (c *clientset) Discovery() discovery.DiscoveryInterface { - return c.inner.Discovery() +{{- range $resourceMethod, $resource := .Target.Resources }} +func (c *clientset) {{ $resourceMethod.Name }}() {{ GoType $resource.Type }}{ + return c.{{ ToLower $resourceMethod.Name }} } +{{- end }} {{- range $clientMethod, $client := .Target.Clients }} func (c *clientset) {{ $clientMethod.Name }}() {{ GoType $client.Type }}{ @@ -216,18 +228,22 @@ func (c *clientset) {{ $clientMethod.Name }}() {{ GoType $client.Type }}{ } {{- end }} -func WrapWithMetrics(inner {{ GoType .Target }}, metrics metrics.MetricsConfigManager, clientType metrics.ClientType) {{ GoType .Target }} { +func WrapWithMetrics(inner {{ GoType .Target }}, m metrics.MetricsConfigManager, clientType metrics.ClientType) {{ GoType .Target }} { return &clientset{ - inner: inner, + {{- range $resourceMethod, $resource := .Target.Resources }} + {{ ToLower $resourceMethod.Name }}: {{ ToLower $resourceMethod.Name }}.WithMetrics(inner.{{ $resourceMethod.Name }}(), metrics.ClusteredClientQueryRecorder(m, {{ Quote $resource.Kind }}, clientType)), + {{- end }} {{- range $clientMethod, $client := .Target.Clients }} - {{ ToLower $clientMethod.Name }}: {{ ToLower $clientMethod.Name }}.WithMetrics(inner.{{ $clientMethod.Name }}(), metrics, clientType), + {{ ToLower $clientMethod.Name }}: {{ ToLower $clientMethod.Name }}.WithMetrics(inner.{{ $clientMethod.Name }}(), m, clientType), {{- end }} } } func WrapWithTracing(inner {{ GoType .Target }}) {{ GoType .Target }} { return &clientset{ - inner: inner, + {{- range $resourceMethod, $resource := .Target.Resources }} + {{ ToLower $resourceMethod.Name }}: {{ ToLower $resourceMethod.Name }}.WithTracing(inner.{{ $resourceMethod.Name }}(), {{ Quote $resourceMethod.Name }}, ""), + {{- end }} {{- range $clientMethod, $client := .Target.Clients }} {{ ToLower $clientMethod.Name }}: {{ ToLower $clientMethod.Name }}.WithTracing(inner.{{ $clientMethod.Name }}(), {{ Quote $clientMethod.Name }}), {{- end }} @@ -337,7 +353,7 @@ func (r ret) IsError() bool { } type operation struct { - Method reflect.Method + reflect.Method } func (o operation) HasContext() bool { @@ -345,7 +361,12 @@ func (o operation) HasContext() bool { } func (o operation) HasError() bool { - return o.Method.Type.NumIn() > 0 && goType(o.Method.Type.In(o.Method.Type.NumIn()-1)) == "error" + for _, out := range getOuts(o.Method) { + if goType(out) == "error" { + return true + } + } + return false } type resource struct { @@ -370,7 +391,8 @@ type client struct { type clientset struct { reflect.Type - Clients map[reflect.Method]client + Clients map[reflect.Method]client + Resources map[resourceKey]resource } func getIns(in reflect.Method) []reflect.Type { @@ -469,15 +491,18 @@ func parseClient(in reflect.Type) client { return c } -func parse(in reflect.Type) clientset { +func parseClientset(in reflect.Type) clientset { cs := clientset{ - Type: in, - Clients: map[reflect.Method]client{}, + Type: in, + Clients: map[reflect.Method]client{}, + Resources: map[resourceKey]resource{}, } for _, clientMethod := range getMethods(in) { // client methods return only the client interface type if clientMethod.Type.NumOut() == 1 && clientMethod.Name != "Discovery" { cs.Clients[clientMethod] = parseClient(clientMethod.Type.Out(0)) + } else if clientMethod.Name == "Discovery" { + cs.Resources[resourceKey(clientMethod)] = parseResource(clientMethod.Type.Out(0)) } } return cs @@ -497,10 +522,10 @@ func parseImports(in reflect.Type) []string { for _, i := range getOuts(m) { pkg := i.PkgPath() if i.Kind() == reflect.Pointer { - i.Elem().PkgPath() + pkg = i.Elem().PkgPath() } if pkg != "" { - imports.Insert(i.PkgPath()) + imports.Insert(pkg) } } } @@ -579,6 +604,9 @@ func generateClientset(cs clientset, folder string) { for m, c := range cs.Clients { generateClient(c, path.Join(folder, strings.ToLower(m.Name))) } + for m, r := range cs.Resources { + generateResource(r, path.Join(folder, strings.ToLower(m.Name))) + } } func generateInterface(cs clientset, folder string) { @@ -586,17 +614,17 @@ func generateInterface(cs clientset, folder string) { } func main() { - kube := parse(reflect.TypeOf((*kubernetes.Interface)(nil)).Elem()) + kube := parseClientset(reflect.TypeOf((*kubernetes.Interface)(nil)).Elem()) generateClientset(kube, "pkg/clients/kube") generateInterface(kube, "pkg/clients/kube") - kyverno := parse(reflect.TypeOf((*versioned.Interface)(nil)).Elem()) + kyverno := parseClientset(reflect.TypeOf((*versioned.Interface)(nil)).Elem()) generateClientset(kyverno, "pkg/clients/kyverno") generateInterface(kyverno, "pkg/clients/kyverno") - dynamicInterface := parse(reflect.TypeOf((*dynamic.Interface)(nil)).Elem()) + dynamicInterface := parseClientset(reflect.TypeOf((*dynamic.Interface)(nil)).Elem()) dynamicResource := parseResource(reflect.TypeOf((*dynamic.ResourceInterface)(nil)).Elem()) generateResource(dynamicResource, "pkg/clients/dynamic/resource") generateInterface(dynamicInterface, "pkg/clients/dynamic") - metadataInterface := parse(reflect.TypeOf((*metadata.Interface)(nil)).Elem()) + metadataInterface := parseClientset(reflect.TypeOf((*metadata.Interface)(nil)).Elem()) metadataResource := parseResource(reflect.TypeOf((*metadata.ResourceInterface)(nil)).Elem()) generateInterface(metadataInterface, "pkg/clients/metadata") generateResource(metadataResource, "pkg/clients/metadata/resource") diff --git a/pkg/clients/kube/clientset.generated.go b/pkg/clients/kube/clientset.generated.go index 2eeba218c3..1ad2273c36 100644 --- a/pkg/clients/kube/clientset.generated.go +++ b/pkg/clients/kube/clientset.generated.go @@ -21,6 +21,7 @@ import ( coordinationv1 "github.com/kyverno/kyverno/pkg/clients/kube/coordinationv1" coordinationv1beta1 "github.com/kyverno/kyverno/pkg/clients/kube/coordinationv1beta1" corev1 "github.com/kyverno/kyverno/pkg/clients/kube/corev1" + discovery "github.com/kyverno/kyverno/pkg/clients/kube/discovery" discoveryv1 "github.com/kyverno/kyverno/pkg/clients/kube/discoveryv1" discoveryv1beta1 "github.com/kyverno/kyverno/pkg/clients/kube/discoveryv1beta1" eventsv1 "github.com/kyverno/kyverno/pkg/clients/kube/eventsv1" @@ -48,7 +49,7 @@ import ( storagev1alpha1 "github.com/kyverno/kyverno/pkg/clients/kube/storagev1alpha1" storagev1beta1 "github.com/kyverno/kyverno/pkg/clients/kube/storagev1beta1" "github.com/kyverno/kyverno/pkg/metrics" - "k8s.io/client-go/discovery" + k8s_io_client_go_discovery "k8s.io/client-go/discovery" k8s_io_client_go_kubernetes "k8s.io/client-go/kubernetes" k8s_io_client_go_kubernetes_typed_admissionregistration_v1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1" k8s_io_client_go_kubernetes_typed_admissionregistration_v1beta1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1" @@ -99,7 +100,7 @@ import ( ) type clientset struct { - inner k8s_io_client_go_kubernetes.Interface + discovery k8s_io_client_go_discovery.DiscoveryInterface admissionregistrationv1 k8s_io_client_go_kubernetes_typed_admissionregistration_v1.AdmissionregistrationV1Interface admissionregistrationv1beta1 k8s_io_client_go_kubernetes_typed_admissionregistration_v1beta1.AdmissionregistrationV1beta1Interface appsv1 k8s_io_client_go_kubernetes_typed_apps_v1.AppsV1Interface @@ -148,8 +149,8 @@ type clientset struct { storagev1beta1 k8s_io_client_go_kubernetes_typed_storage_v1beta1.StorageV1beta1Interface } -func (c *clientset) Discovery() discovery.DiscoveryInterface { - return c.inner.Discovery() +func (c *clientset) Discovery() k8s_io_client_go_discovery.DiscoveryInterface { + return c.discovery } func (c *clientset) AdmissionregistrationV1() k8s_io_client_go_kubernetes_typed_admissionregistration_v1.AdmissionregistrationV1Interface { return c.admissionregistrationv1 @@ -290,61 +291,61 @@ func (c *clientset) StorageV1beta1() k8s_io_client_go_kubernetes_typed_storage_v return c.storagev1beta1 } -func WrapWithMetrics(inner k8s_io_client_go_kubernetes.Interface, metrics metrics.MetricsConfigManager, clientType metrics.ClientType) k8s_io_client_go_kubernetes.Interface { +func WrapWithMetrics(inner k8s_io_client_go_kubernetes.Interface, m metrics.MetricsConfigManager, clientType metrics.ClientType) k8s_io_client_go_kubernetes.Interface { return &clientset{ - inner: inner, - admissionregistrationv1: admissionregistrationv1.WithMetrics(inner.AdmissionregistrationV1(), metrics, clientType), - admissionregistrationv1beta1: admissionregistrationv1beta1.WithMetrics(inner.AdmissionregistrationV1beta1(), metrics, clientType), - appsv1: appsv1.WithMetrics(inner.AppsV1(), metrics, clientType), - appsv1beta1: appsv1beta1.WithMetrics(inner.AppsV1beta1(), metrics, clientType), - appsv1beta2: appsv1beta2.WithMetrics(inner.AppsV1beta2(), metrics, clientType), - authenticationv1: authenticationv1.WithMetrics(inner.AuthenticationV1(), metrics, clientType), - authenticationv1beta1: authenticationv1beta1.WithMetrics(inner.AuthenticationV1beta1(), metrics, clientType), - authorizationv1: authorizationv1.WithMetrics(inner.AuthorizationV1(), metrics, clientType), - authorizationv1beta1: authorizationv1beta1.WithMetrics(inner.AuthorizationV1beta1(), metrics, clientType), - autoscalingv1: autoscalingv1.WithMetrics(inner.AutoscalingV1(), metrics, clientType), - autoscalingv2: autoscalingv2.WithMetrics(inner.AutoscalingV2(), metrics, clientType), - autoscalingv2beta1: autoscalingv2beta1.WithMetrics(inner.AutoscalingV2beta1(), metrics, clientType), - autoscalingv2beta2: autoscalingv2beta2.WithMetrics(inner.AutoscalingV2beta2(), metrics, clientType), - batchv1: batchv1.WithMetrics(inner.BatchV1(), metrics, clientType), - batchv1beta1: batchv1beta1.WithMetrics(inner.BatchV1beta1(), metrics, clientType), - certificatesv1: certificatesv1.WithMetrics(inner.CertificatesV1(), metrics, clientType), - certificatesv1beta1: certificatesv1beta1.WithMetrics(inner.CertificatesV1beta1(), metrics, clientType), - coordinationv1: coordinationv1.WithMetrics(inner.CoordinationV1(), metrics, clientType), - coordinationv1beta1: coordinationv1beta1.WithMetrics(inner.CoordinationV1beta1(), metrics, clientType), - corev1: corev1.WithMetrics(inner.CoreV1(), metrics, clientType), - discoveryv1: discoveryv1.WithMetrics(inner.DiscoveryV1(), metrics, clientType), - discoveryv1beta1: discoveryv1beta1.WithMetrics(inner.DiscoveryV1beta1(), metrics, clientType), - eventsv1: eventsv1.WithMetrics(inner.EventsV1(), metrics, clientType), - eventsv1beta1: eventsv1beta1.WithMetrics(inner.EventsV1beta1(), metrics, clientType), - extensionsv1beta1: extensionsv1beta1.WithMetrics(inner.ExtensionsV1beta1(), metrics, clientType), - flowcontrolv1alpha1: flowcontrolv1alpha1.WithMetrics(inner.FlowcontrolV1alpha1(), metrics, clientType), - flowcontrolv1beta1: flowcontrolv1beta1.WithMetrics(inner.FlowcontrolV1beta1(), metrics, clientType), - flowcontrolv1beta2: flowcontrolv1beta2.WithMetrics(inner.FlowcontrolV1beta2(), metrics, clientType), - internalv1alpha1: internalv1alpha1.WithMetrics(inner.InternalV1alpha1(), metrics, clientType), - networkingv1: networkingv1.WithMetrics(inner.NetworkingV1(), metrics, clientType), - networkingv1alpha1: networkingv1alpha1.WithMetrics(inner.NetworkingV1alpha1(), metrics, clientType), - networkingv1beta1: networkingv1beta1.WithMetrics(inner.NetworkingV1beta1(), metrics, clientType), - nodev1: nodev1.WithMetrics(inner.NodeV1(), metrics, clientType), - nodev1alpha1: nodev1alpha1.WithMetrics(inner.NodeV1alpha1(), metrics, clientType), - nodev1beta1: nodev1beta1.WithMetrics(inner.NodeV1beta1(), metrics, clientType), - policyv1: policyv1.WithMetrics(inner.PolicyV1(), metrics, clientType), - policyv1beta1: policyv1beta1.WithMetrics(inner.PolicyV1beta1(), metrics, clientType), - rbacv1: rbacv1.WithMetrics(inner.RbacV1(), metrics, clientType), - rbacv1alpha1: rbacv1alpha1.WithMetrics(inner.RbacV1alpha1(), metrics, clientType), - rbacv1beta1: rbacv1beta1.WithMetrics(inner.RbacV1beta1(), metrics, clientType), - schedulingv1: schedulingv1.WithMetrics(inner.SchedulingV1(), metrics, clientType), - schedulingv1alpha1: schedulingv1alpha1.WithMetrics(inner.SchedulingV1alpha1(), metrics, clientType), - schedulingv1beta1: schedulingv1beta1.WithMetrics(inner.SchedulingV1beta1(), metrics, clientType), - storagev1: storagev1.WithMetrics(inner.StorageV1(), metrics, clientType), - storagev1alpha1: storagev1alpha1.WithMetrics(inner.StorageV1alpha1(), metrics, clientType), - storagev1beta1: storagev1beta1.WithMetrics(inner.StorageV1beta1(), metrics, clientType), + discovery: discovery.WithMetrics(inner.Discovery(), metrics.ClusteredClientQueryRecorder(m, "Discovery", clientType)), + admissionregistrationv1: admissionregistrationv1.WithMetrics(inner.AdmissionregistrationV1(), m, clientType), + admissionregistrationv1beta1: admissionregistrationv1beta1.WithMetrics(inner.AdmissionregistrationV1beta1(), m, clientType), + appsv1: appsv1.WithMetrics(inner.AppsV1(), m, clientType), + appsv1beta1: appsv1beta1.WithMetrics(inner.AppsV1beta1(), m, clientType), + appsv1beta2: appsv1beta2.WithMetrics(inner.AppsV1beta2(), m, clientType), + authenticationv1: authenticationv1.WithMetrics(inner.AuthenticationV1(), m, clientType), + authenticationv1beta1: authenticationv1beta1.WithMetrics(inner.AuthenticationV1beta1(), m, clientType), + authorizationv1: authorizationv1.WithMetrics(inner.AuthorizationV1(), m, clientType), + authorizationv1beta1: authorizationv1beta1.WithMetrics(inner.AuthorizationV1beta1(), m, clientType), + autoscalingv1: autoscalingv1.WithMetrics(inner.AutoscalingV1(), m, clientType), + autoscalingv2: autoscalingv2.WithMetrics(inner.AutoscalingV2(), m, clientType), + autoscalingv2beta1: autoscalingv2beta1.WithMetrics(inner.AutoscalingV2beta1(), m, clientType), + autoscalingv2beta2: autoscalingv2beta2.WithMetrics(inner.AutoscalingV2beta2(), m, clientType), + batchv1: batchv1.WithMetrics(inner.BatchV1(), m, clientType), + batchv1beta1: batchv1beta1.WithMetrics(inner.BatchV1beta1(), m, clientType), + certificatesv1: certificatesv1.WithMetrics(inner.CertificatesV1(), m, clientType), + certificatesv1beta1: certificatesv1beta1.WithMetrics(inner.CertificatesV1beta1(), m, clientType), + coordinationv1: coordinationv1.WithMetrics(inner.CoordinationV1(), m, clientType), + coordinationv1beta1: coordinationv1beta1.WithMetrics(inner.CoordinationV1beta1(), m, clientType), + corev1: corev1.WithMetrics(inner.CoreV1(), m, clientType), + discoveryv1: discoveryv1.WithMetrics(inner.DiscoveryV1(), m, clientType), + discoveryv1beta1: discoveryv1beta1.WithMetrics(inner.DiscoveryV1beta1(), m, clientType), + eventsv1: eventsv1.WithMetrics(inner.EventsV1(), m, clientType), + eventsv1beta1: eventsv1beta1.WithMetrics(inner.EventsV1beta1(), m, clientType), + extensionsv1beta1: extensionsv1beta1.WithMetrics(inner.ExtensionsV1beta1(), m, clientType), + flowcontrolv1alpha1: flowcontrolv1alpha1.WithMetrics(inner.FlowcontrolV1alpha1(), m, clientType), + flowcontrolv1beta1: flowcontrolv1beta1.WithMetrics(inner.FlowcontrolV1beta1(), m, clientType), + flowcontrolv1beta2: flowcontrolv1beta2.WithMetrics(inner.FlowcontrolV1beta2(), m, clientType), + internalv1alpha1: internalv1alpha1.WithMetrics(inner.InternalV1alpha1(), m, clientType), + networkingv1: networkingv1.WithMetrics(inner.NetworkingV1(), m, clientType), + networkingv1alpha1: networkingv1alpha1.WithMetrics(inner.NetworkingV1alpha1(), m, clientType), + networkingv1beta1: networkingv1beta1.WithMetrics(inner.NetworkingV1beta1(), m, clientType), + nodev1: nodev1.WithMetrics(inner.NodeV1(), m, clientType), + nodev1alpha1: nodev1alpha1.WithMetrics(inner.NodeV1alpha1(), m, clientType), + nodev1beta1: nodev1beta1.WithMetrics(inner.NodeV1beta1(), m, clientType), + policyv1: policyv1.WithMetrics(inner.PolicyV1(), m, clientType), + policyv1beta1: policyv1beta1.WithMetrics(inner.PolicyV1beta1(), m, clientType), + rbacv1: rbacv1.WithMetrics(inner.RbacV1(), m, clientType), + rbacv1alpha1: rbacv1alpha1.WithMetrics(inner.RbacV1alpha1(), m, clientType), + rbacv1beta1: rbacv1beta1.WithMetrics(inner.RbacV1beta1(), m, clientType), + schedulingv1: schedulingv1.WithMetrics(inner.SchedulingV1(), m, clientType), + schedulingv1alpha1: schedulingv1alpha1.WithMetrics(inner.SchedulingV1alpha1(), m, clientType), + schedulingv1beta1: schedulingv1beta1.WithMetrics(inner.SchedulingV1beta1(), m, clientType), + storagev1: storagev1.WithMetrics(inner.StorageV1(), m, clientType), + storagev1alpha1: storagev1alpha1.WithMetrics(inner.StorageV1alpha1(), m, clientType), + storagev1beta1: storagev1beta1.WithMetrics(inner.StorageV1beta1(), m, clientType), } } func WrapWithTracing(inner k8s_io_client_go_kubernetes.Interface) k8s_io_client_go_kubernetes.Interface { return &clientset{ - inner: inner, + discovery: discovery.WithTracing(inner.Discovery(), "Discovery", ""), admissionregistrationv1: admissionregistrationv1.WithTracing(inner.AdmissionregistrationV1(), "AdmissionregistrationV1"), admissionregistrationv1beta1: admissionregistrationv1beta1.WithTracing(inner.AdmissionregistrationV1beta1(), "AdmissionregistrationV1beta1"), appsv1: appsv1.WithTracing(inner.AppsV1(), "AppsV1"), diff --git a/pkg/clients/kube/corev1/events/resource.generated.go b/pkg/clients/kube/corev1/events/resource.generated.go index 767f23a7f6..8b9e98d560 100644 --- a/pkg/clients/kube/corev1/events/resource.generated.go +++ b/pkg/clients/kube/corev1/events/resource.generated.go @@ -131,7 +131,20 @@ func (c *withTracing) Create(arg0 context.Context, arg1 *k8s_io_api_core_v1.Even return ret0, ret1 } func (c *withTracing) CreateWithEventNamespace(arg0 *k8s_io_api_core_v1.Event) (*k8s_io_api_core_v1.Event, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "CreateWithEventNamespace"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "CreateWithEventNamespace"), + ) + defer span.End() ret0, ret1 := c.inner.CreateWithEventNamespace(arg0) + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } return ret0, ret1 } func (c *withTracing) Delete(arg0 context.Context, arg1 string, arg2 k8s_io_apimachinery_pkg_apis_meta_v1.DeleteOptions) error { @@ -189,6 +202,15 @@ func (c *withTracing) Get(arg0 context.Context, arg1 string, arg2 k8s_io_apimach return ret0, ret1 } func (c *withTracing) GetFieldSelector(arg0 *string, arg1 *string, arg2 *string, arg3 *string) k8s_io_apimachinery_pkg_fields.Selector { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "GetFieldSelector"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "GetFieldSelector"), + ) + defer span.End() ret0 := c.inner.GetFieldSelector(arg0, arg1, arg2, arg3) return ret0 } @@ -229,11 +251,37 @@ func (c *withTracing) Patch(arg0 context.Context, arg1 string, arg2 k8s_io_apima return ret0, ret1 } func (c *withTracing) PatchWithEventNamespace(arg0 *k8s_io_api_core_v1.Event, arg1 []uint8) (*k8s_io_api_core_v1.Event, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "PatchWithEventNamespace"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "PatchWithEventNamespace"), + ) + defer span.End() ret0, ret1 := c.inner.PatchWithEventNamespace(arg0, arg1) + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } return ret0, ret1 } func (c *withTracing) Search(arg0 *k8s_io_apimachinery_pkg_runtime.Scheme, arg1 k8s_io_apimachinery_pkg_runtime.Object) (*k8s_io_api_core_v1.EventList, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "Search"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "Search"), + ) + defer span.End() ret0, ret1 := c.inner.Search(arg0, arg1) + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } return ret0, ret1 } func (c *withTracing) Update(arg0 context.Context, arg1 *k8s_io_api_core_v1.Event, arg2 k8s_io_apimachinery_pkg_apis_meta_v1.UpdateOptions) (*k8s_io_api_core_v1.Event, error) { @@ -255,7 +303,20 @@ func (c *withTracing) Update(arg0 context.Context, arg1 *k8s_io_api_core_v1.Even return ret0, ret1 } func (c *withTracing) UpdateWithEventNamespace(arg0 *k8s_io_api_core_v1.Event) (*k8s_io_api_core_v1.Event, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "UpdateWithEventNamespace"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "UpdateWithEventNamespace"), + ) + defer span.End() ret0, ret1 := c.inner.UpdateWithEventNamespace(arg0) + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } return ret0, ret1 } func (c *withTracing) Watch(arg0 context.Context, arg1 k8s_io_apimachinery_pkg_apis_meta_v1.ListOptions) (k8s_io_apimachinery_pkg_watch.Interface, error) { diff --git a/pkg/clients/kube/corev1/pods/resource.generated.go b/pkg/clients/kube/corev1/pods/resource.generated.go index c9a7589572..1295dde889 100644 --- a/pkg/clients/kube/corev1/pods/resource.generated.go +++ b/pkg/clients/kube/corev1/pods/resource.generated.go @@ -292,6 +292,15 @@ func (c *withTracing) Get(arg0 context.Context, arg1 string, arg2 k8s_io_apimach return ret0, ret1 } func (c *withTracing) GetLogs(arg0 string, arg1 *k8s_io_api_core_v1.PodLogOptions) *k8s_io_client_go_rest.Request { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "GetLogs"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "GetLogs"), + ) + defer span.End() ret0 := c.inner.GetLogs(arg0, arg1) return ret0 } @@ -332,6 +341,15 @@ func (c *withTracing) Patch(arg0 context.Context, arg1 string, arg2 k8s_io_apima return ret0, ret1 } func (c *withTracing) ProxyGet(arg0 string, arg1 string, arg2 string, arg3 string, arg4 map[string]string) k8s_io_client_go_rest.ResponseWrapper { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ProxyGet"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ProxyGet"), + ) + defer span.End() ret0 := c.inner.ProxyGet(arg0, arg1, arg2, arg3, arg4) return ret0 } diff --git a/pkg/clients/kube/corev1/services/resource.generated.go b/pkg/clients/kube/corev1/services/resource.generated.go index 0421341de2..df0948ba5c 100644 --- a/pkg/clients/kube/corev1/services/resource.generated.go +++ b/pkg/clients/kube/corev1/services/resource.generated.go @@ -208,6 +208,15 @@ func (c *withTracing) Patch(arg0 context.Context, arg1 string, arg2 k8s_io_apima return ret0, ret1 } func (c *withTracing) ProxyGet(arg0 string, arg1 string, arg2 string, arg3 string, arg4 map[string]string) k8s_io_client_go_rest.ResponseWrapper { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ProxyGet"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ProxyGet"), + ) + defer span.End() ret0 := c.inner.ProxyGet(arg0, arg1, arg2, arg3, arg4) return ret0 } diff --git a/pkg/clients/kube/discovery/resource.generated.go b/pkg/clients/kube/discovery/resource.generated.go new file mode 100644 index 0000000000..5ad240046d --- /dev/null +++ b/pkg/clients/kube/discovery/resource.generated.go @@ -0,0 +1,219 @@ +package resource + +import ( + "context" + "fmt" + + github_com_google_gnostic_openapiv2 "github.com/google/gnostic/openapiv2" + "github.com/kyverno/kyverno/pkg/metrics" + "github.com/kyverno/kyverno/pkg/tracing" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/codes" + k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + k8s_io_apimachinery_pkg_version "k8s.io/apimachinery/pkg/version" + k8s_io_client_go_discovery "k8s.io/client-go/discovery" + k8s_io_client_go_openapi "k8s.io/client-go/openapi" + k8s_io_client_go_rest "k8s.io/client-go/rest" +) + +func WithMetrics(inner k8s_io_client_go_discovery.DiscoveryInterface, recorder metrics.Recorder) k8s_io_client_go_discovery.DiscoveryInterface { + return &withMetrics{inner, recorder} +} + +func WithTracing(inner k8s_io_client_go_discovery.DiscoveryInterface, client, kind string) k8s_io_client_go_discovery.DiscoveryInterface { + return &withTracing{inner, client, kind} +} + +type withMetrics struct { + inner k8s_io_client_go_discovery.DiscoveryInterface + recorder metrics.Recorder +} + +func (c *withMetrics) OpenAPISchema() (*github_com_google_gnostic_openapiv2.Document, error) { + defer c.recorder.Record("open_api_schema") + return c.inner.OpenAPISchema() +} +func (c *withMetrics) OpenAPIV3() k8s_io_client_go_openapi.Client { + defer c.recorder.Record("open_apiv3") + return c.inner.OpenAPIV3() +} +func (c *withMetrics) RESTClient() k8s_io_client_go_rest.Interface { + defer c.recorder.Record("rest_client") + return c.inner.RESTClient() +} +func (c *withMetrics) ServerGroups() (*k8s_io_apimachinery_pkg_apis_meta_v1.APIGroupList, error) { + defer c.recorder.Record("server_groups") + return c.inner.ServerGroups() +} +func (c *withMetrics) ServerGroupsAndResources() ([]*k8s_io_apimachinery_pkg_apis_meta_v1.APIGroup, []*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + defer c.recorder.Record("server_groups_and_resources") + return c.inner.ServerGroupsAndResources() +} +func (c *withMetrics) ServerPreferredNamespacedResources() ([]*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + defer c.recorder.Record("server_preferred_namespaced_resources") + return c.inner.ServerPreferredNamespacedResources() +} +func (c *withMetrics) ServerPreferredResources() ([]*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + defer c.recorder.Record("server_preferred_resources") + return c.inner.ServerPreferredResources() +} +func (c *withMetrics) ServerResourcesForGroupVersion(arg0 string) (*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + defer c.recorder.Record("server_resources_for_group_version") + return c.inner.ServerResourcesForGroupVersion(arg0) +} +func (c *withMetrics) ServerVersion() (*k8s_io_apimachinery_pkg_version.Info, error) { + defer c.recorder.Record("server_version") + return c.inner.ServerVersion() +} + +type withTracing struct { + inner k8s_io_client_go_discovery.DiscoveryInterface + client string + kind string +} + +func (c *withTracing) OpenAPISchema() (*github_com_google_gnostic_openapiv2.Document, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "OpenAPISchema"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "OpenAPISchema"), + ) + defer span.End() + ret0, ret1 := c.inner.OpenAPISchema() + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } + return ret0, ret1 +} +func (c *withTracing) OpenAPIV3() k8s_io_client_go_openapi.Client { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "OpenAPIV3"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "OpenAPIV3"), + ) + defer span.End() + ret0 := c.inner.OpenAPIV3() + return ret0 +} +func (c *withTracing) RESTClient() k8s_io_client_go_rest.Interface { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "RESTClient"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "RESTClient"), + ) + defer span.End() + ret0 := c.inner.RESTClient() + return ret0 +} +func (c *withTracing) ServerGroups() (*k8s_io_apimachinery_pkg_apis_meta_v1.APIGroupList, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ServerGroups"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ServerGroups"), + ) + defer span.End() + ret0, ret1 := c.inner.ServerGroups() + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } + return ret0, ret1 +} +func (c *withTracing) ServerGroupsAndResources() ([]*k8s_io_apimachinery_pkg_apis_meta_v1.APIGroup, []*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ServerGroupsAndResources"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ServerGroupsAndResources"), + ) + defer span.End() + ret0, ret1, ret2 := c.inner.ServerGroupsAndResources() + if ret2 != nil { + span.RecordError(ret2) + span.SetStatus(codes.Error, ret2.Error()) + } + return ret0, ret1, ret2 +} +func (c *withTracing) ServerPreferredNamespacedResources() ([]*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ServerPreferredNamespacedResources"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ServerPreferredNamespacedResources"), + ) + defer span.End() + ret0, ret1 := c.inner.ServerPreferredNamespacedResources() + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } + return ret0, ret1 +} +func (c *withTracing) ServerPreferredResources() ([]*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ServerPreferredResources"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ServerPreferredResources"), + ) + defer span.End() + ret0, ret1 := c.inner.ServerPreferredResources() + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } + return ret0, ret1 +} +func (c *withTracing) ServerResourcesForGroupVersion(arg0 string) (*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ServerResourcesForGroupVersion"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ServerResourcesForGroupVersion"), + ) + defer span.End() + ret0, ret1 := c.inner.ServerResourcesForGroupVersion(arg0) + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } + return ret0, ret1 +} +func (c *withTracing) ServerVersion() (*k8s_io_apimachinery_pkg_version.Info, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ServerVersion"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ServerVersion"), + ) + defer span.End() + ret0, ret1 := c.inner.ServerVersion() + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } + return ret0, ret1 +} diff --git a/pkg/clients/kube/eventsv1beta1/events/resource.generated.go b/pkg/clients/kube/eventsv1beta1/events/resource.generated.go index 6486c9fb18..a7c0467a46 100644 --- a/pkg/clients/kube/eventsv1beta1/events/resource.generated.go +++ b/pkg/clients/kube/eventsv1beta1/events/resource.generated.go @@ -121,7 +121,20 @@ func (c *withTracing) Create(arg0 context.Context, arg1 *k8s_io_api_events_v1bet return ret0, ret1 } func (c *withTracing) CreateWithEventNamespace(arg0 *k8s_io_api_events_v1beta1.Event) (*k8s_io_api_events_v1beta1.Event, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "CreateWithEventNamespace"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "CreateWithEventNamespace"), + ) + defer span.End() ret0, ret1 := c.inner.CreateWithEventNamespace(arg0) + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } return ret0, ret1 } func (c *withTracing) Delete(arg0 context.Context, arg1 string, arg2 k8s_io_apimachinery_pkg_apis_meta_v1.DeleteOptions) error { @@ -215,7 +228,20 @@ func (c *withTracing) Patch(arg0 context.Context, arg1 string, arg2 k8s_io_apima return ret0, ret1 } func (c *withTracing) PatchWithEventNamespace(arg0 *k8s_io_api_events_v1beta1.Event, arg1 []uint8) (*k8s_io_api_events_v1beta1.Event, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "PatchWithEventNamespace"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "PatchWithEventNamespace"), + ) + defer span.End() ret0, ret1 := c.inner.PatchWithEventNamespace(arg0, arg1) + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } return ret0, ret1 } func (c *withTracing) Update(arg0 context.Context, arg1 *k8s_io_api_events_v1beta1.Event, arg2 k8s_io_apimachinery_pkg_apis_meta_v1.UpdateOptions) (*k8s_io_api_events_v1beta1.Event, error) { @@ -237,7 +263,20 @@ func (c *withTracing) Update(arg0 context.Context, arg1 *k8s_io_api_events_v1bet return ret0, ret1 } func (c *withTracing) UpdateWithEventNamespace(arg0 *k8s_io_api_events_v1beta1.Event) (*k8s_io_api_events_v1beta1.Event, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "UpdateWithEventNamespace"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "UpdateWithEventNamespace"), + ) + defer span.End() ret0, ret1 := c.inner.UpdateWithEventNamespace(arg0) + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } return ret0, ret1 } func (c *withTracing) Watch(arg0 context.Context, arg1 k8s_io_apimachinery_pkg_apis_meta_v1.ListOptions) (k8s_io_apimachinery_pkg_watch.Interface, error) { diff --git a/pkg/clients/kyverno/clientset.generated.go b/pkg/clients/kyverno/clientset.generated.go index cc365a7322..2a8444083e 100644 --- a/pkg/clients/kyverno/clientset.generated.go +++ b/pkg/clients/kyverno/clientset.generated.go @@ -7,17 +7,18 @@ import ( github_com_kyverno_kyverno_pkg_client_clientset_versioned_typed_kyverno_v1alpha2 "github.com/kyverno/kyverno/pkg/client/clientset/versioned/typed/kyverno/v1alpha2" github_com_kyverno_kyverno_pkg_client_clientset_versioned_typed_kyverno_v1beta1 "github.com/kyverno/kyverno/pkg/client/clientset/versioned/typed/kyverno/v1beta1" github_com_kyverno_kyverno_pkg_client_clientset_versioned_typed_policyreport_v1alpha2 "github.com/kyverno/kyverno/pkg/client/clientset/versioned/typed/policyreport/v1alpha2" + discovery "github.com/kyverno/kyverno/pkg/clients/kyverno/discovery" kyvernov1 "github.com/kyverno/kyverno/pkg/clients/kyverno/kyvernov1" kyvernov1alpha1 "github.com/kyverno/kyverno/pkg/clients/kyverno/kyvernov1alpha1" kyvernov1alpha2 "github.com/kyverno/kyverno/pkg/clients/kyverno/kyvernov1alpha2" kyvernov1beta1 "github.com/kyverno/kyverno/pkg/clients/kyverno/kyvernov1beta1" wgpolicyk8sv1alpha2 "github.com/kyverno/kyverno/pkg/clients/kyverno/wgpolicyk8sv1alpha2" "github.com/kyverno/kyverno/pkg/metrics" - "k8s.io/client-go/discovery" + k8s_io_client_go_discovery "k8s.io/client-go/discovery" ) type clientset struct { - inner github_com_kyverno_kyverno_pkg_client_clientset_versioned.Interface + discovery k8s_io_client_go_discovery.DiscoveryInterface kyvernov1 github_com_kyverno_kyverno_pkg_client_clientset_versioned_typed_kyverno_v1.KyvernoV1Interface kyvernov1alpha1 github_com_kyverno_kyverno_pkg_client_clientset_versioned_typed_kyverno_v1alpha1.KyvernoV1alpha1Interface kyvernov1alpha2 github_com_kyverno_kyverno_pkg_client_clientset_versioned_typed_kyverno_v1alpha2.KyvernoV1alpha2Interface @@ -25,8 +26,8 @@ type clientset struct { wgpolicyk8sv1alpha2 github_com_kyverno_kyverno_pkg_client_clientset_versioned_typed_policyreport_v1alpha2.Wgpolicyk8sV1alpha2Interface } -func (c *clientset) Discovery() discovery.DiscoveryInterface { - return c.inner.Discovery() +func (c *clientset) Discovery() k8s_io_client_go_discovery.DiscoveryInterface { + return c.discovery } func (c *clientset) KyvernoV1() github_com_kyverno_kyverno_pkg_client_clientset_versioned_typed_kyverno_v1.KyvernoV1Interface { return c.kyvernov1 @@ -44,20 +45,20 @@ func (c *clientset) Wgpolicyk8sV1alpha2() github_com_kyverno_kyverno_pkg_client_ return c.wgpolicyk8sv1alpha2 } -func WrapWithMetrics(inner github_com_kyverno_kyverno_pkg_client_clientset_versioned.Interface, metrics metrics.MetricsConfigManager, clientType metrics.ClientType) github_com_kyverno_kyverno_pkg_client_clientset_versioned.Interface { +func WrapWithMetrics(inner github_com_kyverno_kyverno_pkg_client_clientset_versioned.Interface, m metrics.MetricsConfigManager, clientType metrics.ClientType) github_com_kyverno_kyverno_pkg_client_clientset_versioned.Interface { return &clientset{ - inner: inner, - kyvernov1: kyvernov1.WithMetrics(inner.KyvernoV1(), metrics, clientType), - kyvernov1alpha1: kyvernov1alpha1.WithMetrics(inner.KyvernoV1alpha1(), metrics, clientType), - kyvernov1alpha2: kyvernov1alpha2.WithMetrics(inner.KyvernoV1alpha2(), metrics, clientType), - kyvernov1beta1: kyvernov1beta1.WithMetrics(inner.KyvernoV1beta1(), metrics, clientType), - wgpolicyk8sv1alpha2: wgpolicyk8sv1alpha2.WithMetrics(inner.Wgpolicyk8sV1alpha2(), metrics, clientType), + discovery: discovery.WithMetrics(inner.Discovery(), metrics.ClusteredClientQueryRecorder(m, "Discovery", clientType)), + kyvernov1: kyvernov1.WithMetrics(inner.KyvernoV1(), m, clientType), + kyvernov1alpha1: kyvernov1alpha1.WithMetrics(inner.KyvernoV1alpha1(), m, clientType), + kyvernov1alpha2: kyvernov1alpha2.WithMetrics(inner.KyvernoV1alpha2(), m, clientType), + kyvernov1beta1: kyvernov1beta1.WithMetrics(inner.KyvernoV1beta1(), m, clientType), + wgpolicyk8sv1alpha2: wgpolicyk8sv1alpha2.WithMetrics(inner.Wgpolicyk8sV1alpha2(), m, clientType), } } func WrapWithTracing(inner github_com_kyverno_kyverno_pkg_client_clientset_versioned.Interface) github_com_kyverno_kyverno_pkg_client_clientset_versioned.Interface { return &clientset{ - inner: inner, + discovery: discovery.WithTracing(inner.Discovery(), "Discovery", ""), kyvernov1: kyvernov1.WithTracing(inner.KyvernoV1(), "KyvernoV1"), kyvernov1alpha1: kyvernov1alpha1.WithTracing(inner.KyvernoV1alpha1(), "KyvernoV1alpha1"), kyvernov1alpha2: kyvernov1alpha2.WithTracing(inner.KyvernoV1alpha2(), "KyvernoV1alpha2"), diff --git a/pkg/clients/kyverno/discovery/resource.generated.go b/pkg/clients/kyverno/discovery/resource.generated.go new file mode 100644 index 0000000000..5ad240046d --- /dev/null +++ b/pkg/clients/kyverno/discovery/resource.generated.go @@ -0,0 +1,219 @@ +package resource + +import ( + "context" + "fmt" + + github_com_google_gnostic_openapiv2 "github.com/google/gnostic/openapiv2" + "github.com/kyverno/kyverno/pkg/metrics" + "github.com/kyverno/kyverno/pkg/tracing" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/codes" + k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + k8s_io_apimachinery_pkg_version "k8s.io/apimachinery/pkg/version" + k8s_io_client_go_discovery "k8s.io/client-go/discovery" + k8s_io_client_go_openapi "k8s.io/client-go/openapi" + k8s_io_client_go_rest "k8s.io/client-go/rest" +) + +func WithMetrics(inner k8s_io_client_go_discovery.DiscoveryInterface, recorder metrics.Recorder) k8s_io_client_go_discovery.DiscoveryInterface { + return &withMetrics{inner, recorder} +} + +func WithTracing(inner k8s_io_client_go_discovery.DiscoveryInterface, client, kind string) k8s_io_client_go_discovery.DiscoveryInterface { + return &withTracing{inner, client, kind} +} + +type withMetrics struct { + inner k8s_io_client_go_discovery.DiscoveryInterface + recorder metrics.Recorder +} + +func (c *withMetrics) OpenAPISchema() (*github_com_google_gnostic_openapiv2.Document, error) { + defer c.recorder.Record("open_api_schema") + return c.inner.OpenAPISchema() +} +func (c *withMetrics) OpenAPIV3() k8s_io_client_go_openapi.Client { + defer c.recorder.Record("open_apiv3") + return c.inner.OpenAPIV3() +} +func (c *withMetrics) RESTClient() k8s_io_client_go_rest.Interface { + defer c.recorder.Record("rest_client") + return c.inner.RESTClient() +} +func (c *withMetrics) ServerGroups() (*k8s_io_apimachinery_pkg_apis_meta_v1.APIGroupList, error) { + defer c.recorder.Record("server_groups") + return c.inner.ServerGroups() +} +func (c *withMetrics) ServerGroupsAndResources() ([]*k8s_io_apimachinery_pkg_apis_meta_v1.APIGroup, []*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + defer c.recorder.Record("server_groups_and_resources") + return c.inner.ServerGroupsAndResources() +} +func (c *withMetrics) ServerPreferredNamespacedResources() ([]*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + defer c.recorder.Record("server_preferred_namespaced_resources") + return c.inner.ServerPreferredNamespacedResources() +} +func (c *withMetrics) ServerPreferredResources() ([]*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + defer c.recorder.Record("server_preferred_resources") + return c.inner.ServerPreferredResources() +} +func (c *withMetrics) ServerResourcesForGroupVersion(arg0 string) (*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + defer c.recorder.Record("server_resources_for_group_version") + return c.inner.ServerResourcesForGroupVersion(arg0) +} +func (c *withMetrics) ServerVersion() (*k8s_io_apimachinery_pkg_version.Info, error) { + defer c.recorder.Record("server_version") + return c.inner.ServerVersion() +} + +type withTracing struct { + inner k8s_io_client_go_discovery.DiscoveryInterface + client string + kind string +} + +func (c *withTracing) OpenAPISchema() (*github_com_google_gnostic_openapiv2.Document, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "OpenAPISchema"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "OpenAPISchema"), + ) + defer span.End() + ret0, ret1 := c.inner.OpenAPISchema() + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } + return ret0, ret1 +} +func (c *withTracing) OpenAPIV3() k8s_io_client_go_openapi.Client { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "OpenAPIV3"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "OpenAPIV3"), + ) + defer span.End() + ret0 := c.inner.OpenAPIV3() + return ret0 +} +func (c *withTracing) RESTClient() k8s_io_client_go_rest.Interface { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "RESTClient"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "RESTClient"), + ) + defer span.End() + ret0 := c.inner.RESTClient() + return ret0 +} +func (c *withTracing) ServerGroups() (*k8s_io_apimachinery_pkg_apis_meta_v1.APIGroupList, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ServerGroups"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ServerGroups"), + ) + defer span.End() + ret0, ret1 := c.inner.ServerGroups() + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } + return ret0, ret1 +} +func (c *withTracing) ServerGroupsAndResources() ([]*k8s_io_apimachinery_pkg_apis_meta_v1.APIGroup, []*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ServerGroupsAndResources"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ServerGroupsAndResources"), + ) + defer span.End() + ret0, ret1, ret2 := c.inner.ServerGroupsAndResources() + if ret2 != nil { + span.RecordError(ret2) + span.SetStatus(codes.Error, ret2.Error()) + } + return ret0, ret1, ret2 +} +func (c *withTracing) ServerPreferredNamespacedResources() ([]*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ServerPreferredNamespacedResources"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ServerPreferredNamespacedResources"), + ) + defer span.End() + ret0, ret1 := c.inner.ServerPreferredNamespacedResources() + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } + return ret0, ret1 +} +func (c *withTracing) ServerPreferredResources() ([]*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ServerPreferredResources"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ServerPreferredResources"), + ) + defer span.End() + ret0, ret1 := c.inner.ServerPreferredResources() + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } + return ret0, ret1 +} +func (c *withTracing) ServerResourcesForGroupVersion(arg0 string) (*k8s_io_apimachinery_pkg_apis_meta_v1.APIResourceList, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ServerResourcesForGroupVersion"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ServerResourcesForGroupVersion"), + ) + defer span.End() + ret0, ret1 := c.inner.ServerResourcesForGroupVersion(arg0) + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } + return ret0, ret1 +} +func (c *withTracing) ServerVersion() (*k8s_io_apimachinery_pkg_version.Info, error) { + _, span := tracing.StartSpan( + context.TODO(), + "", + fmt.Sprintf("KUBE %s/%s/%s", c.client, c.kind, "ServerVersion"), + attribute.String("client", c.client), + attribute.String("kind", c.kind), + attribute.String("operation", "ServerVersion"), + ) + defer span.End() + ret0, ret1 := c.inner.ServerVersion() + if ret1 != nil { + span.RecordError(ret1) + span.SetStatus(codes.Error, ret1.Error()) + } + return ret0, ret1 +}