From a6f5abfb81e6934e7e93f8c21e92330454ac72c6 Mon Sep 17 00:00:00 2001 From: Chinmay Chapla Date: Wed, 7 Jun 2023 19:34:33 +0000 Subject: [PATCH 1/2] Updating names from webhookconversion to conversionwebhook --- .../pkg/apiserver/conversion/metrics.go | 56 ++++++------ .../pkg/apiserver/conversion/metrics_test.go | 86 +++++++++---------- .../apiserver/conversion/webhook_converter.go | 40 ++++----- 3 files changed, 91 insertions(+), 91 deletions(-) diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/metrics.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/metrics.go index 11a80bf42a9..df24becb3fe 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/metrics.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/metrics.go @@ -59,7 +59,7 @@ func (c *converterMetricFactory) addMetrics(crdName string, converter crConverte if !exists { metric = metrics.NewHistogramVec( &metrics.HistogramOpts{ - Name: "apiserver_crd_webhook_conversion_duration_seconds", + Name: "apiserver_crd_conversion_webhook_duration_seconds", Help: "CRD webhook conversion duration in seconds", Buckets: latencyBuckets, StabilityLevel: metrics.ALPHA, @@ -88,42 +88,42 @@ func (m *converterMetric) Convert(in runtime.Object, targetGV schema.GroupVersio return obj, err } -type WebhookConversionErrorType string +type ConversionWebhookErrorType string const ( - WebhookConversionCallFailure WebhookConversionErrorType = "webhook_conversion_call_failure" - WebhookConversionMalformedResponseFailure WebhookConversionErrorType = "webhook_conversion_malformed_response_failure" - WebhookConversionPartialResponseFailure WebhookConversionErrorType = "webhook_conversion_partial_response_failure" - WebhookConversionInvalidConvertedObjectFailure WebhookConversionErrorType = "webhook_conversion_invalid_converted_object_failure" - WebhookConversionNoObjectsReturnedFailure WebhookConversionErrorType = "webhook_conversion_no_objects_returned_failure" + ConversionWebhookCallFailure ConversionWebhookErrorType = "conversion_webhook_call_failure" + ConversionWebhookMalformedResponseFailure ConversionWebhookErrorType = "conversion_webhook_malformed_response_failure" + ConversionWebhookPartialResponseFailure ConversionWebhookErrorType = "conversion_webhook_partial_response_failure" + ConversionWebhookInvalidConvertedObjectFailure ConversionWebhookErrorType = "conversion_webhook_invalid_converted_object_failure" + ConversionWebhookNoObjectsReturnedFailure ConversionWebhookErrorType = "conversion_webhook_no_objects_returned_failure" ) var ( - Metrics = newWebhookConversionMetrics() + Metrics = newConversionWebhookMetrics() namespace = "apiserver" ) -// WebhookConversionMetrics instruments webhook conversion with prometheus metrics. -type WebhookConversionMetrics struct { - webhookConversionRequest *metrics.CounterVec - webhookConversionLatency *metrics.HistogramVec +// ConversionWebhookMetrics instruments webhook conversion with prometheus metrics. +type ConversionWebhookMetrics struct { + conversionWebhookRequest *metrics.CounterVec + conversionWebhookLatency *metrics.HistogramVec } -func newWebhookConversionMetrics() *WebhookConversionMetrics { - webhookConversionRequest := metrics.NewCounterVec( +func newConversionWebhookMetrics() *ConversionWebhookMetrics { + conversionWebhookRequest := metrics.NewCounterVec( &metrics.CounterOpts{ - Name: "webhook_conversion_request_total", + Name: "conversion_webhook_request_total", Namespace: namespace, - Help: "Counter for webhook conversion requests with success/failure and failure error type", + Help: "Counter for conversion webhook requests with success/failure and failure error type", StabilityLevel: metrics.ALPHA, }, []string{"result", "failure_type"}) - webhookConversionLatency := metrics.NewHistogramVec( + conversionWebhookLatency := metrics.NewHistogramVec( &metrics.HistogramOpts{ - Name: "webhook_conversion_duration_seconds", + Name: "conversion_webhook_duration_seconds", Namespace: namespace, - Help: "Webhook conversion request latency", + Help: "Conversion webhook request latency", // Various buckets from 5 ms to 60 seconds Buckets: []float64{0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 30, 45, 60}, StabilityLevel: metrics.ALPHA, @@ -131,28 +131,28 @@ func newWebhookConversionMetrics() *WebhookConversionMetrics { []string{"result", "failure_type"}, ) - legacyregistry.MustRegister(webhookConversionRequest) - legacyregistry.MustRegister(webhookConversionLatency) + legacyregistry.MustRegister(conversionWebhookRequest) + legacyregistry.MustRegister(conversionWebhookLatency) - return &WebhookConversionMetrics{webhookConversionRequest: webhookConversionRequest, webhookConversionLatency: webhookConversionLatency} + return &ConversionWebhookMetrics{conversionWebhookRequest: conversionWebhookRequest, conversionWebhookLatency: conversionWebhookLatency} } // Observe successful request -func (m *WebhookConversionMetrics) ObserveWebhookConversionSuccess(ctx context.Context, elapsed time.Duration) { +func (m *ConversionWebhookMetrics) ObserveConversionWebhookSuccess(ctx context.Context, elapsed time.Duration) { result := "success" - m.webhookConversionRequest.WithContext(ctx).WithLabelValues(result, "").Inc() + m.conversionWebhookRequest.WithContext(ctx).WithLabelValues(result, "").Inc() m.observe(ctx, elapsed, result, "") } // Observe failure with failure type -func (m *WebhookConversionMetrics) ObserveWebhookConversionFailure(ctx context.Context, elapsed time.Duration, errorType WebhookConversionErrorType) { +func (m *ConversionWebhookMetrics) ObserveConversionWebhookFailure(ctx context.Context, elapsed time.Duration, errorType ConversionWebhookErrorType) { result := "failure" - m.webhookConversionRequest.WithContext(ctx).WithLabelValues(result, string(errorType)).Inc() + m.conversionWebhookRequest.WithContext(ctx).WithLabelValues(result, string(errorType)).Inc() m.observe(ctx, elapsed, result, errorType) } // Observe latency -func (m *WebhookConversionMetrics) observe(ctx context.Context, elapsed time.Duration, result string, errorType WebhookConversionErrorType) { +func (m *ConversionWebhookMetrics) observe(ctx context.Context, elapsed time.Duration, result string, errorType ConversionWebhookErrorType) { elapsedSeconds := elapsed.Seconds() - m.webhookConversionLatency.WithContext(ctx).WithLabelValues(result, string(errorType)).Observe(elapsedSeconds) + m.conversionWebhookLatency.WithContext(ctx).WithLabelValues(result, string(errorType)).Observe(elapsedSeconds) } diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/metrics_test.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/metrics_test.go index 2b99d5c8426..de6b3c1c737 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/metrics_test.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/metrics_test.go @@ -26,10 +26,10 @@ import ( "k8s.io/component-base/metrics/testutil" ) -func TestWebhookConversionMetrics_ObserveWebhookConversionSuccess(t *testing.T) { +func TestConversionWebhookMetrics_ObserveConversionWebhookSuccess(t *testing.T) { type fields struct { - webhookConversionRequest *metrics.CounterVec - webhookConversionLatency *metrics.HistogramVec + conversionWebhookRequest *metrics.CounterVec + conversionWebhookLatency *metrics.HistogramVec } type args struct { elapsed time.Duration @@ -44,8 +44,8 @@ func TestWebhookConversionMetrics_ObserveWebhookConversionSuccess(t *testing.T) { name: "test_conversion_success", fields: fields{ - webhookConversionRequest: Metrics.webhookConversionRequest, - webhookConversionLatency: Metrics.webhookConversionLatency, + conversionWebhookRequest: Metrics.conversionWebhookRequest, + conversionWebhookLatency: Metrics.conversionWebhookLatency, }, args: args{ elapsed: 2 * time.Second, @@ -58,8 +58,8 @@ func TestWebhookConversionMetrics_ObserveWebhookConversionSuccess(t *testing.T) }, { name: "test_conversion_success_2", fields: fields{ - webhookConversionRequest: Metrics.webhookConversionRequest, - webhookConversionLatency: Metrics.webhookConversionLatency, + conversionWebhookRequest: Metrics.conversionWebhookRequest, + conversionWebhookLatency: Metrics.conversionWebhookLatency, }, args: args{ elapsed: 2 * time.Second, @@ -73,25 +73,25 @@ func TestWebhookConversionMetrics_ObserveWebhookConversionSuccess(t *testing.T) } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - m := &WebhookConversionMetrics{ - webhookConversionRequest: tt.fields.webhookConversionRequest, - webhookConversionLatency: tt.fields.webhookConversionLatency, + m := &ConversionWebhookMetrics{ + conversionWebhookRequest: tt.fields.conversionWebhookRequest, + conversionWebhookLatency: tt.fields.conversionWebhookLatency, } - m.ObserveWebhookConversionSuccess(context.TODO(), tt.args.elapsed) - testutil.AssertVectorCount(t, fmt.Sprintf("%s_webhook_conversion_request_total", namespace), tt.wantLabels, tt.expectedRequestValue) - testutil.AssertHistogramTotalCount(t, fmt.Sprintf("%s_webhook_conversion_duration_seconds", namespace), tt.wantLabels, tt.expectedRequestValue) + m.ObserveConversionWebhookSuccess(context.TODO(), tt.args.elapsed) + testutil.AssertVectorCount(t, fmt.Sprintf("%s_conversion_webhook_request_total", namespace), tt.wantLabels, tt.expectedRequestValue) + testutil.AssertHistogramTotalCount(t, fmt.Sprintf("%s_conversion_webhook_duration_seconds", namespace), tt.wantLabels, tt.expectedRequestValue) }) } } -func TestWebhookConversionMetrics_ObserveWebhookConversionFailure(t *testing.T) { +func TestConversionWebhookMetrics_ObserveConversionWebhookFailure(t *testing.T) { type fields struct { - webhookConversionRequest *metrics.CounterVec - webhookConversionLatency *metrics.HistogramVec + conversionWebhookRequest *metrics.CounterVec + conversionWebhookLatency *metrics.HistogramVec } type args struct { elapsed time.Duration - errorType WebhookConversionErrorType + errorType ConversionWebhookErrorType } tests := []struct { name string @@ -104,80 +104,80 @@ func TestWebhookConversionMetrics_ObserveWebhookConversionFailure(t *testing.T) { name: "test_conversion_failure", fields: fields{ - webhookConversionRequest: Metrics.webhookConversionRequest, - webhookConversionLatency: Metrics.webhookConversionLatency, + conversionWebhookRequest: Metrics.conversionWebhookRequest, + conversionWebhookLatency: Metrics.conversionWebhookLatency, }, args: args{ elapsed: 2 * time.Second, - errorType: WebhookConversionCallFailure, + errorType: ConversionWebhookCallFailure, }, wantLabels: map[string]string{ "result": "failure", - "failure_type": string(WebhookConversionCallFailure), + "failure_type": string(ConversionWebhookCallFailure), }, expectedRequestValue: 1, expectedLatencyCount: 1, }, { name: "test_conversion_failure_2", fields: fields{ - webhookConversionRequest: Metrics.webhookConversionRequest, - webhookConversionLatency: Metrics.webhookConversionLatency, + conversionWebhookRequest: Metrics.conversionWebhookRequest, + conversionWebhookLatency: Metrics.conversionWebhookLatency, }, args: args{ elapsed: 2 * time.Second, - errorType: WebhookConversionMalformedResponseFailure, + errorType: ConversionWebhookMalformedResponseFailure, }, wantLabels: map[string]string{ "result": "failure", - "failure_type": string(WebhookConversionMalformedResponseFailure), + "failure_type": string(ConversionWebhookMalformedResponseFailure), }, expectedRequestValue: 1, expectedLatencyCount: 2, }, { name: "test_conversion_failure_3", fields: fields{ - webhookConversionRequest: Metrics.webhookConversionRequest, - webhookConversionLatency: Metrics.webhookConversionLatency, + conversionWebhookRequest: Metrics.conversionWebhookRequest, + conversionWebhookLatency: Metrics.conversionWebhookLatency, }, args: args{ elapsed: 2 * time.Second, - errorType: WebhookConversionPartialResponseFailure, + errorType: ConversionWebhookPartialResponseFailure, }, wantLabels: map[string]string{ "result": "failure", - "failure_type": string(WebhookConversionPartialResponseFailure), + "failure_type": string(ConversionWebhookPartialResponseFailure), }, expectedRequestValue: 1, expectedLatencyCount: 3, }, { name: "test_conversion_failure_4", fields: fields{ - webhookConversionRequest: Metrics.webhookConversionRequest, - webhookConversionLatency: Metrics.webhookConversionLatency, + conversionWebhookRequest: Metrics.conversionWebhookRequest, + conversionWebhookLatency: Metrics.conversionWebhookLatency, }, args: args{ elapsed: 2 * time.Second, - errorType: WebhookConversionInvalidConvertedObjectFailure, + errorType: ConversionWebhookInvalidConvertedObjectFailure, }, wantLabels: map[string]string{ "result": "failure", - "failure_type": string(WebhookConversionInvalidConvertedObjectFailure), + "failure_type": string(ConversionWebhookInvalidConvertedObjectFailure), }, expectedRequestValue: 1, expectedLatencyCount: 4, }, { name: "test_conversion_failure_5", fields: fields{ - webhookConversionRequest: Metrics.webhookConversionRequest, - webhookConversionLatency: Metrics.webhookConversionLatency, + conversionWebhookRequest: Metrics.conversionWebhookRequest, + conversionWebhookLatency: Metrics.conversionWebhookLatency, }, args: args{ elapsed: 2 * time.Second, - errorType: WebhookConversionNoObjectsReturnedFailure, + errorType: ConversionWebhookNoObjectsReturnedFailure, }, wantLabels: map[string]string{ "result": "failure", - "failure_type": string(WebhookConversionNoObjectsReturnedFailure), + "failure_type": string(ConversionWebhookNoObjectsReturnedFailure), }, expectedRequestValue: 1, expectedLatencyCount: 5, @@ -185,13 +185,13 @@ func TestWebhookConversionMetrics_ObserveWebhookConversionFailure(t *testing.T) } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - m := &WebhookConversionMetrics{ - webhookConversionRequest: tt.fields.webhookConversionRequest, - webhookConversionLatency: tt.fields.webhookConversionLatency, + m := &ConversionWebhookMetrics{ + conversionWebhookRequest: tt.fields.conversionWebhookRequest, + conversionWebhookLatency: tt.fields.conversionWebhookLatency, } - m.ObserveWebhookConversionFailure(context.TODO(), tt.args.elapsed, tt.args.errorType) - testutil.AssertVectorCount(t, fmt.Sprintf("%s_webhook_conversion_request_total", namespace), tt.wantLabels, tt.expectedRequestValue) - testutil.AssertHistogramTotalCount(t, fmt.Sprintf("%s_webhook_conversion_duration_seconds", namespace), tt.wantLabels, tt.expectedRequestValue) + m.ObserveConversionWebhookFailure(context.TODO(), tt.args.elapsed, tt.args.errorType) + testutil.AssertVectorCount(t, fmt.Sprintf("%s_conversion_webhook_request_total", namespace), tt.wantLabels, tt.expectedRequestValue) + testutil.AssertHistogramTotalCount(t, fmt.Sprintf("%s_conversion_webhook_duration_seconds", namespace), tt.wantLabels, tt.expectedRequestValue) }) } } diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/webhook_converter.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/webhook_converter.go index 30047b4fd82..34c6d26db01 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/webhook_converter.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/webhook_converter.go @@ -250,7 +250,7 @@ func (c *webhookConverter) Convert(in runtime.Object, toGV schema.GroupVersion) objCount := len(objectsToConvert) if objCount == 0 { - Metrics.ObserveWebhookConversionSuccess(ctx, time.Since(t)) + Metrics.ObserveConversionWebhookSuccess(ctx, time.Since(t)) // no objects needed conversion if !isList { // for a single item, return as-is @@ -276,19 +276,19 @@ func (c *webhookConverter) Convert(in runtime.Object, toGV schema.GroupVersion) r := c.restClient.Post().Body(request).Do(ctx) if err := r.Into(response); err != nil { // TODO: Return a webhook specific error to be able to convert it to meta.Status - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionCallFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookCallFailure) return nil, fmt.Errorf("conversion webhook for %v failed: %v", in.GetObjectKind().GroupVersionKind(), err) } span.AddEvent("Request completed") convertedObjects, err := getConvertedObjectsFromResponse(requestUID, response) if err != nil { - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionMalformedResponseFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookMalformedResponseFailure) return nil, fmt.Errorf("conversion webhook for %v failed: %v", in.GetObjectKind().GroupVersionKind(), err) } if len(convertedObjects) != len(objectsToConvert) { - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionPartialResponseFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookPartialResponseFailure) return nil, fmt.Errorf("conversion webhook for %v returned %d objects, expected %d", in.GetObjectKind().GroupVersionKind(), len(convertedObjects), len(objectsToConvert)) } @@ -306,78 +306,78 @@ func (c *webhookConverter) Convert(in runtime.Object, toGV schema.GroupVersion) } converted, err := getRawExtensionObject(convertedObjects[convertedIndex]) if err != nil { - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionInvalidConvertedObjectFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v returned invalid converted object at index %v: %v", in.GetObjectKind().GroupVersionKind(), convertedIndex, err) } convertedIndex++ if expected, got := toGV, converted.GetObjectKind().GroupVersionKind().GroupVersion(); expected != got { - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionInvalidConvertedObjectFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v returned invalid converted object at index %v: invalid groupVersion (expected %v, received %v)", in.GetObjectKind().GroupVersionKind(), convertedIndex, expected, got) } if expected, got := original.GetObjectKind().GroupVersionKind().Kind, converted.GetObjectKind().GroupVersionKind().Kind; expected != got { - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionInvalidConvertedObjectFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v returned invalid converted object at index %v: invalid kind (expected %v, received %v)", in.GetObjectKind().GroupVersionKind(), convertedIndex, expected, got) } unstructConverted, ok := converted.(*unstructured.Unstructured) if !ok { // this should not happened - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionInvalidConvertedObjectFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v returned invalid converted object at index %v: invalid type, expected=Unstructured, got=%T", in.GetObjectKind().GroupVersionKind(), convertedIndex, converted) } if err := validateConvertedObject(original, unstructConverted); err != nil { - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionInvalidConvertedObjectFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v returned invalid converted object at index %v: %v", in.GetObjectKind().GroupVersionKind(), convertedIndex, err) } if err := restoreObjectMeta(original, unstructConverted); err != nil { - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionInvalidConvertedObjectFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v returned invalid metadata in object at index %v: %v", in.GetObjectKind().GroupVersionKind(), convertedIndex, err) } convertedList.Items[i] = *unstructConverted } convertedList.SetAPIVersion(toGV.String()) - Metrics.ObserveWebhookConversionSuccess(ctx, time.Since(t)) + Metrics.ObserveConversionWebhookSuccess(ctx, time.Since(t)) return convertedList, nil } if len(convertedObjects) != 1 { // This should not happened - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionNoObjectsReturnedFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookNoObjectsReturnedFailure) return nil, fmt.Errorf("conversion webhook for %v failed, no objects returned", in.GetObjectKind()) } converted, err := getRawExtensionObject(convertedObjects[0]) if err != nil { - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionInvalidConvertedObjectFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, err } if e, a := toGV, converted.GetObjectKind().GroupVersionKind().GroupVersion(); e != a { - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionInvalidConvertedObjectFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v returned invalid object at index 0: invalid groupVersion (expected %v, received %v)", in.GetObjectKind().GroupVersionKind(), e, a) } if e, a := in.GetObjectKind().GroupVersionKind().Kind, converted.GetObjectKind().GroupVersionKind().Kind; e != a { - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionInvalidConvertedObjectFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v returned invalid object at index 0: invalid kind (expected %v, received %v)", in.GetObjectKind().GroupVersionKind(), e, a) } unstructConverted, ok := converted.(*unstructured.Unstructured) if !ok { // this should not happened - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionInvalidConvertedObjectFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v failed, unexpected type %T at index 0", in.GetObjectKind().GroupVersionKind(), converted) } unstructIn, ok := in.(*unstructured.Unstructured) if !ok { // this should not happened - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionInvalidConvertedObjectFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v failed unexpected input type %T", in.GetObjectKind().GroupVersionKind(), in) } if err := validateConvertedObject(unstructIn, unstructConverted); err != nil { - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionInvalidConvertedObjectFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v returned invalid object: %v", in.GetObjectKind().GroupVersionKind(), err) } if err := restoreObjectMeta(unstructIn, unstructConverted); err != nil { - Metrics.ObserveWebhookConversionFailure(ctx, time.Since(t), WebhookConversionInvalidConvertedObjectFailure) + Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v returned invalid metadata: %v", in.GetObjectKind().GroupVersionKind(), err) } - Metrics.ObserveWebhookConversionSuccess(ctx, time.Since(t)) + Metrics.ObserveConversionWebhookSuccess(ctx, time.Since(t)) return converted, nil } From 4820cc852a060e36d571f8e6bda4c0cc04ca111c Mon Sep 17 00:00:00 2001 From: Chinmay Chapla Date: Wed, 7 Jun 2023 19:37:55 +0000 Subject: [PATCH 2/2] Minor fix on variable --- .../pkg/apiserver/conversion/webhook_converter.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/webhook_converter.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/webhook_converter.go index 34c6d26db01..95788af8a87 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/webhook_converter.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/conversion/webhook_converter.go @@ -309,7 +309,6 @@ func (c *webhookConverter) Convert(in runtime.Object, toGV schema.GroupVersion) Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v returned invalid converted object at index %v: %v", in.GetObjectKind().GroupVersionKind(), convertedIndex, err) } - convertedIndex++ if expected, got := toGV, converted.GetObjectKind().GroupVersionKind().GroupVersion(); expected != got { Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v returned invalid converted object at index %v: invalid groupVersion (expected %v, received %v)", in.GetObjectKind().GroupVersionKind(), convertedIndex, expected, got) @@ -332,6 +331,7 @@ func (c *webhookConverter) Convert(in runtime.Object, toGV schema.GroupVersion) Metrics.ObserveConversionWebhookFailure(ctx, time.Since(t), ConversionWebhookInvalidConvertedObjectFailure) return nil, fmt.Errorf("conversion webhook for %v returned invalid metadata in object at index %v: %v", in.GetObjectKind().GroupVersionKind(), convertedIndex, err) } + convertedIndex++ convertedList.Items[i] = *unstructConverted } convertedList.SetAPIVersion(toGV.String())