replace klog with zap log.

Signed-off-by: morvencao <lcao@redhat.com>

cmd/maestro/environments/e_production.go

@@ -43,7 +43,7 @@ func (e *productionEnvImpl) Flags() map[string]string {
 		"v":               "1",
 		"ocm-debug":       "false",
 		"enable-ocm-mock": "false",
-		"enable-sentry":   "true",
+		"enable-sentry":   "false",
 		"source-id":       "maestro",
 	}
 }

cmd/maestro/environments/framework.go

@@ -11,11 +11,11 @@ import (
 	"github.com/openshift-online/maestro/pkg/client/ocm"
 	"github.com/openshift-online/maestro/pkg/config"
 	"github.com/openshift-online/maestro/pkg/errors"
+	"github.com/openshift-online/maestro/pkg/logger"
 	"github.com/spf13/pflag"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
-	"k8s.io/klog/v2"
 
 	"open-cluster-management.io/sdk-go/pkg/cloudevents/generic"
 )
@@ -34,9 +34,14 @@ func init() {
 			TestingEnv:     &testingEnvImpl{environment},
 			ProductionEnv:  &productionEnvImpl{environment},
 		}
+
+		// initialize the logger
+		logger.InitLogger(environment.Name)
 	})
 }
 
+var log = logger.GetLogger()
+
 // EnvironmentImpl defines a set of behaviors for an OCM environment.
 // Each environment provides a set of flags for basic set/override of the environment.
 // Each environment is a set of configured things (services, handlers, clients, etc.) and
@@ -76,50 +81,50 @@ func (e *Env) AddFlags(flags *pflag.FlagSet) error {
 // This should be called after the e.Config has been set appropriately though AddFlags and pasing, done elsewhere
 // The environment does NOT handle flag parsing
 func (e *Env) Initialize() error {
-	klog.Infof("Initializing %s environment", e.Name)
+	log.Infof("Initializing environment: %s", e.Name)
 
 	envImpl, found := environments[e.Name]
 	if !found {
-		klog.Fatalf("Unknown runtime environment: %s", e.Name)
+		log.Fatalf("Unknown runtime environment: %s", e.Name)
 	}
 
 	if err := envImpl.VisitConfig(&e.ApplicationConfig); err != nil {
-		klog.Fatalf("Failed to visit ApplicationConfig: %s", err)
+		log.Fatalf("Failed to visit ApplicationConfig: %s", err)
 	}
 
 	messages := environment.Config.ReadFiles()
 	if len(messages) != 0 {
 		err := fmt.Errorf("unable to read configuration files:\n%s", strings.Join(messages, "\n"))
 		sentry.CaptureException(err)
-		klog.Fatalf("Unable to read configuration files:\n%s", strings.Join(messages, "\n"))
+		log.Fatalf("Unable to read configuration files:\n%s", strings.Join(messages, "\n"))
 	}
 
 	// each env will set db explicitly because the DB impl has a `once` init section
 	if err := envImpl.VisitDatabase(&e.Database); err != nil {
-		klog.Fatalf("Failed to visit Database: %s", err)
+		log.Fatalf("Failed to visit Database: %s", err)
 	}
 
 	if err := envImpl.VisitMessageBroker(&e.MessageBroker); err != nil {
-		klog.Fatalf("Failed to visit MessageBroker: %s", err)
+		log.Fatalf("Failed to visit MessageBroker: %s", err)
 	}
 
 	e.LoadServices()
 	if err := envImpl.VisitServices(&e.Services); err != nil {
-		klog.Fatalf("Failed to visit Services: %s", err)
+		log.Fatalf("Failed to visit Services: %s", err)
 	}
 
 	// Load clients after services so that clients can use services
 	err := e.LoadClients()
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to load clients: %w", err)
 	}
 	if err := envImpl.VisitClients(&e.Clients); err != nil {
-		klog.Fatalf("Failed to visit Clients: %s", err)
+		log.Fatalf("Failed to visit Clients: %s", err)
 	}
 
 	err = e.InitializeSentry()
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to initialize sentry: %w", err)
 	}
 
 	seedErr := e.Seed()
@@ -129,7 +134,7 @@ func (e *Env) Initialize() error {
 
 	if _, ok := envImpl.(HandlerVisitor); ok {
 		if err := (envImpl.(HandlerVisitor)).VisitHandlers(&e.Handlers); err != nil {
-			klog.Fatalf("Failed to visit Handlers: %s", err)
+			log.Fatalf("Failed to visit Handlers: %s", err)
 		}
 	}
 
@@ -162,64 +167,57 @@ func (e *Env) LoadClients() error {
 
 	// Create OCM Authz client
 	if e.Config.OCM.EnableMock {
-		klog.Infof("Using Mock OCM Authz Client")
+		log.Debugf("Using Mock OCM Authz Client")
 		e.Clients.OCM, err = ocm.NewClientMock(ocmConfig)
 	} else {
 		e.Clients.OCM, err = ocm.NewClient(ocmConfig)
 	}
 	if err != nil {
-		klog.Errorf("Unable to create OCM Authz client: %s", err.Error())
-		return err
+		return fmt.Errorf("Unable to create OCM Authz client: %v", err)
 	}
 
 	// Create CloudEvents Source client
 	if e.Config.MessageBroker.EnableMock {
-		klog.Infof("Using Mock CloudEvents Source Client")
+		log.Debugf("Using Mock CloudEvents Source Client")
 		e.Clients.CloudEventsSource = cloudevents.NewSourceClientMock(e.Services.Resources())
 	} else {
 		// For gRPC message broker type, Maestro server does not require the source client to publish resources or subscribe to resource status.
 		if e.Config.MessageBroker.MessageBrokerType != "grpc" {
 			_, config, err := generic.NewConfigLoader(e.Config.MessageBroker.MessageBrokerType, e.Config.MessageBroker.MessageBrokerConfig).
 				LoadConfig()
 			if err != nil {
-				klog.Errorf("Unable to load configuration: %s", err.Error())
-				return err
+				return fmt.Errorf("Unable to load cloudevent config: %v", err)
 			}
 
 			cloudEventsSourceOptions, err := generic.BuildCloudEventsSourceOptions(config,
 				e.Config.MessageBroker.ClientID, e.Config.MessageBroker.SourceID)
 			if err != nil {
-				klog.Errorf("Unable to build cloudevent source options: %s", err.Error())
-				return err
+				return fmt.Errorf("Unable to build cloudevent source options: %v", err)
 			}
 			e.Clients.CloudEventsSource, err = cloudevents.NewSourceClient(cloudEventsSourceOptions, e.Services.Resources())
 			if err != nil {
-				klog.Errorf("Unable to create CloudEvents Source client: %s", err.Error())
-				return err
+				return fmt.Errorf("Unable to create cloudevent source client: %v", err)
 			}
 		}
 	}
 
 	// Create GRPC authorizer based on configuration
 	if e.Config.GRPCServer.EnableGRPCServer {
 		if e.Config.GRPCServer.GRPCAuthNType == "mock" {
-			klog.Infof("Using Mock GRPC Authorizer")
+			log.Debugf("Using Mock GRPC Authorizer")
 			e.Clients.GRPCAuthorizer = grpcauthorizer.NewMockGRPCAuthorizer()
 		} else {
 			kubeConfig, err := clientcmd.BuildConfigFromFlags("", e.Config.GRPCServer.GRPCAuthorizerConfig)
 			if err != nil {
-				klog.Warningf("Unable to create kube client config: %s", err.Error())
-				// fallback to in-cluster config
+				log.Warnf("Unable to load kubeconfig from file %s: %v, falling back to in-cluster config", e.Config.GRPCServer.GRPCAuthorizerConfig, err)
 				kubeConfig, err = rest.InClusterConfig()
 				if err != nil {
-					klog.Errorf("Unable to create kube client config: %s", err.Error())
-					return err
+					return fmt.Errorf("Unable to retrieve kube client config: %v", err)
 				}
 			}
 			kubeClient, err := kubernetes.NewForConfig(kubeConfig)
 			if err != nil {
-				klog.Errorf("Unable to create kube client: %s", err.Error())
-				return err
+				return fmt.Errorf("Unable to create kube client: %v", err)
 			}
 			e.Clients.GRPCAuthorizer = grpcauthorizer.NewKubeGRPCAuthorizer(kubeClient)
 		}
@@ -235,12 +233,12 @@ func (e *Env) InitializeSentry() error {
 		key := e.Config.Sentry.Key
 		url := e.Config.Sentry.URL
 		project := e.Config.Sentry.Project
-		klog.Infof("Sentry error reporting enabled to %s on project %s", url, project)
+		log.Debugf("Sentry error reporting enabled to %s on project %s", url, project)
 		options.Dsn = fmt.Sprintf("https://%s@%s/%s", key, url, project)
 	} else {
 		// Setting the DSN to an empty string effectively disables sentry
 		// See https://godoc.org/github.com/getsentry/sentry-go#ClientOptions Dsn
-		klog.Infof("Disabling Sentry error reporting")
+		log.Debugf("Disabling Sentry error reporting")
 		options.Dsn = ""
 	}
 
@@ -264,16 +262,16 @@ func (e *Env) InitializeSentry() error {
 
 	err = sentry.Init(options)
 	if err != nil {
-		klog.Errorf("Unable to initialize sentry integration: %s", err.Error())
-		return err
+		return fmt.Errorf("Unable to initialize sentry integration: %s", err.Error())
 	}
+
 	return nil
 }
 
 func (e *Env) Teardown() {
 	if e.Name != TestingEnv {
 		if err := e.Database.SessionFactory.Close(); err != nil {
-			klog.Fatalf("Unable to close db connection: %s", err.Error())
+			log.Fatalf("Unable to close db connection: %s", err.Error())
 		}
 		e.Clients.OCM.Close()
 	}
@@ -282,8 +280,7 @@ func (e *Env) Teardown() {
 func setConfigDefaults(flags *pflag.FlagSet, defaults map[string]string) error {
 	for name, value := range defaults {
 		if err := flags.Set(name, value); err != nil {
-			klog.Errorf("Error setting flag %s: %v", name, err)
-			return err
+			return fmt.Errorf("Error setting flag %s: %v", name, err)
 		}
 	}
 	return nil

cmd/maestro/main.go

@@ -3,24 +3,30 @@ package main
 import (
 	"flag"
 	"os"
-	"strconv"
 
-	"github.com/go-logr/zapr"
+	"github.com/fsnotify/fsnotify"
 	"github.com/openshift-online/maestro/cmd/maestro/agent"
-	"github.com/openshift-online/maestro/cmd/maestro/environments"
 	"github.com/openshift-online/maestro/cmd/maestro/migrate"
 	"github.com/openshift-online/maestro/cmd/maestro/servecmd"
+	"github.com/openshift-online/maestro/pkg/logger"
 	"github.com/spf13/cobra"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
+	"github.com/spf13/viper"
 	"k8s.io/klog/v2"
 )
 
 // nolint
 //
 //go:generate go-bindata -o ../../data/generated/openapi/openapi.go -pkg openapi -prefix ../../openapi/ ../../openapi
+const (
+	logConfigFile = "/configs/logging/config.yaml"
+	varLogLevel   = "log_level"
+)
+
+var log = logger.GetLogger()
 
 func main() {
+	defer logger.SyncLogger() // flush the logger
+
 	// check if the glog flag is already registered to avoid duplicate flag define error
 	if flag.CommandLine.Lookup("alsologtostderr") != nil {
 		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
@@ -29,51 +35,32 @@ func main() {
 	// add klog flags
 	klog.InitFlags(nil)
 
-	// Set up klog backing logger
-	cobra.OnInitialize(func() {
-		// Retrieve log level from klog flags
-		logLevel, err := strconv.ParseInt(flag.CommandLine.Lookup("v").Value.String(), 10, 8)
-		if err != nil {
-			klog.Fatalf("can't parse log level: %v", err)
-		}
-
-		// Initialize zap logger based on environment
-		var zc zap.Config
-		env := environments.GetEnvironmentStrFromEnv()
-		switch env {
-		case environments.DevelopmentEnv:
-			zc = zap.NewDevelopmentConfig()
-		case environments.ProductionEnv:
-			zc = zap.NewProductionConfig()
-		default:
-			zc = zap.NewDevelopmentConfig()
-		}
-
-		// zap log level is the inverse of klog log level, for more details refer to:
-		// https://github.com/go-logr/zapr?tab=readme-ov-file#increasing-verbosity
-		// zap level mapping to klog level:
-		// fatal: -5, panic: -4, dpanic: -3, error: -2, warn: -1, info: 0, debug: 1
-		// the higher the log level, the more verbose the logs:
-		// if the log level is 0, it will log everything except debug logs;
-		// if the log level is 1, it will log everything including debug logs;
-		// if the log level is 2 or higher, it will log everything including klog verbose logs.
-		zc.Level = zap.NewAtomicLevelAt(zapcore.Level(0 - logLevel))
-		// Disable stacktrace to reduce logs size
-		zc.DisableStacktrace = true
-		zapLog, err := zc.Build()
-		if err != nil {
-			klog.Fatalf("can't initialize zap logger: %v", err)
-		}
-		// Set backing logger for klog
-		klog.SetLogger(zapr.NewLogger(zapLog))
-	})
-
 	// Initialize root command
 	rootCmd := &cobra.Command{
 		Use:  "maestro",
 		Long: "maestro is a multi-cluster resources orchestrator for Kubernetes",
 	}
 
+	// set the logging config file
+	viper.SetConfigFile(logConfigFile)
+	// default log level is info
+	viper.SetDefault(varLogLevel, "info")
+	if err := viper.ReadInConfig(); err != nil {
+		if _, ok := err.(*os.PathError); ok {
+			log.Infof("no config file '%s' not found", logConfigFile)
+		} else {
+			log.Errorf("failed to read the config file '%s': %v", logConfigFile, err)
+		}
+	} else {
+		logger.SetLogLevel(viper.GetString(varLogLevel))
+	}
+	// monitor the changes in the config file
+	viper.WatchConfig()
+	viper.OnConfigChange(func(e fsnotify.Event) {
+		log.Infof("config file changed: %s, new log level: %s", e.Name, viper.GetString(varLogLevel))
+		logger.SetLogLevel(viper.GetString(varLogLevel))
+	})
+
 	// Add klog flags to root command
 	rootCmd.PersistentFlags().AddGoFlagSet(flag.CommandLine)
 
@@ -86,6 +73,6 @@ func main() {
 	rootCmd.AddCommand(migrateCmd, serveCmd, agentCmd)
 
 	if err := rootCmd.Execute(); err != nil {
-		klog.Fatalf("error running command: %v", err)
+		log.Fatalf("error running command: %v", err)
 	}
 }

cmd/maestro/migrate/cmd.go

@@ -4,13 +4,14 @@ import (
 	"context"
 
 	"github.com/openshift-online/maestro/pkg/db/db_session"
+	"github.com/openshift-online/maestro/pkg/logger"
 	"github.com/spf13/cobra"
-	"k8s.io/klog/v2"
 
 	"github.com/openshift-online/maestro/pkg/config"
 	"github.com/openshift-online/maestro/pkg/db"
 )
 
+var log = logger.GetLogger()
 var dbConfig = config.NewDatabaseConfig()
 
 // migration sub-command handles running migrations
@@ -29,11 +30,11 @@ func NewMigrationCommand() *cobra.Command {
 func runMigration(_ *cobra.Command, _ []string) {
 	err := dbConfig.ReadFiles()
 	if err != nil {
-		klog.Fatal(err)
+		log.Fatal(err)
 	}
 
 	connection := db_session.NewProdFactory(dbConfig)
 	if err := db.Migrate(connection.New(context.Background())); err != nil {
-		klog.Fatal(err)
+		log.Fatal(err)
 	}
 }