Consolidate around klog/v2

go.mod

@@ -5,7 +5,6 @@ go 1.24.4
 require (
 	github.com/cert-manager/cert-manager v1.18.3
 	github.com/go-bindata/go-bindata v3.1.2+incompatible
-	github.com/go-logr/logr v1.4.2
 	github.com/golangci/golangci-lint v1.50.1
 	github.com/google/go-cmp v0.6.0
 	github.com/google/go-jsonnet v0.17.0
@@ -91,6 +90,7 @@ require (
 	github.com/fzipp/gocyclo v0.6.0 // indirect
 	github.com/go-critic/go-critic v0.6.5 // indirect
 	github.com/go-errors/errors v1.4.2 // indirect
+	github.com/go-logr/logr v1.4.2 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-logr/zapr v1.3.0 // indirect
 	github.com/go-openapi/jsonpointer v0.21.0 // indirect

pkg/controller/istiocsr/certificates.go

@@ -5,6 +5,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"
@@ -21,7 +22,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 {
@@ -32,13 +33,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 exist && 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 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)
 	}
 	if !exist {
 		if err := r.Create(r.ctx, desired); err != nil {

pkg/controller/istiocsr/controller.go

@@ -18,6 +18,7 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/record"
+	"k8s.io/klog/v2"
 
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/builder"
@@ -27,8 +28,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"
@@ -50,7 +49,6 @@ type Reconciler struct {
 
 	ctx           context.Context
 	eventRecorder record.EventRecorder
-	log           logr.Logger
 	scheme        *runtime.Scheme
 }
 
@@ -116,15 +114,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 {
@@ -146,7 +143,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]
@@ -165,7 +165,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{}
 	}
 
@@ -214,7 +214,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{}
@@ -223,14 +223,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)
@@ -242,7 +242,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
 	}
 
@@ -257,7 +257,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
 	}
 
@@ -271,14 +271,14 @@ func (r *Reconciler) processReconcileRequest(istiocsr *v1alpha1.IstioCSR, req ty
 
 	var errUpdate error = nil
 	if err := r.reconcileIstioCSRDeployment(istiocsr, istioCSRCreateRecon); err != nil {
-		r.log.Error(err, "failed to reconcile IstioCSR deployment", "request", req)
+		klog.ErrorS(err, "failed to reconcile IstioCSR deployment", "request", req)
 		if IsIrrecoverableError(err) {
 			// Set both conditions atomically before updating status
 			degradedChanged := istiocsr.Status.SetCondition(v1alpha1.Degraded, metav1.ConditionTrue, v1alpha1.ReasonFailed, fmt.Sprintf("reconciliation failed with irrecoverable error not retrying: %v", err))
 			readyChanged := istiocsr.Status.SetCondition(v1alpha1.Ready, metav1.ConditionFalse, v1alpha1.ReasonReady, "")
 
 			if degradedChanged || readyChanged {
-				r.log.V(2).Info("updating istiocsr conditions on irrecoverable error",
+				klog.V(2).InfoS("updating istiocsr conditions on irrecoverable error",
 					"namespace", istiocsr.GetNamespace(),
 					"name", istiocsr.GetName(),
 					"degradedChanged", degradedChanged,
@@ -293,7 +293,7 @@ func (r *Reconciler) processReconcileRequest(istiocsr *v1alpha1.IstioCSR, req ty
 			readyChanged := istiocsr.Status.SetCondition(v1alpha1.Ready, metav1.ConditionFalse, v1alpha1.ReasonInProgress, fmt.Sprintf("reconciliation failed, retrying: %v", err))
 
 			if degradedChanged || readyChanged {
-				r.log.V(2).Info("updating istiocsr conditions on recoverable error",
+				klog.V(2).InfoS("updating istiocsr conditions on recoverable error",
 					"namespace", istiocsr.GetNamespace(),
 					"name", istiocsr.GetName(),
 					"degradedChanged", degradedChanged,
@@ -315,7 +315,7 @@ func (r *Reconciler) processReconcileRequest(istiocsr *v1alpha1.IstioCSR, req ty
 	readyChanged := istiocsr.Status.SetCondition(v1alpha1.Ready, metav1.ConditionTrue, v1alpha1.ReasonReady, "reconciliation successful")
 
 	if degradedChanged || readyChanged {
-		r.log.V(2).Info("updating istiocsr conditions on successful reconciliation",
+		klog.V(2).InfoS("updating istiocsr conditions on successful reconciliation",
 			"namespace", istiocsr.GetNamespace(),
 			"name", istiocsr.GetName(),
 			"degradedChanged", degradedChanged,

pkg/controller/istiocsr/deployments.go

@@ -15,6 +15,7 @@ import (
 	metav1validation "k8s.io/apimachinery/pkg/apis/meta/v1/validation"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/validation/field"
+	"k8s.io/klog/v2"
 	"k8s.io/kubernetes/pkg/apis/core"
 	corevalidation "k8s.io/kubernetes/pkg/apis/core/validation"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -38,7 +39,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 {
@@ -49,13 +50,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 exist && 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 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)
 	}
 	if !exist {
 		if err := r.Create(r.ctx, desired); err != nil {
@@ -555,13 +556,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,7 @@ import (
 	"fmt"
 
 	"github.com/openshift/cert-manager-operator/api/operator/v1alpha1"
+	"k8s.io/klog/v2"
 )
 
 func (r *Reconciler) reconcileIstioCSRDeployment(istiocsr *v1alpha1.IstioCSR, istioCSRCreateRecon bool) error {
@@ -29,27 +30,27 @@ func (r *Reconciler) reconcileIstioCSRDeployment(istiocsr *v1alpha1.IstioCSR, is
 	}
 
 	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
 	}
 
@@ -59,6 +60,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
 }