Simplify the configuration loading

Moves the options to flags. Also moves the
env variables to the main command, so there are
no sideeffects when running the commands.

Signed-off-by: Petr Kotas <pkotas@redhat.com>

Author: petrkotas

cadctl/cmd/investigate/investigate.go

@@ -19,10 +19,10 @@ package investigate
 import (
 	"fmt"
 	"os"
-	"path/filepath"
 	"strings"
 
 	cmv1 "github.com/openshift-online/ocm-sdk-go/clustersmgmt/v1"
+	"github.com/openshift/configuration-anomaly-detection/cadctl/config"
 	investigations "github.com/openshift/configuration-anomaly-detection/pkg/investigations"
 	"github.com/openshift/configuration-anomaly-detection/pkg/investigations/ccam"
 	investigation "github.com/openshift/configuration-anomaly-detection/pkg/investigations/investigation"
@@ -31,41 +31,49 @@ import (
 	"github.com/openshift/configuration-anomaly-detection/pkg/metrics"
 	ocm "github.com/openshift/configuration-anomaly-detection/pkg/ocm"
 	"github.com/openshift/configuration-anomaly-detection/pkg/pagerduty"
+	"go.uber.org/zap"
 
 	"github.com/spf13/cobra"
 )
 
+var c config.Config
+
 // InvestigateCmd represents the entry point for alert investigation
 var InvestigateCmd = &cobra.Command{
 	Use:          "investigate",
 	SilenceUsage: true,
 	Short:        "Filter for and investigate supported alerts",
-	RunE:         run,
+	PreRunE: func(cmd *cobra.Command, _ []string) error {
+		var err error
+
+		c, err = config.BuildConfig(cmd)
+		if err != nil {
+			return fmt.Errorf("failed to build config: %w", err)
+		}
+
+		// Initialize the logger here because it depends on user input
+		logging.RawLogger = logging.InitLogger(c.LogLevel, "")
+
+		return nil
+	},
+	RunE: run,
 }
 
-var (
-	logLevelFlag = ""
-	payloadPath  = "./payload.json"
-)
+var payloadPath = "./payload.json"
 
 const pagerdutyTitlePrefix = "[CAD Investigated]"
 
 func init() {
 	InvestigateCmd.Flags().StringVarP(&payloadPath, "payload-path", "p", payloadPath, "the path to the payload")
-	InvestigateCmd.Flags().StringVarP(&logging.LogLevelString, "log-level", "l", "", "the log level [debug,info,warn,error,fatal], default = info")
 
 	err := InvestigateCmd.MarkFlagRequired("payload-path")
 	if err != nil {
 		logging.Warn("Could not mark flag 'payload-path' as required")
 	}
 }
 
-func run(cmd *cobra.Command, _ []string) error {
+func run(_ *cobra.Command, _ []string) error {
 	// early init of logger for logs before clusterID is known
-	if cmd.Flags().Changed("log-level") {
-		flagValue, _ := cmd.Flags().GetString("log-level")
-		logging.RawLogger = logging.InitLogger(flagValue, "")
-	}
 	payload, err := os.ReadFile(payloadPath)
 	if err != nil {
 		return fmt.Errorf("failed to read webhook payload: %w", err)
@@ -87,8 +95,7 @@ func run(cmd *cobra.Command, _ []string) error {
 		}
 	}()
 
-	_, cadExperimentalEnabled := os.LookupEnv("CAD_EXPERIMENTAL_ENABLED")
-	alertInvestigation := investigations.GetInvestigation(pdClient.GetTitle(), cadExperimentalEnabled)
+	alertInvestigation := investigations.GetInvestigation(pdClient.GetTitle(), c.Experimental)
 
 	// Escalate all unsupported alerts
 	if alertInvestigation == nil {
@@ -109,8 +116,17 @@ func run(cmd *cobra.Command, _ []string) error {
 		return err
 	}
 
-	ocmClient, err := GetOCMClient()
-	if err != nil {
+	var ocmClient *ocm.SdkClient
+	var ocmErr error
+	// Initialize the OCM client
+	// If the config file is set, use it to initialize the OCM client
+	// use config file only when developing
+	if c.ConfigFile != "" {
+		ocmClient, ocmErr = ocm.NewFromConfig(c.ConfigFile)
+	} else {
+		ocmClient, ocmErr = ocm.NewFromClientKeyPair(c.CadOcmURL, c.CadOcmClientID, c.CadOcmClientSecret)
+	}
+	if ocmErr != nil {
 		return fmt.Errorf("could not initialize ocm client: %w", err)
 	}
 
@@ -122,13 +138,8 @@ func run(cmd *cobra.Command, _ []string) error {
 	// For installing clusters, externalID can be empty.
 	internalClusterID := cluster.ID()
 
-	// re-initialize logger for the internal-cluster-id context
-	// if log-level flag is set, take priority over env + default
-	if cmd.Flags().Changed("log-level") {
-		logging.RawLogger = logging.InitLogger(logLevelFlag, internalClusterID)
-	} else {
-		logging.RawLogger = logging.InitLogger(logging.LogLevelString, internalClusterID)
-	}
+	// add the internal-cluster-id context to the logger
+	logging.RawLogger = logging.RawLogger.With(zap.String("cluster_id", internalClusterID))
 
 	requiresInvestigation, err := clusterRequiresInvestigation(cluster, pdClient, ocmClient)
 	if err != nil || !requiresInvestigation {
@@ -184,22 +195,6 @@ func handleCADFailure(err error, resources *investigation.Resources, pdClient *p
 	}
 }
 
-// GetOCMClient will retrieve the OcmClient from the 'ocm' package
-func GetOCMClient() (*ocm.SdkClient, error) {
-	cadOcmFilePath := os.Getenv("CAD_OCM_FILE_PATH")
-
-	_, err := os.Stat(cadOcmFilePath)
-	if os.IsNotExist(err) {
-		configDir, err := os.UserConfigDir()
-		if err != nil {
-			return nil, err
-		}
-		cadOcmFilePath = filepath.Join(configDir, "/ocm/ocm.json")
-	}
-
-	return ocm.New(cadOcmFilePath)
-}
-
 // Checks pre-requisites for a cluster investigation:
 // - the cluster's state is supported by CAD for an investigation (= not uninstalling)
 // - the cloud provider is supported by CAD (cluster is AWS)

cadctl/cmd/root.go

@@ -17,6 +17,8 @@ limitations under the License.
 package cmd
 
 import (
+
+	// "github.com/openshift-online/ocm-cli/pkg/config"
 	investigate "github.com/openshift/configuration-anomaly-detection/cadctl/cmd/investigate"
 	"github.com/openshift/configuration-anomaly-detection/pkg/logging"
 	"github.com/openshift/configuration-anomaly-detection/pkg/metrics"
@@ -41,4 +43,6 @@ func Execute() {
 
 func init() {
 	rootCmd.AddCommand(investigate.InvestigateCmd)
+	rootCmd.PersistentFlags().StringP("ocmconfig", "c", "", "Path to the OCM config file to use for CLI requests. When not set the OCM_CONFIG environment variable will be used. If that is not set, the default OCM config locations will be file will be used.")
+	rootCmd.PersistentFlags().StringP("loglevel", "l", "info", "Log level to use. One of: debug, info, warn, error, fatal, panic")
 }

cadctl/config/config.go

@@ -0,0 +1,182 @@
+/*
+Copyright © 2025 Red Hat, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package config
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+
+	"github.com/openshift/configuration-anomaly-detection/pkg/ocm"
+)
+
+type Config struct {
+	ConfigFile         string
+	LogLevel           string
+	CadOcmClientID     string
+	CadOcmClientSecret string
+	CadOcmURL          string
+	Experimental       bool
+}
+
+func BuildConfig(cmd *cobra.Command) (Config, error) {
+	// Get the config file path from command line flags or environment variables
+	var c Config
+	var err error
+	var ocmConfigFile string
+
+	_, err = c.getLogLevel(cmd)
+	if err != nil {
+		return c, fmt.Errorf("failed to get log level: %w", err)
+	}
+
+	if ocmConfigFile, err = c.getConfigFile(cmd); err != nil {
+		return c, fmt.Errorf("failed to get config file: %w", err)
+	}
+
+	if ocmConfigFile == "" {
+		// loads the configuration unless config file is present
+		// config should be used only when developing
+		if _, err = c.getCadOcmClientID(); err != nil {
+			return c, fmt.Errorf("failed to get cadOcmClientID: %w", err)
+		}
+		if _, err = c.getCadOcmClientSecret(); err != nil {
+			return c, fmt.Errorf("failed to get cadOcmClientSecret: %w", err)
+		}
+		if _, err = c.getCadOcmURL(); err != nil {
+			return c, fmt.Errorf("failed to get cadOcmURL: %w", err)
+		}
+	}
+
+	if _, err = c.getExperimental(); err != nil {
+		return c, fmt.Errorf("failed to get experimental flag: %w", err)
+	}
+
+	return c, err
+}
+
+// getConfigFile retrieves the OCM config file path from the command line flags or environment variables.
+// It checks the following in order:
+// 1. Command line flag --ocmconfig
+// 2. Environment variable OCM_CONFIG
+// 3. Default OCM config locations
+// If the file is not found at any of these locations, the config path remains empty.
+// Missing config is a valid state, as the user may not have a config file.
+func (c *Config) getConfigFile(cmd *cobra.Command) (string, error) {
+	ocmConfigPath, err := cmd.Flags().GetString("ocmconfig")
+	if err != nil {
+		return "", fmt.Errorf("failed to get ocmconfig flag: %w", err)
+	}
+
+	if ocmConfigPath != "" {
+		if _, err := os.Stat(ocmConfigPath); err != nil {
+			return "", fmt.Errorf("ocmconfig file not found at %s: %w", ocmConfigPath, err)
+		}
+
+		c.ConfigFile = ocmConfigPath
+		return ocmConfigPath, nil
+	}
+
+	ocmConfigPath, exists := os.LookupEnv("OCM_CONFIG")
+	if exists {
+		if _, err := os.Stat(ocmConfigPath); err != nil {
+			return "", fmt.Errorf("ocmconfig file not found at %s: %w", ocmConfigPath, err)
+		}
+
+		c.ConfigFile = ocmConfigPath
+		return ocmConfigPath, nil
+	}
+
+	ocmConfigPath, err = ocm.Location()
+	if err != nil {
+		// Location() checks for file existence
+		return "", fmt.Errorf("failed to get ocmconfig file location: %w", err)
+	}
+
+	c.ConfigFile = ocmConfigPath
+	return ocmConfigPath, nil
+}
+
+func (c *Config) getLogLevel(cmd *cobra.Command) (string, error) {
+	logLevel, err := cmd.Flags().GetString("loglevel")
+	if err != nil {
+		return "", fmt.Errorf("failed to get loglevel flag: %w", err)
+	}
+	if logLevel != "" {
+		c.LogLevel = logLevel
+		return logLevel, nil
+	}
+
+	if envLogLevel, exists := os.LookupEnv("LOG_LEVEL"); exists {
+		c.LogLevel = envLogLevel
+		return logLevel, nil
+	}
+
+	c.LogLevel = "info"
+	return logLevel, nil
+}
+
+// getExperimental retrieves the experimental flag passed as a command line argument.
+// If not set, it checks the CAD_EXPERIMENTAL_ENABLED environment variable.
+// Defaults to false if neither is set.
+func (c *Config) getExperimental() (bool, error) {
+	_, exist := os.LookupEnv("CAD_EXPERIMENTAL_ENABLED")
+	if exist {
+		c.Experimental = true
+		return true, nil
+	}
+
+	c.Experimental = false
+	return false, nil
+}
+
+// getCadOcmClientID retrieves the OCM cliend ID passed as
+// an CAD_OCM_CLIENT_ID environment variable.
+func (c *Config) getCadOcmClientID() (string, error) {
+	cadOcmClientID, exist := os.LookupEnv("CAD_OCM_CLIENT_ID")
+	if !exist {
+		return "", fmt.Errorf("client-id flag or CAD_OCM_CLIENT_ID environment variable must be set")
+	}
+
+	c.CadOcmClientID = cadOcmClientID
+	return cadOcmClientID, nil
+}
+
+// getCadOcmClientSecret retrieves the OCM client secret passed as
+// an environment CAD_OCM_CLIENT_SECRET variable.
+func (c *Config) getCadOcmClientSecret() (string, error) {
+	cadOcmClientSecret, exist := os.LookupEnv("CAD_OCM_CLIENT_SECRET")
+	if !exist {
+		return "", fmt.Errorf("client-secret flag or CAD_OCM_CLIENT_SECRET environment variable must be set")
+	}
+
+	c.CadOcmClientSecret = cadOcmClientSecret
+	return cadOcmClientSecret, nil
+}
+
+// getCadOcmURL retrieves the OCM URL passed as an environment
+// CAD_OCM_URL variable.
+func (c *Config) getCadOcmURL() (string, error) {
+	cadOcmURL, exist := os.LookupEnv("CAD_OCM_URL")
+	if !exist {
+		return "", fmt.Errorf("ocm-url flag or CAD_OCM_URL environment variable must be set")
+	}
+
+	c.CadOcmURL = cadOcmURL
+	return cadOcmURL, nil
+}

interceptor/main.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/openshift/configuration-anomaly-detection/interceptor/pkg/interceptor"
 	"github.com/openshift/configuration-anomaly-detection/pkg/logging"
+	zap "go.uber.org/zap"
 	"knative.dev/pkg/signals"
 )
 
@@ -22,7 +23,7 @@ const (
 	idleTimeout  = 60 * time.Second
 )
 
-var logger = logging.InitLogger(logging.LogLevelString, "")
+var logger *zap.SugaredLogger
 
 func main() {
 	// set up signals so we handle the first shutdown signal gracefully
@@ -71,6 +72,17 @@ func main() {
 	logger.Infof("Server exiting")
 }
 
+func init() {
+	// read log level from environment variable
+	logLevel := os.Getenv("LOG_LEVEL")
+	if logLevel != "" {
+		logLevel = "info"
+	}
+
+	// set up logging
+	logger = logging.InitLogger(logLevel, logLevel)
+}
+
 func readinessHandler(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusOK)
 }

pkg/logging/logging.go

@@ -10,10 +10,8 @@ import (
 	"go.uber.org/zap/zapcore"
 )
 
-var LogLevelString = getLogLevel()
-
 // RawLogger is the raw global logger object used for calls wrapped by the logging package
-var RawLogger = InitLogger(LogLevelString, "")
+var RawLogger = InitLogger("info", "")
 
 // InitLogger initializes a cluster-id specific child logger
 func InitLogger(logLevelString string, clusterID string) *zap.SugaredLogger {
@@ -94,11 +92,3 @@ func Errorf(template string, args ...interface{}) {
 func Fatalf(template string, args ...interface{}) {
 	RawLogger.Fatalf(template, args...)
 }
-
-// getLogLevel returns the log level from the environment variable LOG_LEVEL
-func getLogLevel() string {
-	if envLogLevel, exists := os.LookupEnv("LOG_LEVEL"); exists {
-		return envLogLevel
-	}
-	return "info"
-}