Skip to content

Commit ed3350c

Browse files
nikhilbargenikhilbarge
authored
Update logger for VirtualMachineSnapshot (#3503)
1 parent 1539c08 commit ed3350c

File tree

2 files changed

+73
-77
lines changed

2 files changed

+73
-77
lines changed

‎pkg/syncer/cnsoperator/controller/add_virtualmachinesnapshot.go

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
Copyright 2021 The Kubernetes Authors.
2+
Copyright 2025 The Kubernetes Authors.
33
44
Licensed under the Apache License, Version 2.0 (the "License");
55
you may not use this file except in compliance with the License.

‎pkg/syncer/cnsoperator/controller/virtualmachinesnapshot/virtualmachinesnapshot_controller.go

Lines changed: 72 additions & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
Copyright 2019 The Kubernetes Authors.
2+
Copyright 2025 The Kubernetes Authors.
33
44
Licensed under the Apache License, Version 2.0 (the "License");
55
you may not use this file except in compliance with the License.
@@ -26,10 +26,9 @@ import (
2626
"sync"
2727
"time"
2828

29-
"github.com/go-logr/logr"
30-
"github.com/google/uuid"
3129
vmoperatorv1alpha4 "github.com/vmware-tanzu/vm-operator/api/v1alpha4"
3230
cnstypes "github.com/vmware/govmomi/cns/types"
31+
"go.uber.org/zap"
3332
corev1 "k8s.io/api/core/v1"
3433

3534
apierrors "k8s.io/apimachinery/pkg/api/errors"
@@ -38,7 +37,6 @@ import (
3837
"k8s.io/client-go/kubernetes/scheme"
3938
typedcorev1 "k8s.io/client-go/kubernetes/typed/core/v1"
4039
"k8s.io/client-go/tools/record"
41-
ctrl "sigs.k8s.io/controller-runtime"
4240
"sigs.k8s.io/controller-runtime/pkg/client"
4341
"sigs.k8s.io/controller-runtime/pkg/controller"
4442
"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
@@ -90,7 +88,7 @@ func Add(mgr manager.Manager, clusterFlavor cnstypes.CnsClusterFlavor,
9088
coCommonInterface, err = commonco.GetContainerOrchestratorInterface(ctx,
9189
common.Kubernetes, clusterFlavor, &syncer.COInitParams)
9290
if err != nil {
93-
log.Errorf("failed to create CO agnostic interface. Er r: %v", err)
91+
log.Errorf("failed to create CO agnostic interface. error: %v", err)
9492
return err
9593
}
9694
var err error
@@ -102,7 +100,7 @@ func Add(mgr manager.Manager, clusterFlavor cnstypes.CnsClusterFlavor,
102100
log.Info("Creating CnsVolumeInfo Service to persist mapping for VolumeID to storage policy info")
103101
volumeInfoService, err = cnsvolumeinfo.InitVolumeInfoService(ctx)
104102
if err != nil {
105-
return logger.LogNewErrorf(log, "error initializing volumeInfoService. Error: %+v", err)
103+
return logger.LogNewErrorf(log, "error initializing volumeInfoService. error: %+v", err)
106104
}
107105
log.Info("Successfully initialized VolumeInfoService")
108106
} else {
@@ -112,18 +110,18 @@ func Add(mgr manager.Manager, clusterFlavor cnstypes.CnsClusterFlavor,
112110
// Initializes kubernetes client.
113111
k8sclient, err := k8s.NewClient(ctx)
114112
if err != nil {
115-
log.Errorf("Creating Kubernetes client failed. Err: %v", err)
113+
log.Errorf("Creating Kubernetes client failed. error: %v", err)
116114
return err
117115
}
118116
restClientConfig, err := k8s.GetKubeConfig(ctx)
119117
if err != nil {
120-
msg := fmt.Sprintf("Failed to initialize rest clientconfig. Error: %+v", err)
118+
msg := fmt.Sprintf("Failed to initialize rest clientconfig. error: %+v", err)
121119
log.Error(msg)
122120
return err
123121
}
124122
vmOperatorClient, err := k8s.NewClientForGroup(ctx, restClientConfig, vmoperatorv1alpha4.GroupName)
125123
if err != nil {
126-
msg := fmt.Sprintf("Failed to initialize vmOperatorClient. Error: %+v", err)
124+
msg := fmt.Sprintf("Failed to initialize vmOperatorClient. error: %+v", err)
127125
log.Error(msg)
128126
return err
129127
}
@@ -136,16 +134,15 @@ func Add(mgr manager.Manager, clusterFlavor cnstypes.CnsClusterFlavor,
136134
Interface: k8sclient.CoreV1().Events(""),
137135
},
138136
)
139-
logger := ctrl.Log.WithName("controllers").WithName("VirtualMachineSnapshot")
140137
recorder := eventBroadcaster.NewRecorder(scheme.Scheme, corev1.EventSource{Component: apis.GroupName})
141138
return add(mgr, newReconciler(mgr, configInfo, volumeManager,
142-
recorder, vmOperatorClient, volumeInfoService, logger))
139+
recorder, vmOperatorClient, volumeInfoService))
143140
}
144141

145142
// newReconciler returns a new reconcile.Reconciler.
146143
func newReconciler(mgr manager.Manager, configInfo *commonconfig.ConfigurationInfo,
147144
volumeManager volumes.Manager, recorder record.EventRecorder, vmOperatorClient client.Client,
148-
volumeInfoService cnsvolumeinfo.VolumeInfoService, logger logr.Logger) reconcile.Reconciler {
145+
volumeInfoService cnsvolumeinfo.VolumeInfoService) reconcile.Reconciler {
149146
return &ReconcileVirtualMachineSnapshot{
150147
client: mgr.GetClient(),
151148
scheme: mgr.GetScheme(),
@@ -154,7 +151,6 @@ func newReconciler(mgr manager.Manager, configInfo *commonconfig.ConfigurationIn
154151
recorder: recorder,
155152
vmOperatorClient: vmOperatorClient,
156153
volumeInfoService: volumeInfoService,
157-
Logger: logger,
158154
}
159155
}
160156

@@ -196,7 +192,6 @@ type ReconcileVirtualMachineSnapshot struct {
196192
recorder record.EventRecorder
197193
volumeInfoService cnsvolumeinfo.VolumeInfoService
198194
vmOperatorClient client.Client
199-
Logger logr.Logger
200195
}
201196

202197
// Reconcile reads that state of the cluster for a VirtualMachineSnapshot object and
@@ -207,24 +202,24 @@ type ReconcileVirtualMachineSnapshot struct {
207202
// will remove the work from the queue.
208203
func (r *ReconcileVirtualMachineSnapshot) Reconcile(ctx context.Context,
209204
request reconcile.Request) (reconcile.Result, error) {
210-
traceId := uuid.NewString()
211-
logger := r.Logger.WithValues("name", request.NamespacedName, "trace", traceId)
205+
_, log := logger.GetNewContextWithLogger()
212206
now := time.Now()
213-
logger.Info("Reconcile Started")
207+
log.Infof("Reconcile Started for VirtualMachineSnapshot %s/%s", request.Namespace, request.Name)
214208
defer func() {
215-
logger.Info("Reconcile Completed", "Time Taken", time.Since(now))
209+
log.Infof("Reconcile Completed for virtualmachinesnapshot %s/%s Time Taken %v",
210+
request.Namespace, request.Name, time.Since(now))
216211
}()
217212
// Fetch the VirtualMachineSnapshot instance.
218213
vmSnapshot := &vmoperatorv1alpha4.VirtualMachineSnapshot{}
219214
err := r.client.Get(ctx, request.NamespacedName, vmSnapshot)
220215
if err != nil {
221216
if apierrors.IsNotFound(err) {
222-
logger.Info("resource not found. Ignoring since object must be deleted",
223-
"VMSnapshotName", request.Name, "VMSnapshotNamespace", request.Namespace)
217+
log.Infof("resource not found. Ignoring since object must be deleted for vmsnapshot %s/%s",
218+
request.Namespace, request.Name)
224219
return reconcile.Result{}, nil
225220
}
226-
logger.Error(err, "error while fetch the VirtualMachineSnapshot",
227-
"VMSnapshotName", request.Name, "VMSnapshotNamespace", request.Namespace)
221+
log.Errorf("error while fetch the virtualmachinesnapshot %s/%s. error: %v",
222+
request.Namespace, request.Name, err)
228223
// Error reading the object - return with err.
229224
return reconcile.Result{}, err
230225
}
@@ -238,9 +233,9 @@ func (r *ReconcileVirtualMachineSnapshot) Reconcile(ctx context.Context,
238233
timeout = backOffDuration[request.NamespacedName]
239234
backOffDurationMapMutex.Unlock()
240235

241-
logger.Info("Reconciling virtualmachinesnapshot",
242-
"VMSnapshotName", request.Name, "VMSnapshotNamespace", request.Namespace)
243-
err = r.reconcileNormal(ctx, logger, vmSnapshot)
236+
log.Infof("Reconciling virtualmachinesnapshot %s/%s",
237+
request.Namespace, request.Name)
238+
err = r.reconcileNormal(ctx, log, vmSnapshot)
244239
if err != nil {
245240
return reconcile.Result{RequeueAfter: timeout}, err
246241
}
@@ -249,19 +244,19 @@ func (r *ReconcileVirtualMachineSnapshot) Reconcile(ctx context.Context,
249244
backOffDurationMapMutex.Unlock()
250245
return reconcile.Result{}, nil
251246
}
252-
func (r *ReconcileVirtualMachineSnapshot) reconcileNormal(ctx context.Context, logger logr.Logger,
247+
func (r *ReconcileVirtualMachineSnapshot) reconcileNormal(ctx context.Context, log *zap.SugaredLogger,
253248
vmsnapshot *vmoperatorv1alpha4.VirtualMachineSnapshot) error {
254249
deleteVMSnapshot := false
255250
if vmsnapshot.DeletionTimestamp.IsZero() {
256251
// If the finalizer is not present, add it.
257-
logger.Info("reconcileNormal: Adding finalizer on virtualmachinesnapshot cr", "VMSnapshotName", vmsnapshot.Name,
258-
"VMSnapshotNamespace", vmsnapshot.Namespace, "Finalizer", SyncVolumeFinalizer)
252+
log.Infof("reconcileNormal: Adding finalizer %s on virtualmachinesnapshot cr %s/%s",
253+
SyncVolumeFinalizer, vmsnapshot.Namespace, vmsnapshot.Name)
259254
vmSnapshotPatch := client.MergeFrom(vmsnapshot.DeepCopy())
260255
if controllerutil.AddFinalizer(vmsnapshot, SyncVolumeFinalizer) {
261256
err := r.client.Patch(ctx, vmsnapshot, vmSnapshotPatch)
262257
if err != nil {
263-
logger.Error(err, "reconcileNormal: error while add finalizer to virtualmachinesnapshot CR",
264-
"VMSnapshotName", vmsnapshot.Name, "VMSnapshotNamespace", vmsnapshot.Name)
258+
log.Errorf("reconcileNormal: error while add finalizer to "+
259+
"virtualmachinesnapshot %s/%s. error: %v", vmsnapshot.Name, vmsnapshot.Name, err)
265260
return err
266261
}
267262
return nil
@@ -270,13 +265,13 @@ func (r *ReconcileVirtualMachineSnapshot) reconcileNormal(ctx context.Context, l
270265
if !vmsnapshot.DeletionTimestamp.IsZero() &&
271266
controllerutil.ContainsFinalizer(vmsnapshot, SyncVolumeFinalizer) {
272267
if !controllerutil.ContainsFinalizer(vmsnapshot, VMSnapshotFinalizer) {
273-
logger.Info("reconcileNormal: virtualmachinesnapshot is set to delete",
274-
"VMSnapshotName", vmsnapshot.Name, "VMSnapshotNamespace", vmsnapshot.Namespace)
268+
log.Infof("reconcileNormal: virtualmachinesnapshot %s/%s is set to delete",
269+
vmsnapshot.Namespace, vmsnapshot.Name)
275270
deleteVMSnapshot = true
276271
} else {
277-
logger.Info("reconcileNormal: virtualmachinesnapshot is set to delete, "+
278-
"expecting to remove VMSnapshotFinalizer first", "VMSnapshotName", vmsnapshot.Name,
279-
"VMSnapshotNamespace", vmsnapshot.Namespace)
272+
log.Infof("reconcileNormal: virtualmachinesnapshot %s/%s is set to delete, "+
273+
"expecting to remove %s first", vmsnapshot.Namespace, vmsnapshot.Name,
274+
VMSnapshotFinalizer)
280275
return nil
281276
}
282277
}
@@ -290,52 +285,52 @@ func (r *ReconcileVirtualMachineSnapshot) reconcileNormal(ctx context.Context, l
290285
Namespace: vmsnapshot.Namespace,
291286
Name: vmsnapshot.Spec.VMRef.Name,
292287
}
293-
logger.Info("reconcileNormal: get virtulal machine", "VirtualMachineName", vmKey.Name,
294-
"VirtualMachineNamespace", vmKey.Namespace)
288+
log.Infof("reconcileNormal: get virtulal machine %s/%s", vmKey.Namespace, vmKey.Name)
295289
virtualMachine, _, err := utils.GetVirtualMachineAllApiVersions(ctx, vmKey,
296290
r.vmOperatorClient)
297291
if err != nil {
298-
logger.Error(err, "could not get VirtualMachine", "VirtualMachineName", vmKey.Name,
299-
"VirtualMachineNamespace", vmKey.Namespace)
292+
log.Errorf("reconcileNormal: could not get VirtualMachine %s/%s. error: %v",
293+
vmKey.Namespace, vmKey.Name, err)
300294
return err
301295
}
302-
logger.Info("reconcileNormal: sync and update storage quota for vmsnapshot",
303-
"VMSnapshotName", vmsnapshot.Name, "VMSnapshotNamespace", vmsnapshot.Namespace)
304-
err = r.syncVolumesAndUpdateCNSVolumeInfo(ctx, logger, virtualMachine)
296+
log.Infof("reconcileNormal: sync and update storage quota for vmsnapshot %s/%s",
297+
vmsnapshot.Namespace, vmsnapshot.Name)
298+
err = r.syncVolumesAndUpdateCNSVolumeInfo(ctx, log, virtualMachine)
305299
if err != nil {
306-
logger.Error(err, "Failed to validate VirtualMachineSnapshot", "VMSnapshotName", vmsnapshot.Name,
307-
"VMSnapshotNamespace", vmsnapshot.Namespace)
300+
log.Errorf("reconcileNormal: failed to validate VirtualMachineSnapshot %s/%s. error: %v",
301+
vmsnapshot.Namespace, vmsnapshot.Name, err)
308302
return err
309303
}
310-
logger.Info("reconcileNormal: successfully synced and updated storage quota for vmsnapshot",
311-
"VMSnapshotName", vmsnapshot.Name, "VMSnapshotNamespace", vmsnapshot.Namespace)
304+
log.Infof("reconcileNormal: successfully synced and updated storage quota for vmsnapshot %s/%s",
305+
vmsnapshot.Namespace, vmsnapshot.Name)
312306
if deleteVMSnapshot {
313-
logger.Info("deleting virtualmachinesnapshot", "VMSnapshotName", vmsnapshot.Name,
314-
"VMSnapshotNamespace", vmsnapshot.Namespace, "SyncVolumeFinalizer", SyncVolumeFinalizer)
307+
log.Infof("reconcileNormal: remove finalizer %s for virtualmachinesnapshot %s/%s",
308+
SyncVolumeFinalizer, vmsnapshot.Namespace, vmsnapshot.Name)
315309
vmSnapshotPatch := client.MergeFrom(vmsnapshot.DeepCopy())
316310
if controllerutil.RemoveFinalizer(vmsnapshot, SyncVolumeFinalizer) {
317311
err = r.client.Patch(ctx, vmsnapshot, vmSnapshotPatch)
318312
if err != nil {
319-
logger.Error(err, "failed to remove finalizer for VirtualMachineSnapshot CR",
320-
"VMSnapshotName", vmsnapshot.Name, "VMSnapshotNamespace", vmsnapshot.Namespace)
313+
log.Errorf("reconcileNormal: failed to remove finalizer for "+
314+
"virtualmachinesnapshot %s/%s. error: %v", vmsnapshot.Namespace,
315+
vmsnapshot.Name, err)
321316
return err
322317
}
323318
return nil
324319
}
325320
}
326321
// Update VMSnapshot CR annotation to "csi.vsphere.volume.sync: completed"
327-
logger.Info("reconcileNormal: update vmsnapshot annotation value to completed",
328-
"VMSnapshotName", vmsnapshot.Name, "VMSnapshotNamespace", vmsnapshot.Namespace)
322+
log.Infof("reconcileNormal: update annotation value for vmsnapshot %s/%s to 'completed'",
323+
vmsnapshot.Namespace, vmsnapshot.Name)
329324
vmSnapshotPatch := client.MergeFrom(vmsnapshot.DeepCopy())
330325
vmsnapshot.Annotations["csi.vsphere.volume.sync"] = "completed"
331326
err = r.client.Patch(ctx, vmsnapshot, vmSnapshotPatch)
332327
if err != nil {
333-
logger.Error(err, "could not update VirtualMachineSnapshot CR",
334-
"VMSnapshotName", vmsnapshot.Name, "VMSnapshotNamespace", vmsnapshot.Namespace)
328+
log.Errorf("reconcileNormal: could not update virtualmachinesnapshot %s/%s. error: %v",
329+
vmsnapshot.Namespace, vmsnapshot.Name, err)
335330
return err
336331
}
337-
logger.Info("reconcileNormal: successfully updated vmsnapshot",
338-
"VMSnapshotName", vmsnapshot.Name, "VMSnapshotNamespace", vmsnapshot.Namespace)
332+
log.Infof("reconcileNormal: successfully updated vmsnapshot %s/%s",
333+
vmsnapshot.Namespace, vmsnapshot.Name)
339334
}
340335
return nil
341336
}
@@ -377,7 +372,7 @@ func getMaxWorkerThreadsToReconcileVirtualMachineSnapshot(ctx context.Context) i
377372
// after volume sync is successful it will fetch the aggregated size of all related volumes
378373
// will update the relevant CNSVolumeInfo for each volume which will update the storage policy usage.
379374
func (r *ReconcileVirtualMachineSnapshot) syncVolumesAndUpdateCNSVolumeInfo(ctx context.Context,
380-
logger logr.Logger, vm *vmoperatorv1alpha4.VirtualMachine) error {
375+
log *zap.SugaredLogger, vm *vmoperatorv1alpha4.VirtualMachine) error {
381376
var err error
382377
cnsVolumeIds := []cnstypes.CnsVolumeId{}
383378
syncMode := []string{string(cnstypes.CnsSyncVolumeModeSPACE_USAGE)}
@@ -389,8 +384,8 @@ func (r *ReconcileVirtualMachineSnapshot) syncVolumesAndUpdateCNSVolumeInfo(ctx
389384
pvc := &corev1.PersistentVolumeClaim{}
390385
err = r.client.Get(ctx, pvcKey, pvc, &client.GetOptions{})
391386
if err != nil {
392-
logger.Error(err, "syncVolumesAndUpdateCNSVolumeInfo: error get pvc",
393-
"PVCName", vmVolume.Name, "PVCNamespace", vm.Namespace)
387+
log.Errorf("syncVolumesAndUpdateCNSVolumeInfo: failed get pvc %s/%s. error: %v",
388+
vm.Namespace, vmVolume.Name, err)
394389
return err
395390
}
396391
if pvc.Spec.VolumeName != "" {
@@ -400,8 +395,8 @@ func (r *ReconcileVirtualMachineSnapshot) syncVolumesAndUpdateCNSVolumeInfo(ctx
400395
pv := &corev1.PersistentVolume{}
401396
err = r.client.Get(ctx, pvKey, pv, &client.GetOptions{})
402397
if err != nil {
403-
logger.Error(err, "syncVolumesAndUpdateCNSVolumeInfo: could not get the volume for pvc",
404-
"PVCName", pvc.Name, "PVCNamespace", vm.Namespace)
398+
log.Errorf("syncVolumesAndUpdateCNSVolumeInfo: could not get the volume "+
399+
"for pvc %s/%s error: %v", pvc.Namespace, vm.Name, err)
405400
return err
406401
}
407402
if pv.Spec.CSI != nil && pv.Spec.CSI.VolumeHandle != "" {
@@ -414,19 +409,19 @@ func (r *ReconcileVirtualMachineSnapshot) syncVolumesAndUpdateCNSVolumeInfo(ctx
414409
},
415410
}
416411
// Trigger CNS VolumeSync API for identified volume-lds and Fetch Latest Aggregated snapshot size
417-
logger.Info("syncVolumesAndUpdateCNSVolumeInfo: Trigger CNS VolumeSync API for volume",
418-
"VolumeId", cnsVolId)
412+
log.Infof("syncVolumesAndUpdateCNSVolumeInfo: Trigger CNS VolumeSync API for volume %s",
413+
cnsVolId)
419414
syncVolumeFaultType, err := r.volumeManager.SyncVolume(ctx, syncVolumeSpecs)
420415
if err != nil {
421-
logger.Error(err, "syncVolumesAndUpdateCNSVolumeInfo: error while sync volume",
422-
"cnsfault", syncVolumeFaultType, "VolumeId", cnsVolId)
416+
log.Errorf("syncVolumesAndUpdateCNSVolumeInfo: error while sync volume %s "+
417+
"cnsfault %s. error: %v", cnsVolId, syncVolumeFaultType, err)
423418
return err
424419
}
425420
}
426421
} else {
427422
err = fmt.Errorf("could not find the PV associated with PVC %s/%s",
428423
vm.Namespace, vmVolume.Name)
429-
logger.Error(err, "syncVolumesAndUpdateCNSVolumeInfo: pv not found")
424+
log.Errorf("syncVolumesAndUpdateCNSVolumeInfo: pv not found error: %v", err)
430425
return err
431426
}
432427
}
@@ -436,40 +431,41 @@ func (r *ReconcileVirtualMachineSnapshot) syncVolumesAndUpdateCNSVolumeInfo(ctx
436431
}
437432
queryResult, err := r.volumeManager.QueryVolume(ctx, queryFilter)
438433
if err != nil {
439-
logger.Error(err, "syncVolumesAndUpdateCNSVolumeInfo: error while query volumes from cns")
434+
log.Errorf("syncVolumesAndUpdateCNSVolumeInfo: error while query volumes from cns. error: %v", err)
440435
return err
441436
}
442437
if queryResult != nil && len(queryResult.Volumes) > 0 {
443438
for _, cnsvolume := range queryResult.Volumes {
444439
val, ok := cnsvolume.BackingObjectDetails.(*cnstypes.CnsBlockBackingDetails)
445440
if ok {
446-
logger.Info("syncVolumesAndUpdateCNSVolumeInfo: fetched aggregated capacity for volume",
447-
"AggregatedSnapshotCapacityInMb", val.AggregatedSnapshotCapacityInMb,
448-
"VolumeId", cnsvolume.VolumeId.Id)
441+
log.Infof("syncVolumesAndUpdateCNSVolumeInfo: fetched aggregated capacity for volume %s "+
442+
"AggregatedSnapshotCapacityInMb %s", cnsvolume.VolumeId.Id, val.AggregatedSnapshotCapacityInMb)
443+
449444
// Update CNSVolumeInfo with latest aggregated Size and Update SPU used value.
450445
patch, err := common.GetCNSVolumeInfoPatch(ctx, val.AggregatedSnapshotCapacityInMb,
451446
cnsvolume.VolumeId.Id) // TODO: UDPATE to value returned
452447
if err != nil {
453-
logger.Error(err, "syncVolumesAndUpdateCNSVolumeInfo: failed to get cnsvolumeinfo patch")
448+
log.Errorf("syncVolumesAndUpdateCNSVolumeInfo: failed to get cnsvolumeinfo patch for "+
449+
"volume %s, error: %v", cnsvolume.VolumeId.Id, err)
454450
return err
455451
}
456452
patchBytes, err := json.Marshal(patch)
457453
if err != nil {
458-
logger.Error(err, "syncVolumesAndUpdateCNSVolumeInfo: error while json marshal")
454+
log.Errorf("syncVolumesAndUpdateCNSVolumeInfo: error while json marshal. error: %v", err)
459455
return err
460456
}
461457
err = r.volumeInfoService.PatchVolumeInfo(ctx, cnsvolume.VolumeId.Id,
462458
patchBytes, allowedRetriesToPatchCNSVolumeInfo)
463459
if err != nil {
464-
logger.Error(err, "syncVolumesAndUpdateCNSVolumeInfo: "+
465-
"failed to patch cnsvolumeinfo")
460+
log.Errorf("syncVolumesAndUpdateCNSVolumeInfo: failed to patch cnsvolumeinfo for volume "+
461+
"volume %s, error: %v", cnsvolume.VolumeId.Id, err)
466462
return err
467463
}
468464
} else {
469465
err = fmt.Errorf("unable to retrieve CnsBlockBackingDetails for volumeID %s",
470466
cnsvolume.VolumeId.Id)
471-
logger.Error(err, "syncVolumesAndUpdateCNSVolumeInfo: "+
472-
"could not retrieve CnsBlockBackingDetails")
467+
log.Errorf("syncVolumesAndUpdateCNSVolumeInfo: could not retrieve CnsBlockBackingDetails. "+
468+
"error: %v", err)
473469
return err
474470
}
475471
}

0 commit comments

Comments
 (0)