Merge pull request #7087 from killianmuldoon/logs/update-type-casing

🌱  Logs/update type casing

Author: k8s-ci-robot

controlplane/kubeadm/internal/controllers/remediation.go

@@ -98,7 +98,7 @@ func (r *KubeadmControlPlaneReconciler) reconcileUnhealthyMachines(ctx context.C
 		if err := patchHelper.Patch(ctx, machineToBeRemediated, patch.WithOwnedConditions{Conditions: []clusterv1.ConditionType{
 			clusterv1.MachineOwnerRemediatedCondition,
 		}}); err != nil {
-			log.Error(err, "Failed to patch control plane Machine", "machine", machineToBeRemediated.Name)
+			log.Error(err, "Failed to patch control plane Machine", "Machine", machineToBeRemediated.Name)
 			if retErr == nil {
 				retErr = errors.Wrapf(err, "failed to patch control plane Machine %s", machineToBeRemediated.Name)
 			}

exp/runtime/internal/controllers/warmup.go

@@ -103,7 +103,7 @@ func warmupRegistry(ctx context.Context, client client.Client, reader client.Rea
 		extensionConfig := &extensionConfigList.Items[i]
 		original := extensionConfig.DeepCopy()
 
-		log := log.WithValues("extensionConfig", klog.KObj(extensionConfig), "name", extensionConfig.Name, "namespace", extensionConfig.Namespace)
+		log := log.WithValues("ExtensionConfig", klog.KObj(extensionConfig))
 		ctx := ctrl.LoggerInto(ctx, log)
 
 		// Inject CABundle from secret if annotation is set. Otherwise https calls may fail.

exp/util/util.go

@@ -24,6 +24,7 @@ import (
 	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/klog/v2"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
@@ -63,23 +64,23 @@ func GetMachinePoolByName(ctx context.Context, c client.Client, namespace, name
 func MachinePoolToInfrastructureMapFunc(gvk schema.GroupVersionKind, log logr.Logger) handler.MapFunc {
 	log = log.WithValues("machine-pool-to-infra-map-func", gvk.String())
 	return func(o client.Object) []reconcile.Request {
-		log := log.WithValues("namespace", o.GetNamespace(), "name", o.GetName())
 		m, ok := o.(*expv1.MachinePool)
 		if !ok {
-			log.V(4).Info("not a machine pool")
+			log.V(4).Info("Not a machine pool", "Object", klog.KObj(o))
 			return nil
 		}
+		log := log.WithValues("MachinePool", klog.KObj(o))
 
 		gk := gvk.GroupKind()
 		ref := m.Spec.Template.Spec.InfrastructureRef
 		// Return early if the GroupKind doesn't match what we expect.
 		infraGK := ref.GroupVersionKind().GroupKind()
 		if gk != infraGK {
-			log.V(4).Info("infra kind doesn't match filter group kind", "infrastructureGroupKind", infraGK.String())
+			log.V(4).Info("Infra kind doesn't match filter group kind", "infrastructureGroupKind", infraGK.String())
 			return nil
 		}
 
-		log.V(4).Info("projecting object", "namespace", m.Namespace, "name", ref.Name)
+		log.V(4).Info("Projecting object")
 		return []reconcile.Request{
 			{
 				NamespacedName: client.ObjectKey{

internal/controllers/cluster/cluster_controller_phases.go

@@ -274,7 +274,7 @@ func (r *Reconciler) reconcileKubeconfig(ctx context.Context, cluster *clusterv1
 	case apierrors.IsNotFound(err):
 		if err := kubeconfig.CreateSecret(ctx, r.Client, cluster); err != nil {
 			if err == kubeconfig.ErrDependentCertificateNotFound {
-				log.Info("could not find secret for cluster, requeuing", "secret", secret.ClusterCA)
+				log.Info("Could not find secret for cluster, requeuing", "Secret", secret.ClusterCA)
 				return ctrl.Result{RequeueAfter: 30 * time.Second}, nil
 			}
 			return ctrl.Result{}, err

internal/controllers/machine/machine_controller_node_labels.go

@@ -21,6 +21,7 @@ import (
 
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/klog/v2"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
@@ -48,7 +49,7 @@ func (r *Reconciler) reconcileInterruptibleNodeLabel(ctx context.Context, cluste
 	// Get interruptible instance status from the infrastructure provider.
 	interruptible, _, err := unstructured.NestedBool(infra.Object, "status", "interruptible")
 	if err != nil {
-		log.V(1).Error(err, "Failed to get interruptible status from infrastructure provider", "machinename", machine.Name)
+		log.V(1).Error(err, "Failed to get interruptible status from infrastructure provider", "Machine", klog.KObj(machine))
 		return ctrl.Result{}, nil
 	}
 	if !interruptible {

internal/controllers/machine/machine_controller_phases.go

@@ -232,7 +232,7 @@ func (r *Reconciler) reconcileBootstrap(ctx context.Context, cluster *clusterv1.
 	}
 	m.Spec.Bootstrap.DataSecretName = pointer.StringPtr(secretName)
 	if !m.Status.BootstrapReady {
-		log.Info("Bootstrap provider generated data secret and reports status.ready", bootstrapConfig.GetKind(), klog.KObj(bootstrapConfig), "secret", klog.KRef(m.Namespace, secretName))
+		log.Info("Bootstrap provider generated data secret and reports status.ready", bootstrapConfig.GetKind(), klog.KObj(bootstrapConfig), "Secret", klog.KRef(m.Namespace, secretName))
 	}
 	m.Status.BootstrapReady = true
 	return ctrl.Result{}, nil

internal/controllers/machinedeployment/machinedeployment_controller.go

@@ -314,7 +314,7 @@ func (r *Reconciler) getMachineDeploymentsForMachineSet(ctx context.Context, ms
 	log := ctrl.LoggerFrom(ctx)
 
 	if len(ms.Labels) == 0 {
-		log.V(2).Info("No MachineDeployments found for MachineSet because it has no labels", "machineset", ms.Name)
+		log.V(2).Info("No MachineDeployments found for MachineSet because it has no labels", "MachineSet", klog.KObj(ms))
 		return nil
 	}
 

internal/controllers/machinedeployment/machinedeployment_sync.go

@@ -29,6 +29,7 @@ import (
 	apirand "k8s.io/apimachinery/pkg/util/rand"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/client-go/util/retry"
+	"k8s.io/klog/v2"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
@@ -236,13 +237,13 @@ func (r *Reconciler) getNewMachineSet(ctx context.Context, d *clusterv1.MachineD
 
 		return nil, err
 	case err != nil:
-		log.Error(err, "Failed to create new machine set", "machineset", newMS.Name)
+		log.Error(err, "Failed to create new MachineSet", "MachineSet", klog.KObj(&newMS))
 		r.recorder.Eventf(d, corev1.EventTypeWarning, "FailedCreate", "Failed to create MachineSet %q: %v", newMS.Name, err)
 		return nil, err
 	}
 
 	if !alreadyExists {
-		log.V(4).Info("Created new machine set", "machineset", createdMS.Name)
+		log.V(4).Info("Created new MachineSet", "MachineSet", klog.KObj(createdMS))
 		r.recorder.Eventf(d, corev1.EventTypeNormal, "SuccessfulCreate", "Created MachineSet %q", newMS.Name)
 	}
 

internal/controllers/machineset/machineset_controller.go

@@ -660,7 +660,7 @@ func (r *Reconciler) updateStatus(ctx context.Context, cluster *clusterv1.Cluste
 	templateLabel := labels.Set(ms.Spec.Template.Labels).AsSelectorPreValidated()
 
 	for _, machine := range filteredMachines {
-		log = log.WithValues("machine", klog.KObj(machine))
+		log = log.WithValues("Machine", klog.KObj(machine))
 
 		if templateLabel.Matches(labels.Set(machine.Labels)) {
 			fullyLabeledReplicasCount++