fix(logging): Wire up logging for each Reconciler (#50)

k4r1 · ggkhrmv · web-flow · commit 1c07d46ee330 · 2025-07-15T15:53:21.000+02:00
Signed-off-by: Karl Taylor &lt;16408267+k4r1@users.noreply.github.com&gt;

Co-authored-by: Gosha &lt;92053939+ggkhrmv@users.noreply.github.com&gt;
diff --git a/cmd/main.go b/cmd/main.go
@@ -135,6 +135,7 @@ func main() {
 		Scheme:                       mgr.GetScheme(),
 		ArgoCDRBACConfigMapName:      argoCDRBACConfigMapName,
 		ArgoCDRBACConfigMapNamespace: argoCDRBACConfigMapNamespace,
+		Log:                          ctrl.Log.WithName("controllers").WithName("ArgoCDRole"),
 	}).SetupWithManager(mgr); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "Role")
 		os.Exit(1)
@@ -144,12 +145,14 @@ func main() {
 		Scheme:                       mgr.GetScheme(),
 		ArgoCDRBACConfigMapName:      argoCDRBACConfigMapName,
 		ArgoCDRBACConfigMapNamespace: argoCDRBACConfigMapNamespace,
+		Log:                          ctrl.Log.WithName("controllers").WithName("ArgoCDRoleBinding"),
 	}).SetupWithManager(mgr); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "ArgoCDRoleBinding")
 		os.Exit(1)
 	}
 	if err := (&controller.ArgoCDProjectRoleReconciler{
 		Client: mgr.GetClient(),
+		Log:    ctrl.Log.WithName("controllers").WithName("ArgoCDProjectRole"),
 		Scheme: mgr.GetScheme(),
 	}).SetupWithManager(mgr); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "ArgoCDProjectRole")
@@ -158,6 +161,7 @@ func main() {
 	if err := (&controller.ArgoCDProjectRoleBindingReconciler{
 		Client: mgr.GetClient(),
 		Scheme: mgr.GetScheme(),
+		Log:    ctrl.Log.WithName("controllers").WithName("ArgoCDProjectRoleBinding"),
 	}).SetupWithManager(mgr); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "ArgoCDProjectRoleBinding")
 		os.Exit(1)
diff --git a/internal/controller/argocdrole_controller.go b/internal/controller/argocdrole_controller.go
@@ -55,30 +55,30 @@ type ArgoCDRoleReconciler struct {
 func (r *ArgoCDRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
 	_ = r.Log.WithValues("argocdrole", req.NamespacedName)
 
-	r.Log.Info("Reconciling ArgoCDRole %s", req.Name)
+	r.Log.Info("Reconciling ArgoCDRole", "name", req.Name)
 
 	var role rbacoperatorv1alpha1.ArgoCDRole
 	if err := r.Get(ctx, req.NamespacedName, &role); err != nil {
 		if errors.IsNotFound(err) {
-			r.Log.Info("ArgoCDRole %s not found.", req.Name)
+			r.Log.Info("ArgoCDRole not found.", "name", req.Name)
 			return ctrl.Result{}, nil
 		}
 		role.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))
 		if err := r.Client.Status().Update(ctx, &role); err != nil {
-			r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)
+			r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)
 		}
 		return ctrl.Result{}, err
 	}
 
 	if role.IsBeingDeleted() {
 		if err := r.handleFinalizer(ctx, &role); err != nil {
 			if errors.IsConflict(err) {
-				r.Log.Info("Conflict while handling finalizer for ArgoCDRole %s, requeuing", req.Name)
+				r.Log.Info("Conflict while handling finalizer for ArgoCDRole", "name", req.Name)
 				return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, nil
 			}
 			role.SetConditions(rbacoperatorv1alpha1.Deleting().WithMessage(err.Error()))
 			if err := r.Client.Status().Update(ctx, &role); err != nil {
-				r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)
+				r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)
 			}
 			return ctrl.Result{}, fmt.Errorf("error when handling finalizer: %v", err)
 		}
@@ -89,7 +89,7 @@ func (r *ArgoCDRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 		if err := r.addFinalizer(ctx, &role); err != nil {
 			role.SetConditions(rbacoperatorv1alpha1.Deleting().WithMessage(err.Error()))
 			if err := r.Client.Status().Update(ctx, &role); err != nil {
-				r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)
+				r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)
 			}
 			return ctrl.Result{}, fmt.Errorf("error when adding finalizer: %v", err)
 		}
@@ -102,7 +102,7 @@ func (r *ArgoCDRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	if !IsObjectFound(r.Client, cm.Namespace, cm.Name, cm) {
 		role.SetConditions(rbacoperatorv1alpha1.Pending(fmt.Errorf("ConfigMap %s not found", cm.Name)))
 		if err := r.Client.Status().Update(ctx, &role); err != nil {
-			r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)
+			r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)
 		}
 		return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, fmt.Errorf("ConfigMap not found")
 	}
@@ -116,10 +116,10 @@ func (r *ArgoCDRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 		}
 		if err := r.Get(ctx, typeNamespacedNameRoleBinding, &rb); err != nil {
 			if errors.IsNotFound(err) {
-				r.Log.Info("ArgoCDRoleBinding %s not found.", role.Status.ArgoCDRoleBindingRef)
+				r.Log.Info("ArgoCDRoleBinding not found.", "name", role.Status.ArgoCDRoleBindingRef)
 				role.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))
 				if err := r.Client.Status().Update(ctx, &role); err != nil {
-					r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)
+					r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)
 				}
 				return ctrl.Result{}, err
 			}
@@ -129,34 +129,34 @@ func (r *ArgoCDRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 		if err := r.reconcileRBACConfigMapWithRoleBinding(cm, &role, &rb); err != nil {
 			role.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))
 			if err := r.Client.Status().Update(ctx, &role); err != nil {
-				r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)
+				r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)
 			}
 			return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, err
 		}
 
 		role.SetConditions(rbacoperatorv1alpha1.ReconcileSuccess().WithObservedGeneration(role.GetGeneration()))
 		if err := r.Client.Status().Update(ctx, &role); err != nil {
-			r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)
+			r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)
 		}
 		return ctrl.Result{RequeueAfter: time.Minute * 10}, nil
 	}
 
 	r.Log.Info("Reconciling RBAC ConfigMap")
 	if err := r.reconcileRBACConfigMap(cm, &role); err != nil {
 		if errors.IsConflict(err) {
-			r.Log.Info("Conflict while reconciling RBAC ConfigMap, requeuing ArgoCDRole %s", req.Name)
+			r.Log.Info("Conflict while reconciling RBAC ConfigMap, requeuing ArgoCDRole", "name", req.Name)
 			return ctrl.Result{RequeueAfter: time.Second}, nil
 		}
 		role.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))
 		if err := r.Client.Status().Update(ctx, &role); err != nil {
-			r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)
+			r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)
 		}
 		return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, err
 	}
 
 	role.SetConditions(rbacoperatorv1alpha1.ReconcileSuccess().WithObservedGeneration(role.GetGeneration()))
 	if err := r.Client.Status().Update(ctx, &role); err != nil {
-		r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)
+		r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)
 	}
 	return ctrl.Result{RequeueAfter: time.Minute * 10}, nil
 }
diff --git a/internal/controller/argocdrolebinding_controller.go b/internal/controller/argocdrolebinding_controller.go
@@ -53,30 +53,30 @@ type ArgoCDRoleBindingReconciler struct {
 func (r *ArgoCDRoleBindingReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
 	_ = r.Log.WithValues("argocdrole", req.NamespacedName)
 
-	r.Log.Info("Reconciling ArgoCDRoleBinding %s", req.Name)
+	r.Log.Info("Reconciling ArgoCDRoleBinding", "name", req.Name)
 
 	var rb rbacoperatorv1alpha1.ArgoCDRoleBinding
 	if err := r.Get(ctx, req.NamespacedName, &rb); err != nil {
 		if errors.IsNotFound(err) {
-			r.Log.Info("ArgoCDRoleBinding %s not found.", req.Name)
+			r.Log.Info("ArgoCDRoleBinding not found.", "name", req.Name)
 			return ctrl.Result{}, nil
 		}
 		rb.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))
 		if err := r.Client.Status().Update(ctx, &rb); err != nil {
-			r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)
+			r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)
 		}
 		return ctrl.Result{}, err
 	}
 
 	if rb.IsBeingDeleted() {
 		if err := r.handleFinalizer(ctx, &rb); err != nil {
 			if errors.IsConflict(err) {
-				r.Log.Info("Conflict while handling finalizer, requeuing ArgoCDRoleBinding %s", req.Name)
+				r.Log.Info("Conflict while handling finalizer, requeuing ArgoCDRoleBinding", "name", req.Name)
 				return ctrl.Result{RequeueAfter: time.Second}, nil
 			}
 			rb.SetConditions(rbacoperatorv1alpha1.Deleting().WithMessage(err.Error()))
 			if err := r.Client.Status().Update(ctx, &rb); err != nil {
-				r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)
+				r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)
 			}
 			return ctrl.Result{}, fmt.Errorf("error when handling finalizer: %v", err)
 		}
@@ -87,7 +87,7 @@ func (r *ArgoCDRoleBindingReconciler) Reconcile(ctx context.Context, req ctrl.Re
 		if err := r.addFinalizer(ctx, &rb); err != nil {
 			rb.SetConditions(rbacoperatorv1alpha1.Deleting().WithMessage(err.Error()))
 			if err := r.Client.Status().Update(ctx, &rb); err != nil {
-				r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)
+				r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)
 			}
 			return ctrl.Result{}, fmt.Errorf("error when adding finalizer: %v", err)
 		}
@@ -100,7 +100,7 @@ func (r *ArgoCDRoleBindingReconciler) Reconcile(ctx context.Context, req ctrl.Re
 	if !IsObjectFound(r.Client, cm.Namespace, cm.Name, cm) {
 		rb.SetConditions(rbacoperatorv1alpha1.Pending(fmt.Errorf("ConfigMap %s not found", cm.Name)))
 		if err := r.Client.Status().Update(ctx, &rb); err != nil {
-			r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)
+			r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)
 		}
 		return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, fmt.Errorf("ConfigMap not found")
 	}
@@ -116,12 +116,12 @@ func (r *ArgoCDRoleBindingReconciler) Reconcile(ctx context.Context, req ctrl.Re
 
 		if err := r.Get(ctx, typeNamespacedNameRole, &role); err != nil {
 			if errors.IsNotFound(err) {
-				r.Log.Info("ArgoCDRole %s not found.", roleName)
+				r.Log.Info("ArgoCDRole not found.", "name", roleName)
 				return ctrl.Result{RequeueAfter: time.Second}, nil
 			}
 			rb.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))
 			if err := r.Client.Status().Update(ctx, &rb); err != nil {
-				r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)
+				r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)
 			}
 			return ctrl.Result{}, err
 		}
@@ -130,21 +130,21 @@ func (r *ArgoCDRoleBindingReconciler) Reconcile(ctx context.Context, req ctrl.Re
 		if err := r.reconcileRBACConfigMap(cm, &rb, &role); err != nil {
 			rb.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))
 			if err := r.Client.Status().Update(ctx, &rb); err != nil {
-				r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)
+				r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)
 			}
 			return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, err
 		}
 
 		if !role.HasArgoCDRoleBindingRef() {
 			role.SetArgoCDRoleBindingRef(rb.Name)
 			if err := r.Client.Status().Update(ctx, &role); err != nil {
-				r.Log.Error(err, "Failed to update ArgoCDRole %s status", role.Name)
+				r.Log.Error(err, "Failed to update ArgoCDRole status", "name", role.Name)
 			}
 		}
 
 		rb.SetConditions(rbacoperatorv1alpha1.ReconcileSuccess().WithObservedGeneration(rb.GetGeneration()))
 		if err := r.Client.Status().Update(ctx, &rb); err != nil {
-			r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)
+			r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)
 		}
 		return ctrl.Result{RequeueAfter: time.Minute * 10}, nil
 
@@ -162,19 +162,19 @@ func (r *ArgoCDRoleBindingReconciler) Reconcile(ctx context.Context, req ctrl.Re
 	r.Log.Info("Reconciling RBAC ConfigMap")
 	if err := r.reconcileRBACConfigMapForBuiltInRole(cm, &rb, role); err != nil {
 		if errors.IsConflict(err) {
-			r.Log.Info("Conflict while reconciling RBAC ConfigMap, requeuing ArgoCDRoleBinding %s", req.Name)
+			r.Log.Info("Conflict while reconciling RBAC ConfigMap, requeuing ArgoCDRoleBinding", "name", req.Name)
 			return ctrl.Result{RequeueAfter: time.Second}, nil
 		}
 		rb.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))
 		if err := r.Client.Status().Update(ctx, &rb); err != nil {
-			r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)
+			r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)
 		}
 		return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, err
 	}
 
 	rb.SetConditions(rbacoperatorv1alpha1.ReconcileSuccess().WithObservedGeneration(rb.GetGeneration()))
 	if err := r.Client.Status().Update(ctx, &rb); err != nil {
-		r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)
+		r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)
 	}
 	return ctrl.Result{RequeueAfter: time.Minute * 10}, nil
 }

Original file line number	Diff line number	Diff line change
`@@ -55,30 +55,30 @@ type ArgoCDRoleReconciler struct {`
`55`	`55`	`func (r *ArgoCDRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {`
`56`	`56`	`_ = r.Log.WithValues("argocdrole", req.NamespacedName)`
`57`	`57`
`58`		`- r.Log.Info("Reconciling ArgoCDRole %s", req.Name)`
	`58`	`+ r.Log.Info("Reconciling ArgoCDRole", "name", req.Name)`
`59`	`59`
`60`	`60`	`var role rbacoperatorv1alpha1.ArgoCDRole`
`61`	`61`	`if err := r.Get(ctx, req.NamespacedName, &role); err != nil {`
`62`	`62`	`if errors.IsNotFound(err) {`
`63`		`- r.Log.Info("ArgoCDRole %s not found.", req.Name)`
	`63`	`+ r.Log.Info("ArgoCDRole not found.", "name", req.Name)`
`64`	`64`	`return ctrl.Result{}, nil`
`65`	`65`	`}`
`66`	`66`	`role.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))`
`67`	`67`	`if err := r.Client.Status().Update(ctx, &role); err != nil {`
`68`		`- r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)`
	`68`	`+ r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)`
`69`	`69`	`}`
`70`	`70`	`return ctrl.Result{}, err`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`if role.IsBeingDeleted() {`
`74`	`74`	`if err := r.handleFinalizer(ctx, &role); err != nil {`
`75`	`75`	`if errors.IsConflict(err) {`
`76`		`- r.Log.Info("Conflict while handling finalizer for ArgoCDRole %s, requeuing", req.Name)`
	`76`	`+ r.Log.Info("Conflict while handling finalizer for ArgoCDRole", "name", req.Name)`
`77`	`77`	`return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, nil`
`78`	`78`	`}`
`79`	`79`	`role.SetConditions(rbacoperatorv1alpha1.Deleting().WithMessage(err.Error()))`
`80`	`80`	`if err := r.Client.Status().Update(ctx, &role); err != nil {`
`81`		`- r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)`
	`81`	`+ r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)`
`82`	`82`	`}`
`83`	`83`	`return ctrl.Result{}, fmt.Errorf("error when handling finalizer: %v", err)`
`84`	`84`	`}`
`@@ -89,7 +89,7 @@ func (r *ArgoCDRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request)`
`89`	`89`	`if err := r.addFinalizer(ctx, &role); err != nil {`
`90`	`90`	`role.SetConditions(rbacoperatorv1alpha1.Deleting().WithMessage(err.Error()))`
`91`	`91`	`if err := r.Client.Status().Update(ctx, &role); err != nil {`
`92`		`- r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)`
	`92`	`+ r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)`
`93`	`93`	`}`
`94`	`94`	`return ctrl.Result{}, fmt.Errorf("error when adding finalizer: %v", err)`
`95`	`95`	`}`
`@@ -102,7 +102,7 @@ func (r *ArgoCDRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request)`
`102`	`102`	`if !IsObjectFound(r.Client, cm.Namespace, cm.Name, cm) {`
`103`	`103`	`role.SetConditions(rbacoperatorv1alpha1.Pending(fmt.Errorf("ConfigMap %s not found", cm.Name)))`
`104`	`104`	`if err := r.Client.Status().Update(ctx, &role); err != nil {`
`105`		`- r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)`
	`105`	`+ r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)`
`106`	`106`	`}`
`107`	`107`	`return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, fmt.Errorf("ConfigMap not found")`
`108`	`108`	`}`
`@@ -116,10 +116,10 @@ func (r *ArgoCDRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request)`
`116`	`116`	`}`
`117`	`117`	`if err := r.Get(ctx, typeNamespacedNameRoleBinding, &rb); err != nil {`
`118`	`118`	`if errors.IsNotFound(err) {`
`119`		`- r.Log.Info("ArgoCDRoleBinding %s not found.", role.Status.ArgoCDRoleBindingRef)`
	`119`	`+ r.Log.Info("ArgoCDRoleBinding not found.", "name", role.Status.ArgoCDRoleBindingRef)`
`120`	`120`	`role.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))`
`121`	`121`	`if err := r.Client.Status().Update(ctx, &role); err != nil {`
`122`		`- r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)`
	`122`	`+ r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)`
`123`	`123`	`}`
`124`	`124`	`return ctrl.Result{}, err`
`125`	`125`	`}`
`@@ -129,34 +129,34 @@ func (r *ArgoCDRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request)`
`129`	`129`	`if err := r.reconcileRBACConfigMapWithRoleBinding(cm, &role, &rb); err != nil {`
`130`	`130`	`role.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))`
`131`	`131`	`if err := r.Client.Status().Update(ctx, &role); err != nil {`
`132`		`- r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)`
	`132`	`+ r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)`
`133`	`133`	`}`
`134`	`134`	`return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, err`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`role.SetConditions(rbacoperatorv1alpha1.ReconcileSuccess().WithObservedGeneration(role.GetGeneration()))`
`138`	`138`	`if err := r.Client.Status().Update(ctx, &role); err != nil {`
`139`		`- r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)`
	`139`	`+ r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)`
`140`	`140`	`}`
`141`	`141`	`return ctrl.Result{RequeueAfter: time.Minute * 10}, nil`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`r.Log.Info("Reconciling RBAC ConfigMap")`
`145`	`145`	`if err := r.reconcileRBACConfigMap(cm, &role); err != nil {`
`146`	`146`	`if errors.IsConflict(err) {`
`147`		`- r.Log.Info("Conflict while reconciling RBAC ConfigMap, requeuing ArgoCDRole %s", req.Name)`
	`147`	`+ r.Log.Info("Conflict while reconciling RBAC ConfigMap, requeuing ArgoCDRole", "name", req.Name)`
`148`	`148`	`return ctrl.Result{RequeueAfter: time.Second}, nil`
`149`	`149`	`}`
`150`	`150`	`role.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))`
`151`	`151`	`if err := r.Client.Status().Update(ctx, &role); err != nil {`
`152`		`- r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)`
	`152`	`+ r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)`
`153`	`153`	`}`
`154`	`154`	`return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, err`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`role.SetConditions(rbacoperatorv1alpha1.ReconcileSuccess().WithObservedGeneration(role.GetGeneration()))`
`158`	`158`	`if err := r.Client.Status().Update(ctx, &role); err != nil {`
`159`		`- r.Log.Error(err, "Failed to update ArgoCDRole %s status", req.Name)`
	`159`	`+ r.Log.Error(err, "Failed to update ArgoCDRole status", "name", req.Name)`
`160`	`160`	`}`
`161`	`161`	`return ctrl.Result{RequeueAfter: time.Minute * 10}, nil`
`162`	`162`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,30 +53,30 @@ type ArgoCDRoleBindingReconciler struct {`
`53`	`53`	`func (r *ArgoCDRoleBindingReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {`
`54`	`54`	`_ = r.Log.WithValues("argocdrole", req.NamespacedName)`
`55`	`55`
`56`		`- r.Log.Info("Reconciling ArgoCDRoleBinding %s", req.Name)`
	`56`	`+ r.Log.Info("Reconciling ArgoCDRoleBinding", "name", req.Name)`
`57`	`57`
`58`	`58`	`var rb rbacoperatorv1alpha1.ArgoCDRoleBinding`
`59`	`59`	`if err := r.Get(ctx, req.NamespacedName, &rb); err != nil {`
`60`	`60`	`if errors.IsNotFound(err) {`
`61`		`- r.Log.Info("ArgoCDRoleBinding %s not found.", req.Name)`
	`61`	`+ r.Log.Info("ArgoCDRoleBinding not found.", "name", req.Name)`
`62`	`62`	`return ctrl.Result{}, nil`
`63`	`63`	`}`
`64`	`64`	`rb.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))`
`65`	`65`	`if err := r.Client.Status().Update(ctx, &rb); err != nil {`
`66`		`- r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)`
	`66`	`+ r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)`
`67`	`67`	`}`
`68`	`68`	`return ctrl.Result{}, err`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`if rb.IsBeingDeleted() {`
`72`	`72`	`if err := r.handleFinalizer(ctx, &rb); err != nil {`
`73`	`73`	`if errors.IsConflict(err) {`
`74`		`- r.Log.Info("Conflict while handling finalizer, requeuing ArgoCDRoleBinding %s", req.Name)`
	`74`	`+ r.Log.Info("Conflict while handling finalizer, requeuing ArgoCDRoleBinding", "name", req.Name)`
`75`	`75`	`return ctrl.Result{RequeueAfter: time.Second}, nil`
`76`	`76`	`}`
`77`	`77`	`rb.SetConditions(rbacoperatorv1alpha1.Deleting().WithMessage(err.Error()))`
`78`	`78`	`if err := r.Client.Status().Update(ctx, &rb); err != nil {`
`79`		`- r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)`
	`79`	`+ r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)`
`80`	`80`	`}`
`81`	`81`	`return ctrl.Result{}, fmt.Errorf("error when handling finalizer: %v", err)`
`82`	`82`	`}`
`@@ -87,7 +87,7 @@ func (r *ArgoCDRoleBindingReconciler) Reconcile(ctx context.Context, req ctrl.Re`
`87`	`87`	`if err := r.addFinalizer(ctx, &rb); err != nil {`
`88`	`88`	`rb.SetConditions(rbacoperatorv1alpha1.Deleting().WithMessage(err.Error()))`
`89`	`89`	`if err := r.Client.Status().Update(ctx, &rb); err != nil {`
`90`		`- r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)`
	`90`	`+ r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)`
`91`	`91`	`}`
`92`	`92`	`return ctrl.Result{}, fmt.Errorf("error when adding finalizer: %v", err)`
`93`	`93`	`}`
`@@ -100,7 +100,7 @@ func (r *ArgoCDRoleBindingReconciler) Reconcile(ctx context.Context, req ctrl.Re`
`100`	`100`	`if !IsObjectFound(r.Client, cm.Namespace, cm.Name, cm) {`
`101`	`101`	`rb.SetConditions(rbacoperatorv1alpha1.Pending(fmt.Errorf("ConfigMap %s not found", cm.Name)))`
`102`	`102`	`if err := r.Client.Status().Update(ctx, &rb); err != nil {`
`103`		`- r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)`
	`103`	`+ r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)`
`104`	`104`	`}`
`105`	`105`	`return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, fmt.Errorf("ConfigMap not found")`
`106`	`106`	`}`
`@@ -116,12 +116,12 @@ func (r *ArgoCDRoleBindingReconciler) Reconcile(ctx context.Context, req ctrl.Re`
`116`	`116`
`117`	`117`	`if err := r.Get(ctx, typeNamespacedNameRole, &role); err != nil {`
`118`	`118`	`if errors.IsNotFound(err) {`
`119`		`- r.Log.Info("ArgoCDRole %s not found.", roleName)`
	`119`	`+ r.Log.Info("ArgoCDRole not found.", "name", roleName)`
`120`	`120`	`return ctrl.Result{RequeueAfter: time.Second}, nil`
`121`	`121`	`}`
`122`	`122`	`rb.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))`
`123`	`123`	`if err := r.Client.Status().Update(ctx, &rb); err != nil {`
`124`		`- r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)`
	`124`	`+ r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)`
`125`	`125`	`}`
`126`	`126`	`return ctrl.Result{}, err`
`127`	`127`	`}`
`@@ -130,21 +130,21 @@ func (r *ArgoCDRoleBindingReconciler) Reconcile(ctx context.Context, req ctrl.Re`
`130`	`130`	`if err := r.reconcileRBACConfigMap(cm, &rb, &role); err != nil {`
`131`	`131`	`rb.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))`
`132`	`132`	`if err := r.Client.Status().Update(ctx, &rb); err != nil {`
`133`		`- r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)`
	`133`	`+ r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)`
`134`	`134`	`}`
`135`	`135`	`return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, err`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`if !role.HasArgoCDRoleBindingRef() {`
`139`	`139`	`role.SetArgoCDRoleBindingRef(rb.Name)`
`140`	`140`	`if err := r.Client.Status().Update(ctx, &role); err != nil {`
`141`		`- r.Log.Error(err, "Failed to update ArgoCDRole %s status", role.Name)`
	`141`	`+ r.Log.Error(err, "Failed to update ArgoCDRole status", "name", role.Name)`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`rb.SetConditions(rbacoperatorv1alpha1.ReconcileSuccess().WithObservedGeneration(rb.GetGeneration()))`
`146`	`146`	`if err := r.Client.Status().Update(ctx, &rb); err != nil {`
`147`		`- r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)`
	`147`	`+ r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)`
`148`	`148`	`}`
`149`	`149`	`return ctrl.Result{RequeueAfter: time.Minute * 10}, nil`
`150`	`150`
`@@ -162,19 +162,19 @@ func (r *ArgoCDRoleBindingReconciler) Reconcile(ctx context.Context, req ctrl.Re`
`162`	`162`	`r.Log.Info("Reconciling RBAC ConfigMap")`
`163`	`163`	`if err := r.reconcileRBACConfigMapForBuiltInRole(cm, &rb, role); err != nil {`
`164`	`164`	`if errors.IsConflict(err) {`
`165`		`- r.Log.Info("Conflict while reconciling RBAC ConfigMap, requeuing ArgoCDRoleBinding %s", req.Name)`
	`165`	`+ r.Log.Info("Conflict while reconciling RBAC ConfigMap, requeuing ArgoCDRoleBinding", "name", req.Name)`
`166`	`166`	`return ctrl.Result{RequeueAfter: time.Second}, nil`
`167`	`167`	`}`
`168`	`168`	`rb.SetConditions(rbacoperatorv1alpha1.ReconcileError(err))`
`169`	`169`	`if err := r.Client.Status().Update(ctx, &rb); err != nil {`
`170`		`- r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)`
	`170`	`+ r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)`
`171`	`171`	`}`
`172`	`172`	`return ctrl.Result{Requeue: true, RequeueAfter: time.Second}, err`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`rb.SetConditions(rbacoperatorv1alpha1.ReconcileSuccess().WithObservedGeneration(rb.GetGeneration()))`
`176`	`176`	`if err := r.Client.Status().Update(ctx, &rb); err != nil {`
`177`		`- r.Log.Error(err, "Failed to update ArgoCDRoleBinding %s status", req.Name)`
	`177`	`+ r.Log.Error(err, "Failed to update ArgoCDRoleBinding status", "name", req.Name)`
`178`	`178`	`}`
`179`	`179`	`return ctrl.Result{RequeueAfter: time.Minute * 10}, nil`
`180`	`180`	`}`