Reintroduce PR #5974: Remove klogr dependency and move to zap

.devcontainer/Dockerfile

@@ -45,7 +45,7 @@ RUN apt-get update \
     && go install honnef.co/go/tools/cmd/staticcheck@latest \
     && go install golang.org/x/tools/gopls@latest \
     # Protocol Buffer Compiler
-    && PROTOC_VERSION=21.9 \
+    && PROTOC_VERSION=29.2 \
     && if [ $(dpkg --print-architecture) = "amd64" ]; then PROTOC_ARCH="x86_64"; else PROTOC_ARCH="aarch_64" ; fi \
     && curl -LO "https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VERSION}/protoc-${PROTOC_VERSION}-linux-$PROTOC_ARCH.zip" \
     && unzip "protoc-${PROTOC_VERSION}-linux-$PROTOC_ARCH.zip" -d $HOME/.local \

BUILD.md

@@ -340,11 +340,11 @@ rfc3339nano - 2022-05-24T12:10:19.411Z
 
 ### Metrics Server logging
 
-Find `--v=0` argument in Operator Deployment section in `config/metrics-server/deployment.yaml` file, modify its value and redeploy.
+The Metrics Server logging can be configured in a similar way to the KEDA Operator and Admission Webhooks. The configuration is done in the `config/metrics-server/deployment.yaml` file.
 
-Allowed values are `"0"` for info, `"4"` for debug, or an integer value greater than `0`, specified as string
+To change the logging format, find the `--zap-encoder=` argument and modify its value. The allowed values are `json` and `console`. The default value is `console`.
 
-Default value: `"0"`
+To change the logging time encoding, find the `--zap-time-encoding=` argument and modify its value. The allowed values are `epoch`, `millis`, `nano`, `iso8601`, `rfc3339`, or `rfc3339nano`. The default value is `rfc3339`.
 
 ### CPU/Memory Profiling
 

CHANGELOG.md

@@ -89,6 +89,7 @@ Here is an overview of all new **experimental** features:
 - **General**: Centralize and improve automaxprocs configuration with proper structured logging ([#5970](https://github.com/kedacore/keda/issues/5970))
 - **General**: Fix event text when deactivation fails ([#6469](https://github.com/kedacore/keda/issues/6469))
 - **General**: Paused ScaledObject count is reported correctly after operator restart ([#6321](https://github.com/kedacore/keda/issues/6321))
+- **General**: Remove klogr dependency and replace with zap ([#5732](https://github.com/kedacore/keda/issues/5732))
 - **General**: ScaledJobs ready status set to true when recoverred problem ([#6329](https://github.com/kedacore/keda/pull/6329))
 - **AWS Scalers**: Add AWS region to the AWS Config Cache key ([#6128](https://github.com/kedacore/keda/issues/6128))
 - **Redis Streams**: Allow default value of 0 for activationLagCount ([#6478](https://github.com/kedacore/keda/issues/6478))

cmd/adapter/main.go

@@ -32,9 +32,9 @@ import (
 	kubemetrics "k8s.io/component-base/metrics"
 	"k8s.io/component-base/metrics/legacyregistry"
 	"k8s.io/klog/v2"
-	"k8s.io/klog/v2/klogr"
 	ctrl "sigs.k8s.io/controller-runtime"
 	ctrlcache "sigs.k8s.io/controller-runtime/pkg/cache"
+	"sigs.k8s.io/controller-runtime/pkg/log/zap"
 	ctrlmetrics "sigs.k8s.io/controller-runtime/pkg/metrics"
 	"sigs.k8s.io/controller-runtime/pkg/metrics/server"
 	basecmd "sigs.k8s.io/custom-metrics-apiserver/pkg/cmd"
@@ -54,10 +54,7 @@ type Adapter struct {
 	Message string
 }
 
-// https://github.com/kedacore/keda/issues/5732
-//
-//nolint:staticcheck // SA1019: klogr.New is deprecated.
-var logger = klogr.New().WithName("keda_metrics_adapter")
+var setupLog = ctrl.Log.WithName("keda_metrics_adapter")
 
 var (
 	adapterClientRequestQPS     float32
@@ -72,16 +69,16 @@ var (
 func (a *Adapter) makeProvider(ctx context.Context) (provider.ExternalMetricsProvider, error) {
 	scheme := scheme.Scheme
 	if err := appsv1.SchemeBuilder.AddToScheme(scheme); err != nil {
-		logger.Error(err, "failed to add apps/v1 scheme to runtime scheme")
+		setupLog.Error(err, "failed to add apps/v1 scheme to runtime scheme")
 		return nil, fmt.Errorf("failed to add apps/v1 scheme to runtime scheme (%s)", err)
 	}
 	if err := kedav1alpha1.SchemeBuilder.AddToScheme(scheme); err != nil {
-		logger.Error(err, "failed to add keda scheme to runtime scheme")
+		setupLog.Error(err, "failed to add keda scheme to runtime scheme")
 		return nil, fmt.Errorf("failed to add keda scheme to runtime scheme (%s)", err)
 	}
 	namespaces, err := kedautil.GetWatchNamespaces()
 	if err != nil {
-		logger.Error(err, "failed to get watch namespace")
+		setupLog.Error(err, "failed to get watch namespace")
 		return nil, fmt.Errorf("failed to get watch namespace (%s)", err)
 	}
 
@@ -104,23 +101,23 @@ func (a *Adapter) makeProvider(ctx context.Context) (provider.ExternalMetricsPro
 		PprofBindAddress: profilingAddr,
 	})
 	if err != nil {
-		logger.Error(err, "failed to setup manager")
+		setupLog.Error(err, "failed to setup manager")
 		return nil, err
 	}
 
-	logger.Info("Connecting Metrics Service gRPC client to the server", "address", metricsServiceAddr)
+	setupLog.Info("Connecting Metrics Service gRPC client to the server", "address", metricsServiceAddr)
 	grpcClient, err := metricsservice.NewGrpcClient(metricsServiceAddr, a.SecureServing.ServerCert.CertDirectory, metricsServiceGRPCAuthority, clientMetrics)
 	if err != nil {
-		logger.Error(err, "error connecting Metrics Service gRPC client to the server", "address", metricsServiceAddr)
+		setupLog.Error(err, "error connecting Metrics Service gRPC client to the server", "address", metricsServiceAddr)
 		return nil, err
 	}
 	go func() {
 		if err := mgr.Start(ctx); err != nil {
-			logger.Error(err, "controller-runtime encountered an error")
+			setupLog.Error(err, "controller-runtime encountered an error")
 			os.Exit(1)
 		}
 	}()
-	return kedaprovider.NewProvider(ctx, logger, mgr.GetClient(), *grpcClient), nil
+	return kedaprovider.NewProvider(ctx, setupLog, mgr.GetClient(), *grpcClient), nil
 }
 
 // getMetricHandler returns a http handler that exposes metrics from controller-runtime and apiserver
@@ -181,7 +178,7 @@ func RunMetricsServer(ctx context.Context) {
 	}
 
 	go func() {
-		logger.Info("starting /metrics server endpoint")
+		setupLog.Info("starting /metrics server endpoint")
 		// nosemgrep: use-tls
 		err := server.ListenAndServe()
 		if err != http.ErrServerClosed {
@@ -192,7 +189,7 @@ func RunMetricsServer(ctx context.Context) {
 	go func() {
 		<-ctx.Done()
 		if err := server.Shutdown(ctx); err != nil {
-			logger.Error(err, "http server shutdown error")
+			setupLog.Error(err, "http server shutdown error")
 		}
 	}()
 }
@@ -207,15 +204,15 @@ func generateDefaultMetricsServiceAddr() string {
 func printWelcomeMsg(cmd *Adapter) error {
 	clientset, err := cmd.DiscoveryClient()
 	if err != nil {
-		logger.Error(err, "not able to get Kubernetes version")
+		setupLog.Error(err, "not able to get Kubernetes version")
 		return err
 	}
 	version, err := clientset.ServerVersion()
 	if err != nil {
-		logger.Error(err, "not able to get Kubernetes version")
+		setupLog.Error(err, "not able to get Kubernetes version")
 		return err
 	}
-	kedautil.PrintWelcome(logger, kedautil.NewK8sVersion(version), "metrics server")
+	kedautil.PrintWelcome(setupLog, kedautil.NewK8sVersion(version), "metrics server")
 
 	return nil
 }
@@ -225,7 +222,7 @@ func main() {
 	var err error
 	defer func() {
 		if err != nil {
-			logger.Error(err, "unable to run external metrics adapter")
+			setupLog.Error(err, "unable to run external metrics adapter")
 		}
 	}()
 
@@ -236,7 +233,6 @@ func main() {
 	cmd.Name = "keda-adapter"
 
 	cmd.Flags().StringVar(&cmd.Message, "msg", "starting adapter...", "startup message")
-	cmd.Flags().AddGoFlagSet(flag.CommandLine) // make sure we get the klog flags
 	cmd.Flags().IntVar(&metricsAPIServerPort, "port", 8080, "Set the port for the metrics API server")
 	cmd.Flags().StringVar(&metricsServiceAddr, "metrics-service-address", generateDefaultMetricsServiceAddr(), "The address of the GRPC Metrics Service Server.")
 	cmd.Flags().StringVar(&metricsServiceGRPCAuthority, "metrics-service-grpc-authority", "", "Host Authority override for the Metrics Service if the Host Authority is not the same as the address used for the GRPC Metrics Service Server.")
@@ -245,31 +241,36 @@ func main() {
 	cmd.Flags().IntVar(&adapterClientRequestBurst, "kube-api-burst", 30, "Set the burst for throttling requests sent to the apiserver")
 	cmd.Flags().BoolVar(&disableCompression, "disable-compression", true, "Disable response compression for k8s restAPI in client-go. ")
 
+	// Make sure we get the zap flags
+	opts := zap.Options{}
+	opts.BindFlags(flag.CommandLine)
+	cmd.Flags().AddGoFlagSet(flag.CommandLine)
+
 	if err := cmd.Flags().Parse(os.Args); err != nil {
 		return
 	}
 
-	ctrl.SetLogger(logger)
+	ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts)))
 
 	err = printWelcomeMsg(cmd)
 	if err != nil {
 		return
 	}
 
-	err = kedautil.ConfigureMaxProcs(logger)
+	err = kedautil.ConfigureMaxProcs(setupLog)
 	if err != nil {
-		logger.Error(err, "failed to set max procs")
+		setupLog.Error(err, "failed to set max procs")
 		return
 	}
 
 	kedaProvider, err := cmd.makeProvider(ctx)
 	if err != nil {
-		logger.Error(err, "making provider")
+		setupLog.Error(err, "making provider")
 		return
 	}
 	cmd.WithExternalMetrics(kedaProvider)
 
-	logger.Info(cmd.Message)
+	setupLog.Info(cmd.Message)
 
 	RunMetricsServer(ctx)
 

config/metrics-server/deployment.yaml

@@ -57,9 +57,9 @@ spec:
           args:
           - /usr/local/bin/keda-adapter
           - --secure-port=6443
-          - --logtostderr=true
-          - --stderrthreshold=ERROR
-          - --v=0
+          - --zap-log-level=info
+          - --zap-encoder=console
+          - --zap-time-encoding=rfc3339
           - --client-ca-file=/certs/ca.crt
           - --tls-cert-file=/certs/tls.crt
           - --tls-private-key-file=/certs/tls.key