Merge pull request #365 from aramase/update-deps

feat: update deps and switch to klog

Author: k8s-ci-robot

cmd/secrets-store-csi-driver/main.go

@@ -23,9 +23,10 @@ import (
 	"sigs.k8s.io/secrets-store-csi-driver/pkg/metrics"
 	"sigs.k8s.io/secrets-store-csi-driver/pkg/rotation"
 
-	log "github.com/sirupsen/logrus"
 	"k8s.io/apimachinery/pkg/runtime"
 	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
+	json "k8s.io/component-base/logs/json"
+	"k8s.io/klog/v2"
 
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -41,9 +42,8 @@ var (
 	endpoint           = flag.String("endpoint", "unix://tmp/csi.sock", "CSI endpoint")
 	driverName         = flag.String("drivername", "secrets-store.csi.k8s.io", "name of the driver")
 	nodeID             = flag.String("nodeid", "", "node id")
-	debug              = flag.Bool("debug", false, "sets log to debug level")
+	debug              = flag.Bool("debug", false, "sets log to debug level [DEPRECATED]. Use -v=<log level> to configure log level.")
 	logFormatJSON      = flag.Bool("log-format-json", false, "set log formatter to json")
-	logReportCaller    = flag.Bool("log-report-caller", false, "include the calling method as fields in the log")
 	providerVolumePath = flag.String("provider-volume", "/etc/kubernetes/secrets-store-csi-providers", "Volume path for provider")
 	minProviderVersion = flag.String("min-provider-version", "", "set minimum supported provider versions with current driver")
 	metricsAddr        = flag.String("metrics-addr", ":8095", "The address the metric endpoint binds to")
@@ -63,25 +63,25 @@ func init() {
 }
 
 func main() {
+	klog.InitFlags(nil)
+	defer klog.Flush()
+
 	flag.Parse()
 
-	log.SetLevel(log.InfoLevel)
-	if *debug {
-		log.SetLevel(log.DebugLevel)
-	}
 	if *logFormatJSON {
-		log.SetFormatter(&log.JSONFormatter{})
+		klog.SetLogger(json.JSONLogger)
+	}
+	if *debug {
+		klog.Warning("--debug flag has been DEPRECATED and will be removed in future releases. Use -v=<log level> to configure log verbosity.")
 	}
-
-	log.SetReportCaller(*logReportCaller)
 
 	// initialize metrics exporter before creating measurements
 	// Issue: https://github.com/open-telemetry/opentelemetry-go/issues/677
 	// this has been resolved in otel release v0.5.0
 	// TODO (aramase) update to latest version of otel and deps
 	m, err := metrics.NewMetricsExporter()
 	if err != nil {
-		log.Fatalf("failed to initialize metrics exporter, error: %+v", err)
+		klog.Fatalf("failed to initialize metrics exporter, error: %+v", err)
 	}
 	defer m.Stop()
 
@@ -94,23 +94,23 @@ func main() {
 		LeaderElection:     false,
 	})
 	if err != nil {
-		log.Fatalf("failed to start manager, error: %+v", err)
+		klog.Fatalf("failed to start manager, error: %+v", err)
 	}
 
 	reconciler, err := controllers.New(mgr, *nodeID)
 	if err != nil {
-		log.Fatalf("failed to create secret provider class pod status reconciler, error: %+v", err)
+		klog.Fatalf("failed to create secret provider class pod status reconciler, error: %+v", err)
 	}
 	if err = reconciler.SetupWithManager(mgr); err != nil {
-		log.Fatalf("failed to create controller, error: %+v", err)
+		klog.Fatalf("failed to create controller, error: %+v", err)
 	}
 	// +kubebuilder:scaffold:builder
 
 	stopCh := ctrl.SetupSignalHandler()
 	go func() {
-		log.Infof("starting manager")
+		klog.Infof("starting manager")
 		if err := mgr.Start(stopCh); err != nil {
-			log.Fatalf("failed to run manager, error: %+v", err)
+			klog.Fatalf("failed to run manager, error: %+v", err)
 		}
 	}()
 
@@ -121,7 +121,7 @@ func main() {
 	if *enableSecretRotation {
 		rec, err := rotation.NewReconciler(scheme, *providerVolumePath, *nodeID, *rotationPollInterval)
 		if err != nil {
-			log.Fatalf("failed to initialize rotation reconciler, error: %+v", err)
+			klog.Fatalf("failed to initialize rotation reconciler, error: %+v", err)
 		}
 		stopCh := make(<-chan struct{})
 		go rec.Run(stopCh)
@@ -134,11 +134,11 @@ func handle() {
 	driver := secretsstore.GetDriver()
 	cfg, err := config.GetConfig()
 	if err != nil {
-		log.Fatalf("failed to initialize driver, error getting config: %+v", err)
+		klog.Fatalf("failed to initialize driver, error getting config: %+v", err)
 	}
 	c, err := client.New(cfg, client.Options{Scheme: scheme, Mapper: nil})
 	if err != nil {
-		log.Fatalf("failed to initialize driver, error creating client: %+v", err)
+		klog.Fatalf("failed to initialize driver, error creating client: %+v", err)
 	}
 	driver.Run(*driverName, *nodeID, *endpoint, *providerVolumePath, *minProviderVersion, *grpcSupportedProviders, c)
 }

controllers/secretproviderclasspodstatus_controller.go

@@ -28,8 +28,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	"k8s.io/client-go/tools/record"
-
-	log "github.com/sirupsen/logrus"
+	"k8s.io/klog/v2"
 
 	"sigs.k8s.io/secrets-store-csi-driver/apis/v1alpha1"
 	"sigs.k8s.io/secrets-store-csi-driver/pkg/client/clientset/versioned/scheme"
@@ -61,7 +60,6 @@ const (
 type SecretProviderClassPodStatusReconciler struct {
 	client.Client
 	mutex         *sync.Mutex
-	log           *log.Logger
 	scheme        *apiruntime.Scheme
 	nodeID        string
 	reader        client.Reader
@@ -97,14 +95,14 @@ func (r *SecretProviderClassPodStatusReconciler) RunPatcher(stopCh <-chan struct
 			return
 		case <-ticker.C:
 			if err := r.Patcher(); err != nil {
-				log.Errorf("failed to patch secret owner ref, err: %+v", err)
+				klog.ErrorS(err, "failed to patch secret owner ref")
 			}
 		}
 	}
 }
 
 func (r *SecretProviderClassPodStatusReconciler) Patcher() error {
-	log.Debugf("patcher started")
+	klog.V(5).Infof("patcher started")
 	r.mutex.Lock()
 	defer r.mutex.Unlock()
 
@@ -126,8 +124,7 @@ func (r *SecretProviderClassPodStatusReconciler) Patcher() error {
 			spc = &val
 		} else {
 			if err := r.reader.Get(ctx, client.ObjectKey{Namespace: spcPodStatuses[i].Namespace, Name: spcName}, spc); err != nil {
-				log.Errorf("failed to get spc %s, err: %+v", spcName, err)
-				return err
+				return fmt.Errorf("failed to get spc %s, err: %+v", spcName, err)
 			}
 			spcMap[spcPodStatuses[i].Namespace+"/"+spcName] = *spc
 		}
@@ -146,7 +143,7 @@ func (r *SecretProviderClassPodStatusReconciler) Patcher() error {
 		patchFn := func() (bool, error) {
 			if err := r.patchSecretWithOwnerRef(ctx, secret.Name, secret.Namespace, owners...); err != nil {
 				if !apierrors.IsConflict(err) || !apierrors.IsTimeout(err) {
-					log.Errorf("failed to set owner ref for secret, err: %+v", err)
+					klog.ErrorS(err, "failed to set owner ref for secret", "secret", klog.ObjectRef{Namespace: secret.Namespace, Name: secret.Name})
 				}
 				return false, nil
 			}
@@ -162,7 +159,7 @@ func (r *SecretProviderClassPodStatusReconciler) Patcher() error {
 		}
 	}
 
-	log.Debugf("patcher completed")
+	klog.V(5).Infof("patcher completed")
 	return nil
 }
 
@@ -184,54 +181,54 @@ func (r *SecretProviderClassPodStatusReconciler) Reconcile(req ctrl.Request) (ct
 	defer r.mutex.Unlock()
 
 	ctx := context.Background()
-	logger := log.WithFields(log.Fields{"secretproviderclasspodstatus": req.NamespacedName, "node": r.nodeID})
-	logger.Info("reconcile started")
+	klog.InfoS("reconcile started", "spcps", req.NamespacedName.String())
 
-	var spcPodStatus v1alpha1.SecretProviderClassPodStatus
-	if err := r.reader.Get(ctx, req.NamespacedName, &spcPodStatus); err != nil {
+	spcPodStatus := &v1alpha1.SecretProviderClassPodStatus{}
+	if err := r.reader.Get(ctx, req.NamespacedName, spcPodStatus); err != nil {
 		if apierrors.IsNotFound(err) {
+			klog.InfoS("reconcile complete", "spcps", req.NamespacedName.String())
 			return ctrl.Result{}, nil
 		}
-		logger.Errorf("failed to get spc pod status, err: %+v", err)
+		klog.ErrorS(err, "failed to get spc pod status", "spcps", req.NamespacedName.String())
 		return ctrl.Result{}, err
 	}
 
 	// reconcile delete
 	if !spcPodStatus.GetDeletionTimestamp().IsZero() {
-		logger.Infof("reconcile complete")
+		klog.InfoS("reconcile complete", "spcps", req.NamespacedName.String())
 		return ctrl.Result{}, nil
 	}
 
 	node, ok := spcPodStatus.GetLabels()[v1alpha1.InternalNodeLabel]
 	if !ok {
-		logger.Info("node label not found, ignoring this spc pod status")
+		klog.V(3).InfoS("node label not found, ignoring this spc pod status", "spcps", klog.KObj(spcPodStatus))
 		return ctrl.Result{}, nil
 	}
 	if !strings.EqualFold(node, r.nodeID) {
-		logger.Infof("ignoring as spc pod status belongs to node %s", node)
+		klog.V(3).InfoS("ignoring as spc pod status belongs diff node", "node", node, "spcps", klog.KObj(spcPodStatus))
 		return ctrl.Result{}, nil
 	}
 
 	spcName := spcPodStatus.Status.SecretProviderClassName
 	spc := &v1alpha1.SecretProviderClass{}
 	if err := r.reader.Get(ctx, client.ObjectKey{Namespace: req.Namespace, Name: spcName}, spc); err != nil {
-		logger.Errorf("failed to get spc %s, err: %+v", spcName, err)
+		klog.ErrorS(err, "failed to get spc", "spc", spcName)
 		if apierrors.IsNotFound(err) {
 			return ctrl.Result{RequeueAfter: 5 * time.Second}, nil
 		}
 		return ctrl.Result{}, err
 	}
 
 	if len(spc.Spec.SecretObjects) == 0 {
-		logger.Infof("no secret objects defined for spc, nothing to reconcile")
+		klog.InfoS("no secret objects defined for spc, nothing to reconcile", "spc", klog.KObj(spc), "spcps", klog.KObj(spcPodStatus))
 		return ctrl.Result{}, nil
 	}
 
 	// Obtain the full pod metadata. An object reference is needed for sending
 	// events and the UID is helpful for validating the SPCPS TargetPath.
 	pod := &v1.Pod{}
 	if err := r.reader.Get(ctx, client.ObjectKey{Namespace: req.Namespace, Name: spcPodStatus.Status.PodName}, pod); err != nil {
-		logger.Errorf("failed to get pod %s/%s, err: %+v", req.Namespace, spcPodStatus.Status.PodName, err)
+		klog.ErrorS(err, "failed to get pod", "pod", klog.ObjectRef{Namespace: req.Namespace, Name: spcPodStatus.Status.PodName})
 		if apierrors.IsNotFound(err) {
 			return ctrl.Result{RequeueAfter: 5 * time.Second}, nil
 		}
@@ -255,21 +252,21 @@ func (r *SecretProviderClassPodStatusReconciler) Reconcile(req ctrl.Request) (ct
 	files, err := fileutil.GetMountedFiles(spcPodStatus.Status.TargetPath)
 	if err != nil {
 		r.generateEvent(pod, corev1.EventTypeWarning, secretCreationFailedReason, fmt.Sprintf("failed to get mounted files, err: %+v", err))
-		logger.Errorf("failed to get mounted files, err: %+v", err)
+		klog.ErrorS(err, "failed to get mounted files", "spc", klog.KObj(spc), "pod", klog.KObj(pod), "spcps", klog.KObj(spcPodStatus))
 		return ctrl.Result{RequeueAfter: 10 * time.Second}, err
 	}
 	errs := make([]error, 0)
 	for _, secretObj := range spc.Spec.SecretObjects {
 		secretName := strings.TrimSpace(secretObj.SecretName)
 
 		if err = secretutil.ValidateSecretObject(*secretObj); err != nil {
-			logger.Errorf("failed to validate secret object in spc %s/%s, err: %+v", spc.Namespace, spc.Name, err)
+			klog.ErrorS(err, "failed to validate secret object in spc", "spc", klog.KObj(spc), "pod", klog.KObj(pod), "spcps", klog.KObj(spcPodStatus))
 			errs = append(errs, fmt.Errorf("failed to validate secret object in spc %s/%s, err: %+v", spc.Namespace, spc.Name, err))
 			continue
 		}
 		exists, err := r.secretExists(ctx, secretName, req.Namespace)
 		if err != nil {
-			logger.Errorf("failed to check if secret %s exists, err: %+v", secretName, err)
+			klog.ErrorS(err, "failed to check if secret exists", "secret", klog.ObjectRef{Namespace: req.Namespace, Name: secretName}, "spc", klog.KObj(spc), "pod", klog.KObj(pod), "spcps", klog.KObj(spcPodStatus))
 			errs = append(errs, fmt.Errorf("failed to check if secret %s exists, err: %+v", secretName, err))
 			continue
 		}
@@ -282,7 +279,7 @@ func (r *SecretProviderClassPodStatusReconciler) Reconcile(req ctrl.Request) (ct
 			datamap := make(map[string][]byte)
 			if datamap, err = secretutil.GetSecretData(secretObj.Data, secretType, files); err != nil {
 				r.generateEvent(pod, corev1.EventTypeWarning, secretCreationFailedReason, fmt.Sprintf("failed to get data in spc %s/%s for secret %s, err: %+v", req.Namespace, spcName, secretName, err))
-				log.Errorf("failed to get data in spc %s/%s for secret %s, err: %+v", req.Namespace, spcName, secretName, err)
+				klog.ErrorS(err, "failed to get data in spc for secret", "spc", klog.KObj(spc), "pod", klog.KObj(pod), "secret", klog.ObjectRef{Namespace: req.Namespace, Name: secretName}, "spcps", klog.KObj(spcPodStatus))
 				errs = append(errs, fmt.Errorf("failed to get data in spc %s/%s for secret %s, err: %+v", req.Namespace, spcName, secretName, err))
 				continue
 			}
@@ -298,7 +295,7 @@ func (r *SecretProviderClassPodStatusReconciler) Reconcile(req ctrl.Request) (ct
 
 			createFn := func() (bool, error) {
 				if err := r.createK8sSecret(ctx, secretName, req.Namespace, datamap, labelsMap, secretType); err != nil {
-					logger.Errorf("failed createK8sSecret, err: %v for secret: %s", err, secretName)
+					klog.ErrorS(err, "failed to create Kubernetes secret", "spc", klog.KObj(spc), "pod", klog.KObj(pod), "secret", klog.ObjectRef{Namespace: req.Namespace, Name: secretName}, "spcps", klog.KObj(spcPodStatus))
 					return false, nil
 				}
 				return true, nil
@@ -323,7 +320,7 @@ func (r *SecretProviderClassPodStatusReconciler) Reconcile(req ctrl.Request) (ct
 		return ctrl.Result{Requeue: true}, nil
 	}
 
-	logger.Info("reconcile complete")
+	klog.InfoS("reconcile complete", "spc", klog.KObj(spc), "pod", klog.KObj(pod), "spcps", klog.KObj(spcPodStatus))
 	// requeue the spc pod status again after 5mins to check if secret and ownerRef exists
 	// and haven't been modified. If secret doesn't exist, then this requeue will ensure it's
 	// created in the next reconcile and the owner ref patched again
@@ -351,7 +348,7 @@ func (r *SecretProviderClassPodStatusReconciler) createK8sSecret(ctx context.Con
 
 	err := r.writer.Create(ctx, secret)
 	if err == nil {
-		log.Infof("created k8s secret: %s/%s", namespace, name)
+		klog.InfoS("successfully created Kubernetes secret", "secret", klog.ObjectRef{Namespace: namespace, Name: name})
 		return nil
 	}
 	if apierrors.IsAlreadyExists(err) {
@@ -369,7 +366,7 @@ func (r *SecretProviderClassPodStatusReconciler) patchSecretWithOwnerRef(ctx con
 	}
 	if err := r.Client.Get(ctx, secretKey, secret); err != nil {
 		if apierrors.IsNotFound(err) {
-			log.Debugf("secret %s/%s not found for patching", namespace, name)
+			klog.V(5).InfoS("secret not found for patching", "secret", klog.ObjectRef{Namespace: namespace, Name: name})
 			return nil
 		}
 		return err

controllers/secretproviderclasspodstatus_controller_test.go

@@ -24,8 +24,6 @@ import (
 
 	. "github.com/onsi/gomega"
 
-	log "github.com/sirupsen/logrus"
-
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -87,7 +85,6 @@ func newReconciler(client client.Client, scheme *runtime.Scheme) *SecretProvider
 		Client:        client,
 		reader:        client,
 		writer:        client,
-		log:           log.New(),
 		scheme:        scheme,
 		eventRecorder: fakeRecorder,
 	}

go.mod

@@ -1,26 +1,27 @@
 module sigs.k8s.io/secrets-store-csi-driver
 
-go 1.13
+go 1.15
 
 require (
 	github.com/blang/semver v3.5.0+incompatible
 	github.com/container-storage-interface/spec v1.0.0
+	github.com/go-logr/logr v0.2.1 // indirect
 	github.com/golang/protobuf v1.4.2
 	github.com/google/go-cmp v0.5.0
 	github.com/kubernetes-csi/csi-lib-utils v0.6.1
 	github.com/kubernetes-csi/csi-test v1.1.0
-	github.com/onsi/gomega v1.8.1
-	github.com/pkg/errors v0.9.1 // indirect
-	github.com/sirupsen/logrus v1.4.2
+	github.com/onsi/gomega v1.10.1
 	github.com/stretchr/testify v1.5.1
 	go.opentelemetry.io/otel v0.4.3
 	go.opentelemetry.io/otel/exporters/metric/prometheus v0.4.3
-	golang.org/x/net v0.0.0-20200222125558-5a598a2470a0
+	golang.org/x/net v0.0.0-20200707034311-ab3426394381
 	google.golang.org/grpc v1.27.1
 	google.golang.org/protobuf v1.25.0
-	k8s.io/api v0.17.2
-	k8s.io/apimachinery v0.17.2
-	k8s.io/client-go v0.17.2
-	k8s.io/utils v0.0.0-20191114184206-e782cd3c129f
-	sigs.k8s.io/controller-runtime v0.5.5
+	k8s.io/api v0.19.3
+	k8s.io/apimachinery v0.19.3
+	k8s.io/client-go v0.19.3
+	k8s.io/component-base v0.19.3
+	k8s.io/klog/v2 v2.3.0
+	k8s.io/utils v0.0.0-20200729134348-d5654de09c73
+	sigs.k8s.io/controller-runtime v0.6.3
 )