Merge pull request #4356 from zac-nixon/znixon/fix-tgb-error-metrics

k8s-ci-robot · web-flow · commit f6558daec8e7 · 2025-09-26T18:24:15.000-07:00
fix metric population by requeueneeded error
diff --git a/controllers/elbv2/targetgroupbinding_controller.go b/controllers/elbv2/targetgroupbinding_controller.go
@@ -32,7 +32,7 @@ import (
 	"k8s.io/client-go/util/workqueue"
 	"sigs.k8s.io/aws-load-balancer-controller/controllers/elbv2/eventhandlers"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/config"
-	errmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/error"
+	ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/k8s"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/runtime"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/targetgroupbinding"
@@ -131,7 +131,7 @@ func (r *targetGroupBindingReconciler) reconcileTargetGroupBinding(ctx context.C
 	r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "add_finalizers", finalizerFn)
 	if err != nil {
 		r.eventRecorder.Event(tgb, corev1.EventTypeWarning, k8s.TargetGroupBindingEventReasonFailedAddFinalizer, fmt.Sprintf("Failed add finalizer due to %v", err))
-		return errmetrics.NewErrorWithMetrics(controllerName, "add_finalizers_error", err, r.metricsCollector)
+		return ctrlerrors.NewErrorWithMetrics(controllerName, "add_finalizers_error", err, r.metricsCollector)
 	}
 
 	var deferred bool
@@ -140,7 +140,7 @@ func (r *targetGroupBindingReconciler) reconcileTargetGroupBinding(ctx context.C
 	}
 	r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "reconcile_targetgroupbinding", tgbResourceFn)
 	if err != nil {
-		return errmetrics.NewErrorWithMetrics(controllerName, "reconcile_targetgroupbinding_error", err, r.metricsCollector)
+		return ctrlerrors.NewErrorWithMetrics(controllerName, "reconcile_targetgroupbinding_error", err, r.metricsCollector)
 	}
 
 	if deferred {
@@ -155,7 +155,7 @@ func (r *targetGroupBindingReconciler) reconcileTargetGroupBinding(ctx context.C
 	}
 	r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "update_status", updateTargetGroupBindingStatusFn)
 	if err != nil {
-		return errmetrics.NewErrorWithMetrics(controllerName, "update_status_error", err, r.metricsCollector)
+		return ctrlerrors.NewErrorWithMetrics(controllerName, "update_status_error", err, r.metricsCollector)
 	}
 
 	r.eventRecorder.Event(tgb, corev1.EventTypeNormal, k8s.TargetGroupBindingEventReasonSuccessfullyReconciled, "Successfully reconciled")
diff --git a/controllers/gateway/gateway_controller.go b/controllers/gateway/gateway_controller.go
@@ -20,6 +20,7 @@ import (
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy"
 	elbv2deploy "sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/elbv2"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/tracking"
+	ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/gateway/constants"
 	gatewaymodel "sigs.k8s.io/aws-load-balancer-controller/pkg/gateway/model"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/gateway/referencecounter"
@@ -336,7 +337,7 @@ func (r *gatewayReconciler) reconcileUpdate(ctx context.Context, gw *gwv1.Gatewa
 
 func (r *gatewayReconciler) deployModel(ctx context.Context, gw *gwv1.Gateway, stack core.Stack, secrets []types.NamespacedName) error {
 	if err := r.stackDeployer.Deploy(ctx, stack, r.metricsCollector, r.controllerName, nil); err != nil {
-		var requeueNeededAfter *runtime.RequeueNeededAfter
+		var requeueNeededAfter *ctrlerrors.RequeueNeededAfter
 		if errors.As(err, &requeueNeededAfter) {
 			return err
 		}
@@ -401,7 +402,7 @@ func (r *gatewayReconciler) updateGatewayStatusSuccess(ctx context.Context, lbSt
 	}
 
 	if requeueNeeded {
-		return runtime.NewRequeueNeededAfter(requeueMessage, statusUpdateRequeueTime)
+		return ctrlerrors.NewRequeueNeededAfter(requeueMessage, statusUpdateRequeueTime)
 	}
 
 	return nil
diff --git a/controllers/gateway/listenerrule_configuration_controller.go b/controllers/gateway/listenerrule_configuration_controller.go
@@ -12,6 +12,7 @@ import (
 	"k8s.io/client-go/util/workqueue"
 	elbv2gw "sigs.k8s.io/aws-load-balancer-controller/apis/gateway/v1beta1"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/config"
+	ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/gateway/constants"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/gateway/routeutils"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/k8s"
@@ -101,7 +102,7 @@ func (r *listenerRuleConfigurationReconciler) handleUpdate(ctx context.Context,
 			if err := r.updateStatus(ctx, listenerRuleConf, false, secretValidationErr.Error()); err != nil {
 				return err
 			}
-			return runtime.NewRequeueNeededAfter("Required secret not yet available", secretValidationRequeueInterval)
+			return ctrlerrors.NewRequeueNeededAfter("Required secret not yet available", secretValidationRequeueInterval)
 		}
 		return secretValidationErr
 	}
diff --git a/controllers/ingress/group_controller.go b/controllers/ingress/group_controller.go
@@ -23,7 +23,7 @@ import (
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy"
 	elbv2deploy "sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/elbv2"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/tracking"
-	errmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/error"
+	ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/ingress"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/k8s"
 	lbcmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/metrics/lbc"
@@ -141,7 +141,7 @@ func (r *groupReconciler) reconcile(ctx context.Context, req reconcile.Request)
 	}
 	r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "fetch_ingress", loadIngressFn)
 	if err != nil {
-		return errmetrics.NewErrorWithMetrics(controllerName, "fetch_ingress_error", err, r.metricsCollector)
+		return ctrlerrors.NewErrorWithMetrics(controllerName, "fetch_ingress_error", err, r.metricsCollector)
 	}
 
 	addFinalizerFn := func() {
@@ -150,7 +150,7 @@ func (r *groupReconciler) reconcile(ctx context.Context, req reconcile.Request)
 	r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "add_group_finalizer", addFinalizerFn)
 	if err != nil {
 		r.recordIngressGroupEvent(ctx, ingGroup, corev1.EventTypeWarning, k8s.IngressEventReasonFailedAddFinalizer, fmt.Sprintf("Failed add finalizer due to %v", err))
-		return errmetrics.NewErrorWithMetrics(controllerName, "add_group_finalizer_error", err, r.metricsCollector)
+		return ctrlerrors.NewErrorWithMetrics(controllerName, "add_group_finalizer_error", err, r.metricsCollector)
 	}
 
 	_, lb, frontendNlb, err := r.buildAndDeployModel(ctx, ingGroup)
@@ -181,7 +181,7 @@ func (r *groupReconciler) reconcile(ctx context.Context, req reconcile.Request)
 		}
 		r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "dns_resolve_and_update_status", dnsResolveAndUpdateStatus)
 		if statusErr != nil {
-			return errmetrics.NewErrorWithMetrics(controllerName, "dns_resolve_and_update_status_error", statusErr, r.metricsCollector)
+			return ctrlerrors.NewErrorWithMetrics(controllerName, "dns_resolve_and_update_status_error", statusErr, r.metricsCollector)
 		}
 	}
 
@@ -192,7 +192,7 @@ func (r *groupReconciler) reconcile(ctx context.Context, req reconcile.Request)
 		r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "remove_group_finalizer", removeGroupFinalizerFn)
 		if err != nil {
 			r.recordIngressGroupEvent(ctx, ingGroup, corev1.EventTypeWarning, k8s.IngressEventReasonFailedRemoveFinalizer, fmt.Sprintf("Failed remove finalizer due to %v", err))
-			return errmetrics.NewErrorWithMetrics(controllerName, "remove_group_finalizer_error", err, r.metricsCollector)
+			return ctrlerrors.NewErrorWithMetrics(controllerName, "remove_group_finalizer_error", err, r.metricsCollector)
 		}
 	}
 
@@ -214,7 +214,7 @@ func (r *groupReconciler) buildAndDeployModel(ctx context.Context, ingGroup ingr
 	r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "build_model", buildModelFn)
 	if err != nil {
 		r.recordIngressGroupEvent(ctx, ingGroup, corev1.EventTypeWarning, k8s.IngressEventReasonFailedBuildModel, fmt.Sprintf("Failed build model due to %v", err))
-		return nil, nil, nil, errmetrics.NewErrorWithMetrics(controllerName, "build_model_error", err, r.metricsCollector)
+		return nil, nil, nil, ctrlerrors.NewErrorWithMetrics(controllerName, "build_model_error", err, r.metricsCollector)
 	}
 	stackJSON, err := r.stackMarshaller.Marshal(stack)
 	if err != nil {
@@ -228,12 +228,12 @@ func (r *groupReconciler) buildAndDeployModel(ctx context.Context, ingGroup ingr
 	}
 	r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "deploy_model", deployModelFn)
 	if err != nil {
-		var requeueNeededAfter *runtime.RequeueNeededAfter
+		var requeueNeededAfter *ctrlerrors.RequeueNeededAfter
 		if errors.As(err, &requeueNeededAfter) {
 			return nil, nil, nil, err
 		}
 		r.recordIngressGroupEvent(ctx, ingGroup, corev1.EventTypeWarning, k8s.IngressEventReasonFailedDeployModel, fmt.Sprintf("Failed deploy model due to %v", err))
-		return nil, nil, nil, errmetrics.NewErrorWithMetrics(controllerName, "deploy_model_error", err, r.metricsCollector)
+		return nil, nil, nil, ctrlerrors.NewErrorWithMetrics(controllerName, "deploy_model_error", err, r.metricsCollector)
 	}
 	r.logger.Info("successfully deployed model", "ingressGroup", ingGroup.ID)
 	r.secretsManager.MonitorSecrets(ingGroup.ID.String(), secrets)
@@ -243,7 +243,7 @@ func (r *groupReconciler) buildAndDeployModel(ctx context.Context, ingGroup ingr
 		inactiveResources = append(inactiveResources, k8s.ToSliceOfNamespacedNames(ingGroup.Members)...)
 	}
 	if err := r.backendSGProvider.Release(ctx, networkingpkg.ResourceTypeIngress, inactiveResources); err != nil {
-		return nil, nil, nil, errmetrics.NewErrorWithMetrics(controllerName, "release_auto_generated_backend_sg_error", err, r.metricsCollector)
+		return nil, nil, nil, ctrlerrors.NewErrorWithMetrics(controllerName, "release_auto_generated_backend_sg_error", err, r.metricsCollector)
 	}
 	return stack, lb, frontendNlb, nil
 }
diff --git a/controllers/service/service_controller.go b/controllers/service/service_controller.go
@@ -20,7 +20,7 @@ import (
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy"
 	elbv2deploy "sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/elbv2"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/tracking"
-	errmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/error"
+	ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/k8s"
 	lbcmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/metrics/lbc"
 	metricsutil "sigs.k8s.io/aws-load-balancer-controller/pkg/metrics/util"
@@ -123,7 +123,7 @@ func (r *serviceReconciler) reconcile(ctx context.Context, req reconcile.Request
 	}
 	r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "build_model", buildModelFn)
 	if err != nil {
-		return errmetrics.NewErrorWithMetrics(controllerName, "build_model_error", err, r.metricsCollector)
+		return ctrlerrors.NewErrorWithMetrics(controllerName, "build_model_error", err, r.metricsCollector)
 	}
 
 	if lb == nil {
@@ -132,7 +132,7 @@ func (r *serviceReconciler) reconcile(ctx context.Context, req reconcile.Request
 		}
 		r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "cleanup_load_balancer", cleanupLoadBalancerFn)
 		if err != nil {
-			return errmetrics.NewErrorWithMetrics(controllerName, "cleanup_load_balancer_error", err, r.metricsCollector)
+			return ctrlerrors.NewErrorWithMetrics(controllerName, "cleanup_load_balancer_error", err, r.metricsCollector)
 		}
 	}
 	return r.reconcileLoadBalancerResources(ctx, svc, stack, lb, backendSGRequired)
@@ -155,7 +155,7 @@ func (r *serviceReconciler) buildModel(ctx context.Context, svc *corev1.Service)
 
 func (r *serviceReconciler) deployModel(ctx context.Context, svc *corev1.Service, stack core.Stack) error {
 	if err := r.stackDeployer.Deploy(ctx, stack, r.metricsCollector, "service", nil); err != nil {
-		var requeueNeededAfter *runtime.RequeueNeededAfter
+		var requeueNeededAfter *ctrlerrors.RequeueNeededAfter
 		if errors.As(err, &requeueNeededAfter) {
 			return err
 		}
@@ -177,15 +177,15 @@ func (r *serviceReconciler) reconcileLoadBalancerResources(ctx context.Context,
 	r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "add_finalizers", addFinalizersFn)
 	if err != nil {
 		r.eventRecorder.Event(svc, corev1.EventTypeWarning, k8s.ServiceEventReasonFailedAddFinalizer, fmt.Sprintf("Failed add finalizer due to %v", err))
-		return errmetrics.NewErrorWithMetrics(controllerName, "add_finalizers_error", err, r.metricsCollector)
+		return ctrlerrors.NewErrorWithMetrics(controllerName, "add_finalizers_error", err, r.metricsCollector)
 	}
 
 	deployModelFn := func() {
 		err = r.deployModel(ctx, svc, stack)
 	}
 	r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "deploy_model", deployModelFn)
 	if err != nil {
-		return errmetrics.NewErrorWithMetrics(controllerName, "deploy_model_error", err, r.metricsCollector)
+		return ctrlerrors.NewErrorWithMetrics(controllerName, "deploy_model_error", err, r.metricsCollector)
 	}
 
 	var lbDNS string
@@ -194,12 +194,12 @@ func (r *serviceReconciler) reconcileLoadBalancerResources(ctx context.Context,
 	}
 	r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "DNS_resolve", dnsResolveFn)
 	if err != nil {
-		return errmetrics.NewErrorWithMetrics(controllerName, "dns_resolve_error", err, r.metricsCollector)
+		return ctrlerrors.NewErrorWithMetrics(controllerName, "dns_resolve_error", err, r.metricsCollector)
 	}
 
 	if !backendSGRequired {
 		if err := r.backendSGProvider.Release(ctx, networking.ResourceTypeService, []types.NamespacedName{k8s.NamespacedName(svc)}); err != nil {
-			return errmetrics.NewErrorWithMetrics(controllerName, "release_auto_generated_backend_sg_error", err, r.metricsCollector)
+			return ctrlerrors.NewErrorWithMetrics(controllerName, "release_auto_generated_backend_sg_error", err, r.metricsCollector)
 		}
 	}
 
@@ -209,7 +209,7 @@ func (r *serviceReconciler) reconcileLoadBalancerResources(ctx context.Context,
 	r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "update_status", updateStatusFn)
 	if err != nil {
 		r.eventRecorder.Event(svc, corev1.EventTypeWarning, k8s.ServiceEventReasonFailedUpdateStatus, fmt.Sprintf("Failed update status due to %v", err))
-		return errmetrics.NewErrorWithMetrics(controllerName, "update_status_error", err, r.metricsCollector)
+		return ctrlerrors.NewErrorWithMetrics(controllerName, "update_status_error", err, r.metricsCollector)
 	}
 	r.eventRecorder.Event(svc, corev1.EventTypeNormal, k8s.ServiceEventReasonSuccessfullyReconciled, "Successfully reconciled")
 	return nil
diff --git a/pkg/deploy/elbv2/frontend_nlb_target_synthesizer.go b/pkg/deploy/elbv2/frontend_nlb_target_synthesizer.go
@@ -2,6 +2,7 @@ package elbv2
 
 import (
 	"context"
+	ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"
 	"time"
 
 	awssdk "github.com/aws/aws-sdk-go-v2/aws"
@@ -12,7 +13,6 @@ import (
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/tracking"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/model/core"
 	elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2"
-	"sigs.k8s.io/aws-load-balancer-controller/pkg/runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
@@ -147,7 +147,7 @@ func (s *frontendNlbTargetSynthesizer) PostSynthesize(ctx context.Context) error
 
 			if err != nil {
 				requeueMsg := "Failed to register target, retrying after deplay for target group: " + resTG.Status.TargetGroupARN
-				return runtime.NewRequeueNeededAfter(requeueMsg, 15*time.Second)
+				return ctrlerrors.NewRequeueNeededAfter(requeueMsg, 15*time.Second)
 			}
 
 		}
diff --git a/pkg/deploy/elbv2/load_balancer_synthesizer.go b/pkg/deploy/elbv2/load_balancer_synthesizer.go
@@ -11,9 +11,9 @@ import (
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/config"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/tracking"
+	ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/model/core"
 	elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2"
-	"sigs.k8s.io/aws-load-balancer-controller/pkg/runtime"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/shared_constants"
 	"strings"
 )
@@ -131,7 +131,7 @@ func (s *loadBalancerSynthesizer) PostSynthesize(ctx context.Context) error {
 		}
 		if isLoadBalancerProvisioning {
 			requeueMsg := "monitor provisioning state for load balancer: " + awssdk.ToString(resAndSDKLB.sdkLB.LoadBalancer.LoadBalancerName)
-			return runtime.NewRequeueNeededAfter(requeueMsg, s.controllerConfig.LBStabilizationMonitorInterval)
+			return ctrlerrors.NewRequeueNeededAfter(requeueMsg, s.controllerConfig.LBStabilizationMonitorInterval)
 		}
 		if err := s.capacityReservationReconciler.Reconcile(ctx, resAndSDKLB.resLB, resAndSDKLB.sdkLB); err != nil {
 			return err
diff --git a/pkg/deploy/stack_deployer.go b/pkg/deploy/stack_deployer.go
@@ -15,7 +15,7 @@ import (
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/tracking"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/wafregional"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/wafv2"
-	errmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/error"
+	ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"
 	lbcmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/metrics/lbc"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/model/core"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/networking"
@@ -157,7 +157,7 @@ func (d *defaultStackDeployer) Deploy(ctx context.Context, stack core.Stack, met
 		}
 		d.metricsCollector.ObserveControllerReconcileLatency(controllerName, synthesizerType, synthesizeFn)
 		if err != nil {
-			return errmetrics.NewErrorWithMetrics(controllerName, synthesizerType, err, d.metricsCollector)
+			return ctrlerrors.NewErrorWithMetrics(controllerName, synthesizerType, err, d.metricsCollector)
 		}
 	}
 	for i := len(synthesizers) - 1; i >= 0; i-- {
diff --git a/pkg/error/error_with_metrics.go b/pkg/error/error_with_metrics.go
@@ -1,6 +1,7 @@
-package errmetrics
+package ctrlerrors
 
 import (
+	"github.com/pkg/errors"
 	lbcmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/metrics/lbc"
 )
 
@@ -16,7 +17,18 @@ func NewErrorWithMetrics(resourceType string, errorCategory string, err error, m
 		ErrorCategory: errorCategory,
 		Err:           err,
 	}
-	metricCollector.ObserveControllerReconcileError(resourceType, errorCategory)
+
+	var skipErrorMetric bool
+	var requeueNeededAfter *RequeueNeededAfter
+	var requeueAfter *RequeueNeeded
+	if errors.As(err, &requeueNeededAfter) || errors.As(err, &requeueAfter) {
+		skipErrorMetric = true
+	}
+
+	if !skipErrorMetric {
+		metricCollector.ObserveControllerReconcileError(resourceType, errorCategory)
+	}
+
 	return reconcileErr
 }
 
diff --git a/pkg/error/error_with_metrics_test.go b/pkg/error/error_with_metrics_test.go
@@ -0,0 +1,44 @@
+package ctrlerrors
+
+import (
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	lbcmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/metrics/lbc"
+	"testing"
+)
+
+func Test_NewErrorWithMetrics(t *testing.T) {
+	resourceType := "test-resource"
+	category := "test-category"
+	testCases := []struct {
+		name                string
+		err                 error
+		expectedInvocations int
+	}{
+		{
+			name:                "real error",
+			err:                 errors.New("bad thing"),
+			expectedInvocations: 1,
+		},
+		{
+			name: "requeue needed error",
+			err:  &RequeueNeeded{},
+		},
+		{
+			name: "requeue needed after error",
+			err:  &RequeueNeededAfter{},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			collector := lbcmetrics.NewMockCollector()
+			res := NewErrorWithMetrics(resourceType, category, tc.err, collector)
+			assert.Equal(t, tc.err, res.Err)
+			assert.Equal(t, resourceType, res.ResourceType)
+			assert.Equal(t, category, res.ErrorCategory)
+			mc := collector.(*lbcmetrics.MockCollector)
+			assert.Equal(t, tc.expectedInvocations, len(mc.Invocations[lbcmetrics.MetricControllerReconcileErrors]))
+		})
+	}
+}
diff --git a/pkg/error/errors.go b/pkg/error/errors.go
@@ -1,4 +1,4 @@
-package runtime
+package ctrlerrors
 
 import (
 	"fmt"
diff --git a/pkg/error/errors_test.go b/pkg/error/errors_test.go
@@ -1,4 +1,4 @@
-package runtime
+package ctrlerrors
 
 import (
 	"github.com/stretchr/testify/assert"
diff --git a/pkg/ingress/model_builder.go b/pkg/ingress/model_builder.go
diff --git a/pkg/runtime/reconcile.go b/pkg/runtime/reconcile.go
diff --git a/pkg/runtime/reconcile_test.go b/pkg/runtime/reconcile_test.go
diff --git a/pkg/service/model_builder.go b/pkg/service/model_builder.go
diff --git a/pkg/targetgroupbinding/resource_manager.go b/pkg/targetgroupbinding/resource_manager.go

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ import (`
`12`	`12`	`"k8s.io/client-go/util/workqueue"`
`13`	`13`	`elbv2gw "sigs.k8s.io/aws-load-balancer-controller/apis/gateway/v1beta1"`
`14`	`14`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/config"`
	`15`	`+ ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"`
`15`	`16`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/gateway/constants"`
`16`	`17`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/gateway/routeutils"`
`17`	`18`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/k8s"`
`@@ -101,7 +102,7 @@ func (r *listenerRuleConfigurationReconciler) handleUpdate(ctx context.Context,`
`101`	`102`	`if err := r.updateStatus(ctx, listenerRuleConf, false, secretValidationErr.Error()); err != nil {`
`102`	`103`	`return err`
`103`	`104`	`}`
`104`		`- return runtime.NewRequeueNeededAfter("Required secret not yet available", secretValidationRequeueInterval)`
	`105`	`+ return ctrlerrors.NewRequeueNeededAfter("Required secret not yet available", secretValidationRequeueInterval)`
`105`	`106`	`}`
`106`	`107`	`return secretValidationErr`
`107`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ import (`
`23`	`23`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy"`
`24`	`24`	`elbv2deploy "sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/elbv2"`
`25`	`25`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/tracking"`
`26`		`- errmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/error"`
	`26`	`+ ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"`
`27`	`27`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/ingress"`
`28`	`28`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/k8s"`
`29`	`29`	`lbcmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/metrics/lbc"`
`@@ -141,7 +141,7 @@ func (r *groupReconciler) reconcile(ctx context.Context, req reconcile.Request)`
`141`	`141`	`}`
`142`	`142`	`r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "fetch_ingress", loadIngressFn)`
`143`	`143`	`if err != nil {`
`144`		`- return errmetrics.NewErrorWithMetrics(controllerName, "fetch_ingress_error", err, r.metricsCollector)`
	`144`	`+ return ctrlerrors.NewErrorWithMetrics(controllerName, "fetch_ingress_error", err, r.metricsCollector)`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`addFinalizerFn := func() {`
`@@ -150,7 +150,7 @@ func (r *groupReconciler) reconcile(ctx context.Context, req reconcile.Request)`
`150`	`150`	`r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "add_group_finalizer", addFinalizerFn)`
`151`	`151`	`if err != nil {`
`152`	`152`	`r.recordIngressGroupEvent(ctx, ingGroup, corev1.EventTypeWarning, k8s.IngressEventReasonFailedAddFinalizer, fmt.Sprintf("Failed add finalizer due to %v", err))`
`153`		`- return errmetrics.NewErrorWithMetrics(controllerName, "add_group_finalizer_error", err, r.metricsCollector)`
	`153`	`+ return ctrlerrors.NewErrorWithMetrics(controllerName, "add_group_finalizer_error", err, r.metricsCollector)`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`_, lb, frontendNlb, err := r.buildAndDeployModel(ctx, ingGroup)`
`@@ -181,7 +181,7 @@ func (r *groupReconciler) reconcile(ctx context.Context, req reconcile.Request)`
`181`	`181`	`}`
`182`	`182`	`r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "dns_resolve_and_update_status", dnsResolveAndUpdateStatus)`
`183`	`183`	`if statusErr != nil {`
`184`		`- return errmetrics.NewErrorWithMetrics(controllerName, "dns_resolve_and_update_status_error", statusErr, r.metricsCollector)`
	`184`	`+ return ctrlerrors.NewErrorWithMetrics(controllerName, "dns_resolve_and_update_status_error", statusErr, r.metricsCollector)`
`185`	`185`	`}`
`186`	`186`	`}`
`187`	`187`
`@@ -192,7 +192,7 @@ func (r *groupReconciler) reconcile(ctx context.Context, req reconcile.Request)`
`192`	`192`	`r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "remove_group_finalizer", removeGroupFinalizerFn)`
`193`	`193`	`if err != nil {`
`194`	`194`	`r.recordIngressGroupEvent(ctx, ingGroup, corev1.EventTypeWarning, k8s.IngressEventReasonFailedRemoveFinalizer, fmt.Sprintf("Failed remove finalizer due to %v", err))`
`195`		`- return errmetrics.NewErrorWithMetrics(controllerName, "remove_group_finalizer_error", err, r.metricsCollector)`
	`195`	`+ return ctrlerrors.NewErrorWithMetrics(controllerName, "remove_group_finalizer_error", err, r.metricsCollector)`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`
`@@ -214,7 +214,7 @@ func (r *groupReconciler) buildAndDeployModel(ctx context.Context, ingGroup ingr`
`214`	`214`	`r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "build_model", buildModelFn)`
`215`	`215`	`if err != nil {`
`216`	`216`	`r.recordIngressGroupEvent(ctx, ingGroup, corev1.EventTypeWarning, k8s.IngressEventReasonFailedBuildModel, fmt.Sprintf("Failed build model due to %v", err))`
`217`		`- return nil, nil, nil, errmetrics.NewErrorWithMetrics(controllerName, "build_model_error", err, r.metricsCollector)`
	`217`	`+ return nil, nil, nil, ctrlerrors.NewErrorWithMetrics(controllerName, "build_model_error", err, r.metricsCollector)`
`218`	`218`	`}`
`219`	`219`	`stackJSON, err := r.stackMarshaller.Marshal(stack)`
`220`	`220`	`if err != nil {`
`@@ -228,12 +228,12 @@ func (r *groupReconciler) buildAndDeployModel(ctx context.Context, ingGroup ingr`
`228`	`228`	`}`
`229`	`229`	`r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "deploy_model", deployModelFn)`
`230`	`230`	`if err != nil {`
`231`		`- var requeueNeededAfter *runtime.RequeueNeededAfter`
	`231`	`+ var requeueNeededAfter *ctrlerrors.RequeueNeededAfter`
`232`	`232`	`if errors.As(err, &requeueNeededAfter) {`
`233`	`233`	`return nil, nil, nil, err`
`234`	`234`	`}`
`235`	`235`	`r.recordIngressGroupEvent(ctx, ingGroup, corev1.EventTypeWarning, k8s.IngressEventReasonFailedDeployModel, fmt.Sprintf("Failed deploy model due to %v", err))`
`236`		`- return nil, nil, nil, errmetrics.NewErrorWithMetrics(controllerName, "deploy_model_error", err, r.metricsCollector)`
	`236`	`+ return nil, nil, nil, ctrlerrors.NewErrorWithMetrics(controllerName, "deploy_model_error", err, r.metricsCollector)`
`237`	`237`	`}`
`238`	`238`	`r.logger.Info("successfully deployed model", "ingressGroup", ingGroup.ID)`
`239`	`239`	`r.secretsManager.MonitorSecrets(ingGroup.ID.String(), secrets)`
`@@ -243,7 +243,7 @@ func (r *groupReconciler) buildAndDeployModel(ctx context.Context, ingGroup ingr`
`243`	`243`	`inactiveResources = append(inactiveResources, k8s.ToSliceOfNamespacedNames(ingGroup.Members)...)`
`244`	`244`	`}`
`245`	`245`	`if err := r.backendSGProvider.Release(ctx, networkingpkg.ResourceTypeIngress, inactiveResources); err != nil {`
`246`		`- return nil, nil, nil, errmetrics.NewErrorWithMetrics(controllerName, "release_auto_generated_backend_sg_error", err, r.metricsCollector)`
	`246`	`+ return nil, nil, nil, ctrlerrors.NewErrorWithMetrics(controllerName, "release_auto_generated_backend_sg_error", err, r.metricsCollector)`
`247`	`247`	`}`
`248`	`248`	`return stack, lb, frontendNlb, nil`
`249`	`249`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ import (`
`20`	`20`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy"`
`21`	`21`	`elbv2deploy "sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/elbv2"`
`22`	`22`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/tracking"`
`23`		`- errmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/error"`
	`23`	`+ ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"`
`24`	`24`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/k8s"`
`25`	`25`	`lbcmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/metrics/lbc"`
`26`	`26`	`metricsutil "sigs.k8s.io/aws-load-balancer-controller/pkg/metrics/util"`
`@@ -123,7 +123,7 @@ func (r *serviceReconciler) reconcile(ctx context.Context, req reconcile.Request`
`123`	`123`	`}`
`124`	`124`	`r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "build_model", buildModelFn)`
`125`	`125`	`if err != nil {`
`126`		`- return errmetrics.NewErrorWithMetrics(controllerName, "build_model_error", err, r.metricsCollector)`
	`126`	`+ return ctrlerrors.NewErrorWithMetrics(controllerName, "build_model_error", err, r.metricsCollector)`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`if lb == nil {`
`@@ -132,7 +132,7 @@ func (r *serviceReconciler) reconcile(ctx context.Context, req reconcile.Request`
`132`	`132`	`}`
`133`	`133`	`r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "cleanup_load_balancer", cleanupLoadBalancerFn)`
`134`	`134`	`if err != nil {`
`135`		`- return errmetrics.NewErrorWithMetrics(controllerName, "cleanup_load_balancer_error", err, r.metricsCollector)`
	`135`	`+ return ctrlerrors.NewErrorWithMetrics(controllerName, "cleanup_load_balancer_error", err, r.metricsCollector)`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`	`return r.reconcileLoadBalancerResources(ctx, svc, stack, lb, backendSGRequired)`
`@@ -155,7 +155,7 @@ func (r serviceReconciler) buildModel(ctx context.Context, svc corev1.Service)`
`155`	`155`
`156`	`156`	`func (r serviceReconciler) deployModel(ctx context.Context, svc corev1.Service, stack core.Stack) error {`
`157`	`157`	`if err := r.stackDeployer.Deploy(ctx, stack, r.metricsCollector, "service", nil); err != nil {`
`158`		`- var requeueNeededAfter *runtime.RequeueNeededAfter`
	`158`	`+ var requeueNeededAfter *ctrlerrors.RequeueNeededAfter`
`159`	`159`	`if errors.As(err, &requeueNeededAfter) {`
`160`	`160`	`return err`
`161`	`161`	`}`
`@@ -177,15 +177,15 @@ func (r *serviceReconciler) reconcileLoadBalancerResources(ctx context.Context,`
`177`	`177`	`r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "add_finalizers", addFinalizersFn)`
`178`	`178`	`if err != nil {`
`179`	`179`	`r.eventRecorder.Event(svc, corev1.EventTypeWarning, k8s.ServiceEventReasonFailedAddFinalizer, fmt.Sprintf("Failed add finalizer due to %v", err))`
`180`		`- return errmetrics.NewErrorWithMetrics(controllerName, "add_finalizers_error", err, r.metricsCollector)`
	`180`	`+ return ctrlerrors.NewErrorWithMetrics(controllerName, "add_finalizers_error", err, r.metricsCollector)`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`deployModelFn := func() {`
`184`	`184`	`err = r.deployModel(ctx, svc, stack)`
`185`	`185`	`}`
`186`	`186`	`r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "deploy_model", deployModelFn)`
`187`	`187`	`if err != nil {`
`188`		`- return errmetrics.NewErrorWithMetrics(controllerName, "deploy_model_error", err, r.metricsCollector)`
	`188`	`+ return ctrlerrors.NewErrorWithMetrics(controllerName, "deploy_model_error", err, r.metricsCollector)`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`var lbDNS string`
`@@ -194,12 +194,12 @@ func (r *serviceReconciler) reconcileLoadBalancerResources(ctx context.Context,`
`194`	`194`	`}`
`195`	`195`	`r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "DNS_resolve", dnsResolveFn)`
`196`	`196`	`if err != nil {`
`197`		`- return errmetrics.NewErrorWithMetrics(controllerName, "dns_resolve_error", err, r.metricsCollector)`
	`197`	`+ return ctrlerrors.NewErrorWithMetrics(controllerName, "dns_resolve_error", err, r.metricsCollector)`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`if !backendSGRequired {`
`201`	`201`	`if err := r.backendSGProvider.Release(ctx, networking.ResourceTypeService, []types.NamespacedName{k8s.NamespacedName(svc)}); err != nil {`
`202`		`- return errmetrics.NewErrorWithMetrics(controllerName, "release_auto_generated_backend_sg_error", err, r.metricsCollector)`
	`202`	`+ return ctrlerrors.NewErrorWithMetrics(controllerName, "release_auto_generated_backend_sg_error", err, r.metricsCollector)`
`203`	`203`	`}`
`204`	`204`	`}`
`205`	`205`
`@@ -209,7 +209,7 @@ func (r *serviceReconciler) reconcileLoadBalancerResources(ctx context.Context,`
`209`	`209`	`r.metricsCollector.ObserveControllerReconcileLatency(controllerName, "update_status", updateStatusFn)`
`210`	`210`	`if err != nil {`
`211`	`211`	`r.eventRecorder.Event(svc, corev1.EventTypeWarning, k8s.ServiceEventReasonFailedUpdateStatus, fmt.Sprintf("Failed update status due to %v", err))`
`212`		`- return errmetrics.NewErrorWithMetrics(controllerName, "update_status_error", err, r.metricsCollector)`
	`212`	`+ return ctrlerrors.NewErrorWithMetrics(controllerName, "update_status_error", err, r.metricsCollector)`
`213`	`213`	`}`
`214`	`214`	`r.eventRecorder.Event(svc, corev1.EventTypeNormal, k8s.ServiceEventReasonSuccessfullyReconciled, "Successfully reconciled")`
`215`	`215`	`return nil`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@ package elbv2`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`"context"`
	`5`	`+ ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"`
`5`	`6`	`"time"`
`6`	`7`
`7`	`8`	`awssdk "github.com/aws/aws-sdk-go-v2/aws"`
`@@ -12,7 +13,6 @@ import (`
`12`	`13`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/tracking"`
`13`	`14`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/model/core"`
`14`	`15`	`elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2"`
`15`		`- "sigs.k8s.io/aws-load-balancer-controller/pkg/runtime"`
`16`	`16`	`"sigs.k8s.io/controller-runtime/pkg/client"`
`17`	`17`	`)`
`18`	`18`
`@@ -147,7 +147,7 @@ func (s *frontendNlbTargetSynthesizer) PostSynthesize(ctx context.Context) error`
`147`	`147`
`148`	`148`	`if err != nil {`
`149`	`149`	`requeueMsg := "Failed to register target, retrying after deplay for target group: " + resTG.Status.TargetGroupARN`
`150`		`- return runtime.NewRequeueNeededAfter(requeueMsg, 15*time.Second)`
	`150`	`+ return ctrlerrors.NewRequeueNeededAfter(requeueMsg, 15*time.Second)`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,9 +11,9 @@ import (`
`11`	`11`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services"`
`12`	`12`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/config"`
`13`	`13`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/tracking"`
	`14`	`+ ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"`
`14`	`15`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/model/core"`
`15`	`16`	`elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2"`
`16`		`- "sigs.k8s.io/aws-load-balancer-controller/pkg/runtime"`
`17`	`17`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/shared_constants"`
`18`	`18`	`"strings"`
`19`	`19`	`)`
`@@ -131,7 +131,7 @@ func (s *loadBalancerSynthesizer) PostSynthesize(ctx context.Context) error {`
`131`	`131`	`}`
`132`	`132`	`if isLoadBalancerProvisioning {`
`133`	`133`	`requeueMsg := "monitor provisioning state for load balancer: " + awssdk.ToString(resAndSDKLB.sdkLB.LoadBalancer.LoadBalancerName)`
`134`		`- return runtime.NewRequeueNeededAfter(requeueMsg, s.controllerConfig.LBStabilizationMonitorInterval)`
	`134`	`+ return ctrlerrors.NewRequeueNeededAfter(requeueMsg, s.controllerConfig.LBStabilizationMonitorInterval)`
`135`	`135`	`}`
`136`	`136`	`if err := s.capacityReservationReconciler.Reconcile(ctx, resAndSDKLB.resLB, resAndSDKLB.sdkLB); err != nil {`
`137`	`137`	`return err`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ import (`
`15`	`15`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/tracking"`
`16`	`16`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/wafregional"`
`17`	`17`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/wafv2"`
`18`		`- errmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/error"`
	`18`	`+ ctrlerrors "sigs.k8s.io/aws-load-balancer-controller/pkg/error"`
`19`	`19`	`lbcmetrics "sigs.k8s.io/aws-load-balancer-controller/pkg/metrics/lbc"`
`20`	`20`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/model/core"`
`21`	`21`	`"sigs.k8s.io/aws-load-balancer-controller/pkg/networking"`
`@@ -157,7 +157,7 @@ func (d *defaultStackDeployer) Deploy(ctx context.Context, stack core.Stack, met`
`157`	`157`	`}`
`158`	`158`	`d.metricsCollector.ObserveControllerReconcileLatency(controllerName, synthesizerType, synthesizeFn)`
`159`	`159`	`if err != nil {`
`160`		`- return errmetrics.NewErrorWithMetrics(controllerName, synthesizerType, err, d.metricsCollector)`
	`160`	`+ return ctrlerrors.NewErrorWithMetrics(controllerName, synthesizerType, err, d.metricsCollector)`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`	`for i := len(synthesizers) - 1; i >= 0; i-- {`