CNF-22825: Consolidate around klog/v2

pkg/controller/istiocsr/certificates.go

@@ -6,6 +6,7 @@ import (
 
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/klog/v2"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	certmanagerv1 "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1"
@@ -23,7 +24,7 @@ func (r *Reconciler) createOrApplyCertificates(istiocsr *v1alpha1.IstioCSR, reso
 	}
 
 	certificateName := fmt.Sprintf("%s/%s", desired.GetNamespace(), desired.GetName())
-	r.log.V(4).Info("reconciling certificate resource", "name", certificateName)
+	klog.V(4).InfoS("reconciling certificate resource", "name", certificateName)
 	fetched := &certmanagerv1.Certificate{}
 	exist, err := r.Exists(r.ctx, client.ObjectKeyFromObject(desired), fetched)
 	if err != nil {
@@ -35,13 +36,13 @@ func (r *Reconciler) createOrApplyCertificates(istiocsr *v1alpha1.IstioCSR, reso
 			r.eventRecorder.Eventf(istiocsr, corev1.EventTypeWarning, "ResourceAlreadyExists", "%s certificate resource already exists, maybe from previous installation", certificateName)
 		}
 		if hasObjectChanged(desired, fetched) {
-			r.log.V(1).Info("certificate has been modified, updating to desired state", "name", certificateName)
+			klog.V(1).InfoS("certificate has been modified, updating to desired state", "name", certificateName)
 			if err := r.UpdateWithRetry(r.ctx, desired); err != nil {
 				return common.FromClientError(err, "failed to update %s certificate resource", certificateName)
 			}
 			r.eventRecorder.Eventf(istiocsr, corev1.EventTypeNormal, "Reconciled", "certificate resource %s reconciled back to desired state", certificateName)
 		} else {
-			r.log.V(4).Info("certificate resource already exists and is in expected state", "name", certificateName)
+			klog.V(4).InfoS("certificate resource already exists and is in expected state", "name", certificateName)
 		}
 	}
 

pkg/controller/istiocsr/controller.go

@@ -14,6 +14,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/tools/record"
+	"k8s.io/klog/v2"
 
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/builder"
@@ -22,8 +23,6 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
-	"github.com/go-logr/logr"
-
 	certmanagerv1 "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1"
 
 	v1alpha1 "github.com/openshift/cert-manager-operator/api/operator/v1alpha1"
@@ -41,7 +40,6 @@ type Reconciler struct {
 
 	ctx           context.Context
 	eventRecorder record.EventRecorder
-	log           logr.Logger
 	scheme        *runtime.Scheme
 }
 
@@ -60,15 +58,14 @@ func New(mgr ctrl.Manager) (*Reconciler, error) {
 		CtrlClient:    c,
 		ctx:           context.Background(),
 		eventRecorder: mgr.GetEventRecorderFor(ControllerName),
-		log:           ctrl.Log.WithName(ControllerName),
 		scheme:        mgr.GetScheme(),
 	}, nil
 }
 
 // SetupWithManager sets up the controller with the Manager.
 func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error {
 	mapFunc := func(ctx context.Context, obj client.Object) []reconcile.Request {
-		r.log.V(4).Info("received reconcile event", "object", fmt.Sprintf("%T", obj), "name", obj.GetName(), "namespace", obj.GetNamespace())
+		klog.V(4).InfoS("received reconcile event", "object", fmt.Sprintf("%T", obj), "name", obj.GetName(), "namespace", obj.GetNamespace())
 
 		objLabels := obj.GetLabels()
 		if objLabels != nil {
@@ -90,7 +87,10 @@ func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error {
 				}
 				key := strings.Split(value, "_")
 				if len(key) != 2 {
-					r.log.Error(fmt.Errorf("invalid label format"), "%s label value(%s) not in expected format on %s resource", IstiocsrResourceWatchLabelName, value, obj.GetName())
+					klog.ErrorS(fmt.Errorf("invalid label format"), "label value not in expected format",
+					"labelName", IstiocsrResourceWatchLabelName,
+					"labelValue", value,
+					"resource", obj.GetName())
 					return false
 				}
 				namespace = key[0]
@@ -109,7 +109,7 @@ func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error {
 			}
 		}
 
-		r.log.V(4).Info("object not of interest, ignoring reconcile event", "object", fmt.Sprintf("%T", obj), "name", obj.GetName(), "namespace", obj.GetNamespace())
+		klog.V(4).InfoS("object not of interest, ignoring reconcile event", "object", fmt.Sprintf("%T", obj), "name", obj.GetName(), "namespace", obj.GetNamespace())
 		return []reconcile.Request{}
 	}
 
@@ -160,7 +160,7 @@ func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error {
 // Reconcile function to compare the state specified by the IstioCSR object against the actual cluster state,
 // and to make the cluster state reflect the state specified by the user.
 func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
-	r.log.V(1).Info("reconciling", "request", req)
+	klog.V(1).InfoS("reconciling", "request", req)
 
 	// Fetch the istiocsr.openshift.operator.io CR
 	istiocsr := &v1alpha1.IstioCSR{}
@@ -169,14 +169,14 @@ func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Resu
 			// NotFound errors, since they can't be fixed by an immediate
 			// requeue (have to wait for a new notification), and can be processed
 			// on deleted requests.
-			r.log.V(1).Info("istiocsr.openshift.operator.io object not found, skipping reconciliation", "request", req)
+			klog.V(1).InfoS("istiocsr.openshift.operator.io object not found, skipping reconciliation", "request", req)
 			return ctrl.Result{}, nil
 		}
 		return ctrl.Result{}, fmt.Errorf("failed to fetch istiocsr.openshift.operator.io %q during reconciliation: %w", req.NamespacedName, err)
 	}
 
 	if !istiocsr.DeletionTimestamp.IsZero() {
-		r.log.V(1).Info("istiocsr.openshift.operator.io is marked for deletion", "namespace", req.NamespacedName)
+		klog.V(1).InfoS("istiocsr.openshift.operator.io is marked for deletion", "namespace", req.NamespacedName)
 
 		if requeue, err := r.cleanUp(istiocsr); err != nil {
 			return ctrl.Result{}, fmt.Errorf("clean up failed for %q istiocsr.openshift.operator.io instance deletion: %w", req.NamespacedName, err)
@@ -188,7 +188,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Resu
 			return ctrl.Result{}, err
 		}
 
-		r.log.V(1).Info("removed finalizer, cleanup complete", "request", req.NamespacedName)
+		klog.V(1).InfoS("removed finalizer, cleanup complete", "request", req.NamespacedName)
 		return ctrl.Result{}, nil
 	}
 
@@ -203,7 +203,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Resu
 func (r *Reconciler) processReconcileRequest(istiocsr *v1alpha1.IstioCSR, req types.NamespacedName) (ctrl.Result, error) {
 	istioCSRCreateRecon := false
 	if !containsProcessedAnnotation(istiocsr) && reflect.DeepEqual(istiocsr.Status, v1alpha1.IstioCSRStatus{}) {
-		r.log.V(1).Info("starting reconciliation of newly created istiocsr", "namespace", istiocsr.GetNamespace(), "name", istiocsr.GetName())
+		klog.V(1).InfoS("starting reconciliation of newly created istiocsr", "namespace", istiocsr.GetNamespace(), "name", istiocsr.GetName())
 		istioCSRCreateRecon = true
 	}
 
@@ -217,13 +217,13 @@ func (r *Reconciler) processReconcileRequest(istiocsr *v1alpha1.IstioCSR, req ty
 
 	reconcileErr := r.reconcileIstioCSRDeployment(istiocsr, istioCSRCreateRecon)
 	if reconcileErr != nil {
-		r.log.Error(reconcileErr, "failed to reconcile IstioCSR deployment", "request", req)
+		klog.ErrorS(reconcileErr, "failed to reconcile IstioCSR deployment", "request", req)
 	}
 
 	return common.HandleReconcileResult(
 		&istiocsr.Status.ConditionalStatus,
 		reconcileErr,
-		r.log.WithValues("namespace", istiocsr.GetNamespace(), "name", istiocsr.GetName()),
+		klog.NewKlogr().WithValues("namespace", istiocsr.GetNamespace(), "name", istiocsr.GetName()),
 		func(prependErr error) error {
 			return r.updateCondition(istiocsr, prependErr)
 		},

pkg/controller/istiocsr/deployments.go

@@ -13,6 +13,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/validation/field"
+	"k8s.io/klog/v2"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	certmanagerv1 "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1"
@@ -35,7 +36,7 @@ func (r *Reconciler) createOrApplyDeployments(istiocsr *v1alpha1.IstioCSR, resou
 	}
 
 	deploymentName := fmt.Sprintf("%s/%s", desired.GetNamespace(), desired.GetName())
-	r.log.V(4).Info("reconciling deployment resource", "name", deploymentName)
+	klog.V(4).InfoS("reconciling deployment resource", "name", deploymentName)
 	fetched := &appsv1.Deployment{}
 	exist, err := r.Exists(r.ctx, client.ObjectKeyFromObject(desired), fetched)
 	if err != nil {
@@ -47,13 +48,13 @@ func (r *Reconciler) createOrApplyDeployments(istiocsr *v1alpha1.IstioCSR, resou
 			r.eventRecorder.Eventf(istiocsr, corev1.EventTypeWarning, "ResourceAlreadyExists", "%s deployment resource already exists, maybe from previous installation", deploymentName)
 		}
 		if hasObjectChanged(desired, fetched) {
-			r.log.V(1).Info("deployment has been modified, updating to desired state", "name", deploymentName)
+			klog.V(1).InfoS("deployment has been modified, updating to desired state", "name", deploymentName)
 			if err := r.UpdateWithRetry(r.ctx, desired); err != nil {
 				return common.FromClientError(err, "failed to update %s deployment resource", deploymentName)
 			}
 			r.eventRecorder.Eventf(istiocsr, corev1.EventTypeNormal, "Reconciled", "deployment resource %s reconciled back to desired state", deploymentName)
 		} else {
-			r.log.V(4).Info("deployment resource already exists and is in expected state", "name", deploymentName)
+			klog.V(4).InfoS("deployment resource already exists and is in expected state", "name", deploymentName)
 		}
 	}
 
@@ -575,13 +576,13 @@ func (r *Reconciler) createOrUpdateCAConfigMap(istiocsr *v1alpha1.IstioCSR, cert
 	}
 
 	if exist && hasObjectChanged(desired, fetched) {
-		r.log.V(1).Info("ca configmap need update", "name", configmapKey)
+		klog.V(1).InfoS("ca configmap need update", "name", configmapKey)
 		if err := r.UpdateWithRetry(r.ctx, desired); err != nil {
 			return fmt.Errorf("failed to update %s configmap resource: %w", configmapKey, err)
 		}
 		r.eventRecorder.Eventf(istiocsr, corev1.EventTypeNormal, "Reconciled", "configmap resource %s reconciled back to desired state", configmapKey)
 	} else {
-		r.log.V(4).Info("configmap resource already exists and is in expected state", "name", configmapKey)
+		klog.V(4).InfoS("configmap resource already exists and is in expected state", "name", configmapKey)
 	}
 
 	if !exist {

pkg/controller/istiocsr/install_istiocsr.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"maps"
 
+	"k8s.io/klog/v2"
+
 	"github.com/openshift/cert-manager-operator/api/operator/v1alpha1"
 	"github.com/openshift/cert-manager-operator/pkg/controller/common"
 )
@@ -22,32 +24,32 @@ func (r *Reconciler) reconcileIstioCSRDeployment(istiocsr *v1alpha1.IstioCSR, is
 	maps.Copy(resourceLabels, controllerDefaultResourceLabels)
 
 	if err := r.createOrApplyNetworkPolicies(istiocsr, resourceLabels, istioCSRCreateRecon); err != nil {
-		r.log.Error(err, "failed to reconcile network policy resources")
+		klog.ErrorS(err, "failed to reconcile network policy resources")
 		return err
 	}
 
 	if err := r.createOrApplyServices(istiocsr, resourceLabels, istioCSRCreateRecon); err != nil {
-		r.log.Error(err, "failed to reconcile service resource")
+		klog.ErrorS(err, "failed to reconcile service resource")
 		return err
 	}
 
 	if err := r.createOrApplyServiceAccounts(istiocsr, resourceLabels, istioCSRCreateRecon); err != nil {
-		r.log.Error(err, "failed to reconcile serviceaccount resource")
+		klog.ErrorS(err, "failed to reconcile serviceaccount resource")
 		return err
 	}
 
 	if err := r.createOrApplyRBACResource(istiocsr, resourceLabels, istioCSRCreateRecon); err != nil {
-		r.log.Error(err, "failed to reconcile rbac resources")
+		klog.ErrorS(err, "failed to reconcile rbac resources")
 		return err
 	}
 
 	if err := r.createOrApplyCertificates(istiocsr, resourceLabels, istioCSRCreateRecon); err != nil {
-		r.log.Error(err, "failed to reconcile certificate resource")
+		klog.ErrorS(err, "failed to reconcile certificate resource")
 		return err
 	}
 
 	if err := r.createOrApplyDeployments(istiocsr, resourceLabels, istioCSRCreateRecon); err != nil {
-		r.log.Error(err, "failed to reconcile deployment resource")
+		klog.ErrorS(err, "failed to reconcile deployment resource")
 		return err
 	}
 
@@ -57,6 +59,6 @@ func (r *Reconciler) reconcileIstioCSRDeployment(istiocsr *v1alpha1.IstioCSR, is
 		}
 	}
 
-	r.log.V(4).Info("finished reconciliation of istiocsr", "namespace", istiocsr.GetNamespace(), "name", istiocsr.GetName())
+	klog.V(4).InfoS("finished reconciliation of istiocsr", "namespace", istiocsr.GetNamespace(), "name", istiocsr.GetName())
 	return nil
 }

pkg/controller/istiocsr/networkpolicies.go

@@ -8,14 +8,15 @@ import (
 	networkingv1 "k8s.io/api/networking/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/klog/v2"
 
 	"github.com/openshift/cert-manager-operator/api/operator/v1alpha1"
 	"github.com/openshift/cert-manager-operator/pkg/controller/common"
 	"github.com/openshift/cert-manager-operator/pkg/operator/assets"
 )
 
 func (r *Reconciler) createOrApplyNetworkPolicies(istiocsr *v1alpha1.IstioCSR, resourceLabels map[string]string, istioCSRCreateRecon bool) error {
-	r.log.V(4).Info("reconciling istio-csr network policies", "namespace", istiocsr.GetNamespace(), "name", istiocsr.GetName())
+	klog.V(4).InfoS("reconciling istio-csr network policies", "namespace", istiocsr.GetNamespace(), "name", istiocsr.GetName())
 
 	// Apply static network policy assets for istio-csr
 	for _, assetPath := range istioCSRNetworkPolicyAssets {
@@ -65,7 +66,7 @@ func (r *Reconciler) getNetworkPolicyFromAsset(assetPath string, istiocsr *v1alp
 func (r *Reconciler) createOrUpdateNetworkPolicy(policy *networkingv1.NetworkPolicy, istioCSRCreateRecon bool) error {
 	desired := policy.DeepCopy()
 	policyName := fmt.Sprintf("%s/%s", desired.GetNamespace(), desired.GetName())
-	r.log.V(4).Info("reconciling network policy resource", "name", policyName)
+	klog.V(4).InfoS("reconciling network policy resource", "name", policyName)
 
 	fetched := &networkingv1.NetworkPolicy{}
 	key := types.NamespacedName{
@@ -82,13 +83,13 @@ func (r *Reconciler) createOrUpdateNetworkPolicy(policy *networkingv1.NetworkPol
 			r.eventRecorder.Eventf(policy, corev1.EventTypeWarning, "ResourceAlreadyExists", "%s network policy resource already exists, maybe from previous installation", policyName)
 		}
 		if hasObjectChanged(desired, fetched) {
-			r.log.V(1).Info("network policy has been modified, updating to desired state", "name", policyName)
+			klog.V(1).InfoS("network policy has been modified, updating to desired state", "name", policyName)
 			if err := r.UpdateWithRetry(r.ctx, desired); err != nil {
 				return common.FromClientError(err, "failed to update %s network policy resource", policyName)
 			}
 			r.eventRecorder.Eventf(policy, corev1.EventTypeNormal, "Reconciled", "network policy resource %s reconciled back to desired state", policyName)
 		} else {
-			r.log.V(4).Info("network policy resource already exists and is in expected state", "name", policyName)
+			klog.V(4).InfoS("network policy resource already exists and is in expected state", "name", policyName)
 		}
 	}