🌱 reduce log verbosity for queueing operations

config/crds/bootstrap.go

@@ -126,7 +126,7 @@ func CRD(fs embed.FS, gr metav1.GroupResource) (*apiextensionsv1.CustomResourceD
 func CreateSingle(ctx context.Context, client apiextensionsv1client.CustomResourceDefinitionInterface, rawCRD *apiextensionsv1.CustomResourceDefinition) error {
 	logger := klog.FromContext(ctx).WithValues("crd", rawCRD.Name)
 	start := time.Now()
-	logger.V(4).Info("bootstrapping CRD")
+	logger.V(2).Info("bootstrapping CRD")
 
 	updateNeeded := false
 	crd, err := client.Get(ctx, rawCRD.Name, metav1.GetOptions{})

pkg/proxy/index/index_controller.go

@@ -176,7 +176,7 @@ func (c *Controller) processNextWorkItem(ctx context.Context) bool {
 
 	logger := logging.WithQueueKey(klog.FromContext(ctx), key)
 	ctx = klog.NewContext(ctx, logger)
-	logger.V(1).Info("processing key")
+	logger.V(4).Info("processing key")
 
 	// No matter what, tell the queue we're done with this key, to unblock
 	// other workers.
@@ -213,7 +213,7 @@ func (c *Controller) process(ctx context.Context, key string) error {
 	defer c.lock.Unlock()
 
 	if _, found := c.shardWorkspaceInformers[shard.Name]; !found {
-		logger.V(1).Info("Starting informers for Shard")
+		logger.V(2).Info("Starting informers for Shard")
 
 		client, err := c.clientGetter(shard)
 		if err != nil {

pkg/reconciler/apis/apibinding/apibinding_controller.go

@@ -324,7 +324,7 @@ func (c *controller) enqueueAPIBinding(apiBinding *apisv1alpha1.APIBinding, logg
 		return
 	}
 
-	logging.WithQueueKey(logger, key).V(2).Info(fmt.Sprintf("queueing APIBinding%s", logSuffix))
+	logging.WithQueueKey(logger, key).V(4).Info(fmt.Sprintf("queueing APIBinding%s", logSuffix))
 	c.queue.Add(key)
 }
 
@@ -427,7 +427,7 @@ func (c *controller) processNextWorkItem(ctx context.Context) bool {
 
 	logger := logging.WithQueueKey(klog.FromContext(ctx), key)
 	ctx = klog.NewContext(ctx, logger)
-	logger.V(1).Info("processing key")
+	logger.V(4).Info("processing key")
 
 	// No matter what, tell the queue we're done with this key, to unblock
 	// other workers.

pkg/reconciler/apis/apibindingdeletion/apibinding_deletion_controller.go

@@ -133,7 +133,7 @@ func (c *Controller) enqueue(obj interface{}) {
 		return
 	}
 	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), ControllerName), key)
-	logger.V(2).Info("queueing APIBinding")
+	logger.V(4).Info("queueing APIBinding")
 	c.queue.Add(key)
 }
 
@@ -168,7 +168,7 @@ func (c *Controller) processNextWorkItem(ctx context.Context) bool {
 
 	logger := logging.WithQueueKey(klog.FromContext(ctx), key)
 	ctx = klog.NewContext(ctx, logger)
-	logger.V(1).Info("processing key")
+	logger.V(4).Info("processing key")
 
 	// No matter what, tell the queue we're done with this key, to unblock
 	// other workers.
@@ -186,7 +186,7 @@ func (c *Controller) processNextWorkItem(ctx context.Context) bool {
 	if errors.As(err, &estimate) {
 		t := estimate.Estimate/2 + 1
 		duration := time.Duration(t) * time.Second
-		logger.V(2).Info("custom resources remaining for APIBinding, waiting", "duration", duration)
+		logger.V(3).Info("custom resources remaining for APIBinding, waiting", "duration", duration)
 		c.queue.AddAfter(key, duration)
 	} else {
 		// rather than wait for a full resync, re-add the workspace to the queue to be processed

pkg/reconciler/apis/apiexport/apiexport_controller.go

@@ -229,7 +229,7 @@ func (c *controller) enqueueAllAPIExports(shard *corev1alpha1.Shard) {
 			continue
 		}
 
-		logging.WithQueueKey(logger, key).V(2).Info("queuing APIExport because Shard changed")
+		logging.WithQueueKey(logger, key).V(3).Info("queuing APIExport because Shard changed")
 		c.queue.Add(key)
 	}
 }
@@ -248,7 +248,7 @@ func (c *controller) enqueueSecret(secret *corev1.Secret) {
 			runtime.HandleError(err)
 			return
 		}
-		logging.WithQueueKey(logger, key).V(2).Info("queueing APIExport via identity Secret")
+		logging.WithQueueKey(logger, key).V(3).Info("queueing APIExport via identity Secret")
 		c.queue.Add(key)
 	}
 }

pkg/reconciler/apis/crdcleanup/crdcleanup_controller.go

@@ -153,7 +153,7 @@ func (c *controller) enqueueFromAPIBinding(oldBinding, newBinding *apisv1alpha1.
 
 	for uid := range uidSet {
 		key := kcpcache.ToClusterAwareKey(apibinding.SystemBoundCRDsClusterName.String(), "", uid)
-		logging.WithQueueKey(logger, key).V(2).Info("queueing CRD via APIBinding")
+		logging.WithQueueKey(logger, key).V(3).Info("queueing CRD via APIBinding")
 		c.queue.Add(key)
 	}
 }
@@ -242,7 +242,7 @@ func (c *controller) process(ctx context.Context, key string) error {
 		return nil
 	}
 
-	logger.V(1).Info("Deleting CRD")
+	logger.V(2).Info("Deleting CRD")
 	if err := c.deleteCRD(ctx, obj.Name); err != nil {
 		if errors.IsNotFound(err) {
 			return nil // object deleted before we handled it

pkg/reconciler/apis/extraannotationsync/apibindingannotation_controller.go

@@ -149,7 +149,7 @@ func (c *controller) enqueueAPIBinding(obj interface{}, logger logr.Logger, logS
 		return
 	}
 
-	logging.WithQueueKey(logger, key).V(2).Info(fmt.Sprintf("queueing APIBinding%s", logSuffix))
+	logging.WithQueueKey(logger, key).V(4).Info(fmt.Sprintf("queueing APIBinding%s", logSuffix))
 	c.queue.Add(key)
 }
 
@@ -209,7 +209,7 @@ func (c *controller) processNextWorkItem(ctx context.Context) bool {
 
 	logger := logging.WithQueueKey(klog.FromContext(ctx), key)
 	ctx = klog.NewContext(ctx, logger)
-	logger.V(1).Info("processing key")
+	logger.V(4).Info("processing key")
 
 	// No matter what, tell the queue we're done with this key, to unblock
 	// other workers.
@@ -265,7 +265,7 @@ func (c *controller) process(ctx context.Context, key string) error {
 		return nil
 	}
 
-	logger.V(1).Info("patching APIBinding extra annotations", "patch", string(patchBytes))
+	logger.V(2).Info("patching APIBinding extra annotations", "patch", string(patchBytes))
 	_, err = c.kcpClusterClient.Cluster(clusterName.Path()).ApisV1alpha1().APIBindings().Patch(ctx, name, types.MergePatchType, patchBytes, metav1.PatchOptions{})
 	return err
 }

pkg/reconciler/apis/permissionclaimlabel/permissionclaimlabel_controller.go

@@ -125,7 +125,7 @@ func (c *controller) enqueueAPIBinding(obj interface{}, logger logr.Logger) {
 		return
 	}
 
-	logging.WithQueueKey(logger, key).V(2).Info("queueing APIBinding")
+	logging.WithQueueKey(logger, key).V(4).Info("queueing APIBinding")
 	c.queue.Add(key)
 }
 
@@ -161,7 +161,7 @@ func (c *controller) processNextWorkItem(ctx context.Context) bool {
 
 	logger := logging.WithQueueKey(klog.FromContext(ctx), key)
 	ctx = klog.NewContext(ctx, logger)
-	logger.V(1).Info("processing key")
+	logger.V(4).Info("processing key")
 
 	// No matter what, tell the queue we're done with this key, to unblock
 	// other workers.

pkg/reconciler/apis/permissionclaimlabel/permissionclaimlabel_resource_controller.go

@@ -102,7 +102,7 @@ func (c *resourceController) enqueueForResource(logger logr.Logger, gvr schema.G
 	}
 
 	queueKey += "::" + key
-	logging.WithQueueKey(logger, queueKey).V(2).Info("queuing resource")
+	logging.WithQueueKey(logger, queueKey).V(4).Info("queuing resource")
 	c.queue.Add(queueKey)
 }
 
@@ -138,7 +138,7 @@ func (c *resourceController) processNextWorkItem(ctx context.Context) bool {
 
 	logger := logging.WithQueueKey(klog.FromContext(ctx), key)
 	ctx = klog.NewContext(ctx, logger)
-	logger.V(1).Info("processing key")
+	logger.V(4).Info("processing key")
 
 	// No matter what, tell the queue we're done with this key, to unblock
 	// other workers.

pkg/reconciler/apis/permissionclaimlabel/permissionclaimlabel_resource_reconcile.go

@@ -83,7 +83,7 @@ func (c *resourceController) reconcile(ctx context.Context, obj *unstructured.Un
 
 	if err != nil {
 		if apierrors.IsNotFound(err) {
-			logger.V(2).Info("got a not found error when trying to patch")
+			logger.V(3).Info("got a not found error when trying to patch")
 			return nil
 		}
 

pkg/reconciler/cache/labelclusterrolebindings/labelclusterrolebinding_reconcile.go

@@ -82,7 +82,7 @@ func (r *reconciler) reconcile(ctx context.Context, crb *rbacv1.ClusterRoleBindi
 	} else {
 		var changed bool
 		if crb.Annotations, changed = kcpcorehelper.DontReplicateFor(crb.Annotations, r.groupName); changed {
-			logger.V(2).Info("Not replicating ClusterRoleBinding")
+			logger.V(3).Info("Not replicating ClusterRoleBinding")
 		}
 	}
 

pkg/reconciler/cache/labelclusterroles/labelclusterrole_reconcile.go

@@ -79,7 +79,7 @@ func (r *reconciler) reconcile(ctx context.Context, cr *rbacv1.ClusterRole) (boo
 	} else {
 		var changed bool
 		if cr.Annotations, changed = kcpcorehelper.DontReplicateFor(cr.Annotations, r.groupName); changed {
-			logger.V(2).Info("Not replicating ClusterRole")
+			logger.V(3).Info("Not replicating ClusterRole")
 		}
 	}
 

pkg/reconciler/cache/labellogicalcluster/labellogicalcluster_reconcile.go

@@ -50,7 +50,7 @@ func (r *reconciler) reconcile(ctx context.Context, cluster *corev1alpha1.Logica
 	} else {
 		var changed bool
 		if cluster.Annotations, changed = kcpcorehelper.DontReplicateFor(cluster.Annotations, r.groupName); changed {
-			logger.V(2).Info("Not replicating LogicalCluster")
+			logger.V(3).Info("Not replicating LogicalCluster")
 		}
 	}
 

pkg/reconciler/core/logicalcluster/logicalcluster_controller.go

@@ -93,7 +93,7 @@ func (c *Controller) enqueue(obj interface{}) {
 		return
 	}
 	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), ControllerName), key)
-	logger.V(2).Info("queueing LogicalCluster")
+	logger.V(4).Info("queueing LogicalCluster")
 	c.queue.Add(key)
 }
 
@@ -128,7 +128,7 @@ func (c *Controller) processNextWorkItem(ctx context.Context) bool {
 
 	logger := logging.WithQueueKey(klog.FromContext(ctx), key)
 	ctx = klog.NewContext(ctx, logger)
-	logger.V(1).Info("processing key")
+	logger.V(4).Info("processing key")
 
 	// No matter what, tell the queue we're done with this key, to unblock
 	// other workers.

pkg/reconciler/core/logicalclusterdeletion/logicalcluster_deletion_controller.go

@@ -237,7 +237,7 @@ func (c *Controller) process(ctx context.Context, key string) error {
 	}
 	logicalCluster, deleteErr := c.logicalClusterLister.Cluster(clusterName).Get(name)
 	if apierrors.IsNotFound(deleteErr) {
-		logger.V(2).Info("Workspace has been deleted")
+		logger.V(3).Info("Workspace has been deleted")
 		return nil
 	}
 	if deleteErr != nil {
@@ -258,7 +258,7 @@ func (c *Controller) process(ctx context.Context, key string) error {
 	startTime := time.Now()
 	deleteErr = c.deleter.Delete(ctx, logicalClusterCopy)
 	if deleteErr == nil {
-		logger.V(2).Info("finished deleting logical cluster content", "duration", time.Since(startTime))
+		logger.V(4).Info("finished deleting logical cluster content", "duration", time.Since(startTime))
 		return c.finalizeWorkspace(ctx, logicalClusterCopy)
 	}
 

pkg/reconciler/core/shard/shard_controller.go

@@ -92,7 +92,7 @@ func (c *Controller) enqueue(obj interface{}) {
 		return
 	}
 	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), ControllerName), key)
-	logger.V(2).Info("queueing Shard")
+	logger.V(4).Info("queueing Shard")
 	c.queue.Add(key)
 }
 
@@ -127,7 +127,7 @@ func (c *Controller) processNextWorkItem(ctx context.Context) bool {
 
 	logger := logging.WithQueueKey(klog.FromContext(ctx), key)
 	ctx = klog.NewContext(ctx, logger)
-	logger.V(1).Info("processing key")
+	logger.V(4).Info("processing key")
 
 	// No matter what, tell the queue we're done with this key, to unblock
 	// other workers.

pkg/reconciler/garbagecollector/garbagecollector_controller.go

@@ -126,7 +126,7 @@ func (c *Controller) enqueue(obj interface{}) {
 	}
 
 	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), ControllerName), key)
-	logger.V(2).Info("queueing LogicalCluster")
+	logger.V(4).Info("queueing LogicalCluster")
 	c.queue.Add(key)
 }
 
@@ -164,7 +164,7 @@ func (c *Controller) processNextWorkItem(ctx context.Context) bool {
 
 	logger := logging.WithQueueKey(klog.FromContext(ctx), key)
 	ctx = klog.NewContext(ctx, logger)
-	logger.V(1).Info("processing key")
+	logger.V(4).Info("processing key")
 
 	// No matter what, tell the queue we're done with this key, to unblock
 	// other workers.

pkg/reconciler/kubequota/kubequota_controller.go

@@ -134,7 +134,7 @@ func (c *Controller) enqueue(obj interface{}) {
 	}
 
 	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), ControllerName), key)
-	logger.V(2).Info("queueing Workspace")
+	logger.V(4).Info("queueing Workspace")
 	c.queue.Add(key)
 }
 
@@ -172,7 +172,7 @@ func (c *Controller) processNextWorkItem(ctx context.Context) bool {
 
 	logger := logging.WithQueueKey(klog.FromContext(ctx), key)
 	ctx = klog.NewContext(ctx, logger)
-	logger.V(1).Info("processing key")
+	logger.V(4).Info("processing key")
 
 	// No matter what, tell the queue we're done with this key, to unblock
 	// other workers.

pkg/reconciler/tenancy/bootstrap/bootstrap_controller.go

@@ -114,7 +114,7 @@ func (c *controller) enqueue(obj interface{}) {
 		return
 	}
 	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), c.controllerName), key)
-	logger.V(2).Info("queueing LogicalCluster")
+	logger.V(4).Info("queueing LogicalCluster")
 	c.queue.Add(key)
 }
 
@@ -154,7 +154,7 @@ func (c *controller) processNextWorkItem(ctx context.Context) bool {
 
 	logger := logging.WithQueueKey(klog.FromContext(ctx), key)
 	ctx = klog.NewContext(ctx, logger)
-	logger.V(1).Info("processing key")
+	logger.V(4).Info("processing key")
 
 	if err := c.process(ctx, key); err != nil {
 		runtime.HandleError(fmt.Errorf("%q controller failed to sync %q, err: %w", c.controllerName, key, err))

pkg/reconciler/tenancy/initialization/apibinder_initializer_controller.go

@@ -177,7 +177,7 @@ func (b *APIBinder) enqueueLogicalCluster(obj interface{}, logger logr.Logger) {
 		return
 	}
 
-	logging.WithQueueKey(logger, key).V(2).Info("queueing LogicalCluster")
+	logging.WithQueueKey(logger, key).V(4).Info("queueing LogicalCluster")
 	b.queue.Add(key)
 }
 
@@ -265,7 +265,7 @@ func (b *APIBinder) processNextWorkItem(ctx context.Context) bool {
 
 	logger := logging.WithQueueKey(klog.FromContext(ctx), key)
 	ctx = klog.NewContext(ctx, logger)
-	logger.V(1).Info("processing key")
+	logger.V(4).Info("processing key")
 
 	// No matter what, tell the queue we're done with this key, to unblock
 	// other workers.

pkg/reconciler/tenancy/initialization/apibinder_initializer_reconcile.go

@@ -57,7 +57,7 @@ func (b *APIBinder) reconcile(ctx context.Context, logicalCluster *corev1alpha1.
 
 	var errors []error
 	clusterName := logicalcluster.From(logicalCluster)
-	logger.V(2).Info("initializing APIBindings for workspace")
+	logger.V(3).Info("initializing APIBindings for workspace")
 
 	// Start with the WorkspaceType specified by the Workspace
 	leafWT, err := b.getWorkspaceType(wtCluster, wtName)
@@ -119,7 +119,7 @@ func (b *APIBinder) reconcile(ctx context.Context, logicalCluster *corev1alpha1.
 
 	for _, wt := range wts {
 		logger := logging.WithObject(logger, wt)
-		logger.V(2).Info("attempting to initialize APIBindings")
+		logger.V(3).Info("attempting to initialize APIBindings")
 
 		for i := range wt.Spec.DefaultAPIBindings {
 			exportRef := wt.Spec.DefaultAPIBindings[i]

pkg/reconciler/tenancy/logicalcluster/logicalcluster_controller.go

@@ -109,7 +109,7 @@ func (c *Controller) enqueue(obj interface{}) {
 		return
 	}
 	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), ControllerName), key)
-	logger.V(2).Info("queueing LogicalCluster")
+	logger.V(4).Info("queueing LogicalCluster")
 	c.queue.Add(key)
 }
 
@@ -120,7 +120,7 @@ func (c *Controller) enqueueCRB(obj interface{}) {
 		return
 	}
 	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), ControllerName), key)
-	logger.V(2).Info("queueing LogicalCluster")
+	logger.V(4).Info("queueing LogicalCluster")
 	c.queue.Add(key)
 }
 
@@ -155,7 +155,7 @@ func (c *Controller) processNextWorkItem(ctx context.Context) bool {
 
 	logger := logging.WithQueueKey(klog.FromContext(ctx), key)
 	ctx = klog.NewContext(ctx, logger)
-	logger.V(1).Info("processing key")
+	logger.V(4).Info("processing key")
 
 	// No matter what, tell the queue we're done with this key, to unblock
 	// other workers.