refactor(logger): migrate from glog to slog with structured logging

Author: yasun1

README.md

@@ -155,6 +155,7 @@ This project uses [pre-commit](https://pre-commit.io/) for code quality checks.
 - **[Database](docs/database.md)** - Schema, migrations, and data model
 - **[Deployment](docs/deployment.md)** - Container images, Kubernetes deployment, and configuration
 - **[Authentication](docs/authentication.md)** - Development and production auth
+- **[Logging](docs/logging.md)** - Structured logging, OpenTelemetry integration, and data masking
 
 ### Additional Resources
 

cmd/hyperfleet-api/environments/framework.go

@@ -1,16 +1,17 @@
 package environments
 
 import (
+	"context"
 	"os"
 	"strings"
 
-	"github.com/golang/glog"
 	"github.com/spf13/pflag"
 
 	"github.com/openshift-hyperfleet/hyperfleet-api/cmd/hyperfleet-api/environments/registry"
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/client/ocm"
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/config"
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/errors"
+	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/logger"
 )
 
 func init() {
@@ -64,38 +65,45 @@ 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 {
-	glog.Infof("Initializing %s environment", e.Name)
+	ctx := context.Background()
+	logger.Infof(ctx, "Initializing %s environment", e.Name)
 
 	envImpl, found := environments[e.Name]
 	if !found {
-		glog.Fatalf("Unknown runtime environment: %s", e.Name)
+		logger.Errorf(ctx, "Unknown runtime environment: %s", e.Name)
+		os.Exit(1)
 	}
 
 	if err := envImpl.OverrideConfig(e.Config); err != nil {
-		glog.Fatalf("Failed to configure ApplicationConfig: %s", err)
+		logger.Errorf(ctx, "Failed to configure ApplicationConfig: %s", err)
+		os.Exit(1)
 	}
 
 	messages := environment.Config.ReadFiles()
 	if len(messages) != 0 {
-		glog.Fatalf("unable to read configuration files:\n%s", strings.Join(messages, "\n"))
+		logger.Errorf(ctx, "unable to read configuration files:\n%s", strings.Join(messages, "\n"))
+		os.Exit(1)
 	}
 
 	// each env will set db explicitly because the DB impl has a `once` init section
 	if err := envImpl.OverrideDatabase(&e.Database); err != nil {
-		glog.Fatalf("Failed to configure Database: %s", err)
+		logger.Errorf(ctx, "Failed to configure Database: %s", err)
+		os.Exit(1)
 	}
 
 	err := e.LoadClients()
 	if err != nil {
 		return err
 	}
 	if err := envImpl.OverrideClients(&e.Clients); err != nil {
-		glog.Fatalf("Failed to configure Clients: %s", err)
+		logger.Errorf(ctx, "Failed to configure Clients: %s", err)
+		os.Exit(1)
 	}
 
 	e.LoadServices()
 	if err := envImpl.OverrideServices(&e.Services); err != nil {
-		glog.Fatalf("Failed to configure Services: %s", err)
+		logger.Errorf(ctx, "Failed to configure Services: %s", err)
+		os.Exit(1)
 	}
 
 	seedErr := e.Seed()
@@ -104,7 +112,8 @@ func (e *Env) Initialize() error {
 	}
 
 	if err := envImpl.OverrideHandlers(&e.Handlers); err != nil {
-		glog.Fatalf("Failed to configure Handlers: %s", err)
+		logger.Errorf(ctx, "Failed to configure Handlers: %s", err)
+		os.Exit(1)
 	}
 
 	return nil
@@ -123,6 +132,7 @@ func (e *Env) LoadServices() {
 }
 
 func (e *Env) LoadClients() error {
+	ctx := context.Background()
 	var err error
 
 	ocmConfig := ocm.Config{
@@ -136,36 +146,38 @@ func (e *Env) LoadClients() error {
 
 	// Create OCM Authz client
 	if e.Config.OCM.EnableMock {
-		glog.Infof("Using Mock OCM Authz Client")
+		logger.Info(ctx, "Using Mock OCM Authz Client")
 		e.Clients.OCM, err = ocm.NewClientMock(ocmConfig)
 	} else {
 		e.Clients.OCM, err = ocm.NewClient(ocmConfig)
 	}
 	if err != nil {
-		glog.Errorf("Unable to create OCM Authz client: %s", err.Error())
+		logger.Errorf(ctx, "Unable to create OCM Authz client: %s", err)
 		return err
 	}
 
 	return nil
 }
 
 func (e *Env) Teardown() {
+	ctx := context.Background()
 	if e.Database.SessionFactory != nil {
 		if err := e.Database.SessionFactory.Close(); err != nil {
-			glog.Errorf("Error closing database session factory: %s", err.Error())
+			logger.Errorf(ctx, "Error closing database session factory: %s", err)
 		}
 	}
 	if e.Clients.OCM != nil {
 		if err := e.Clients.OCM.Close(); err != nil {
-			glog.Errorf("Error closing OCM client: %v", err)
+			logger.Errorf(ctx, "Error closing OCM client: %v", err)
 		}
 	}
 }
 
 func setConfigDefaults(flags *pflag.FlagSet, defaults map[string]string) error {
+	ctx := context.Background()
 	for name, value := range defaults {
 		if err := flags.Set(name, value); err != nil {
-			glog.Errorf("Error setting flag %s: %v", name, err)
+			logger.Error(ctx, "Error setting flag", "flag", name, "error", err)
 			return err
 		}
 	}

cmd/hyperfleet-api/main.go

@@ -1,13 +1,16 @@
 package main
 
 import (
+	"context"
 	"flag"
+	"log/slog"
+	"os"
 
-	"github.com/golang/glog"
 	"github.com/spf13/cobra"
 
 	"github.com/openshift-hyperfleet/hyperfleet-api/cmd/hyperfleet-api/migrate"
 	"github.com/openshift-hyperfleet/hyperfleet-api/cmd/hyperfleet-api/servecmd"
+	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/logger"
 
 	// Import plugins to trigger their init() functions
 	// _ "github.com/openshift-hyperfleet/hyperfleet-api/plugins/events" // REMOVED: Events plugin no longer exists
@@ -20,18 +23,14 @@ import (
 // nolint
 
 func main() {
-	// This is needed to make `glog` believe that the flags have already been parsed, otherwise
-	// every log messages is prefixed by an error message stating the the flags haven't been
-	// parsed.
-	if err := flag.CommandLine.Parse([]string{}); err != nil {
-		glog.Fatalf("Failed to parse flags: %v", err)
-	}
-
-	//pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
+	// Initialize logger first (before any logging occurs)
+	initDefaultLogger()
+	ctx := context.Background()
 
-	// Always log to stderr by default
-	if err := flag.Set("logtostderr", "true"); err != nil {
-		glog.Infof("Unable to set logtostderr to true")
+	// Parse flags (needed for cobra compatibility)
+	if err := flag.CommandLine.Parse([]string{}); err != nil {
+		logger.Error(ctx, "Failed to parse flags", "error", err)
+		os.Exit(1)
 	}
 
 	rootCmd := &cobra.Command{
@@ -47,6 +46,29 @@ func main() {
 	rootCmd.AddCommand(migrateCmd, serveCmd)
 
 	if err := rootCmd.Execute(); err != nil {
-		glog.Fatalf("error running command: %v", err)
+		logger.Error(ctx, "Error running command", "error", err)
+		os.Exit(1)
+	}
+}
+
+// initDefaultLogger initializes a default logger with INFO level
+// This ensures logging works before environment/config is loaded
+func initDefaultLogger() {
+	cfg := &logger.LogConfig{
+		Level:     slog.LevelInfo,
+		Format:    logger.FormatJSON,
+		Output:    os.Stdout,
+		Component: "hyperfleet-api",
+		Version:   "unknown",
+		Hostname:  getHostname(),
+	}
+	logger.InitGlobalLogger(cfg)
+}
+
+func getHostname() string {
+	hostname, err := os.Hostname()
+	if err != nil {
+		return "unknown"
 	}
+	return hostname
 }

cmd/hyperfleet-api/migrate/cmd.go

@@ -3,13 +3,14 @@ package migrate
 import (
 	"context"
 	"flag"
+	"os"
 
-	"github.com/golang/glog"
-	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/db/db_session"
 	"github.com/spf13/cobra"
 
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/config"
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/db"
+	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/db/db_session"
+	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/logger"
 )
 
 var dbConfig = config.NewDatabaseConfig()
@@ -29,13 +30,16 @@ func NewMigrateCommand() *cobra.Command {
 }
 
 func runMigrate(_ *cobra.Command, _ []string) {
+	ctx := context.Background()
 	err := dbConfig.ReadFiles()
 	if err != nil {
-		glog.Fatal(err)
+		logger.Error(ctx, "Fatal error", "error", err)
+		os.Exit(1)
 	}
 
 	connection := db_session.NewProdFactory(dbConfig)
-	if err := db.Migrate(connection.New(context.Background())); err != nil {
-		glog.Fatal(err)
+	if err := db.Migrate(connection.New(ctx)); err != nil {
+		logger.Error(ctx, "Fatal error", "error", err)
+		os.Exit(1)
 	}
 }

cmd/hyperfleet-api/servecmd/cmd.go

@@ -5,15 +5,17 @@ import (
 	"log/slog"
 	"os"
 
-	"github.com/golang/glog"
 	"github.com/spf13/cobra"
 
 	"github.com/openshift-hyperfleet/hyperfleet-api/cmd/hyperfleet-api/environments"
 	"github.com/openshift-hyperfleet/hyperfleet-api/cmd/hyperfleet-api/server"
+	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/api"
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/logger"
+	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/telemetry"
 )
 
 func NewServeCommand() *cobra.Command {
+	ctx := context.Background()
 	cmd := &cobra.Command{
 		Use:   "serve",
 		Short: "Serve the hyperfleet",
@@ -22,31 +24,54 @@ func NewServeCommand() *cobra.Command {
 	}
 	err := environments.Environment().AddFlags(cmd.PersistentFlags())
 	if err != nil {
-		glog.Fatalf("Unable to add environment flags to serve command: %s", err.Error())
+		logger.Error(ctx, "Unable to add environment flags to serve command", "error", err)
+		os.Exit(1)
 	}
 
 	return cmd
 }
 
 func runServe(cmd *cobra.Command, args []string) {
+	ctx := context.Background()
+
+	// Initialize environment (loads configuration)
 	err := environments.Environment().Initialize()
 	if err != nil {
-		glog.Fatalf("Unable to initialize environment: %s", err.Error())
+		logger.Error(ctx, "Unable to initialize environment", "error", err)
+		os.Exit(1)
 	}
 
-	// Initialize slog logger (demonstration only, full migration in PR 3)
-	ctx := context.Background()
-	hostname, _ := os.Hostname()
-	logConfig := &logger.LogConfig{
-		Level:     slog.LevelInfo,
-		Format:    logger.FormatJSON,
-		Output:    os.Stdout,
-		Component: "api",
-		Version:   "dev",
-		Hostname:  hostname,
+	// Bind environment variables for advanced configuration (OTel, Masking)
+	environments.Environment().Config.Logging.BindEnv()
+
+	// Initialize slog logger
+	initLogger()
+
+	// Initialize OpenTelemetry (if enabled)
+	if environments.Environment().Config.Logging.OTel.Enabled {
+		samplingRate := environments.Environment().Config.Logging.OTel.SamplingRate
+		tp, err := telemetry.InitTraceProvider("hyperfleet-api", api.Version, samplingRate)
+		if err != nil {
+			logger.Warn(ctx, "Failed to initialize OpenTelemetry", "error", err)
+		} else {
+			defer func() {
+				if err := telemetry.Shutdown(context.Background(), tp); err != nil {
+					logger.Error(ctx, "Failed to shutdown OpenTelemetry", "error", err)
+				}
+			}()
+			logger.Info(ctx, "OpenTelemetry initialized", "sampling_rate", samplingRate)
+		}
+	} else {
+		logger.Info(ctx, "OpenTelemetry disabled", "otel_enabled", false)
 	}
-	logger.InitGlobalLogger(logConfig)
-	logger.Info(ctx, "New slog logger initialized (example)", "log_level", "info", "log_format", "json")
+
+	// Log configuration
+	logger.Info(ctx, "Logger initialized",
+		"log_level", environments.Environment().Config.Logging.Level,
+		"log_format", environments.Environment().Config.Logging.Format,
+		"log_output", environments.Environment().Config.Logging.Output,
+		"masking_enabled", environments.Environment().Config.Logging.Masking.Enabled,
+	)
 
 	// Run the servers
 	go func() {
@@ -66,3 +91,46 @@ func runServe(cmd *cobra.Command, args []string) {
 
 	select {}
 }
+
+// initLogger initializes the global slog logger from configuration
+func initLogger() {
+	ctx := context.Background()
+	cfg := environments.Environment().Config.Logging
+
+	// Parse log level
+	level, err := logger.ParseLogLevel(cfg.Level)
+	if err != nil {
+		logger.Warn(ctx, "Invalid log level, using default", "level", cfg.Level, "error", err)
+		level = slog.LevelInfo // Default to info
+	}
+
+	// Parse log format
+	format, err := logger.ParseLogFormat(cfg.Format)
+	if err != nil {
+		logger.Warn(ctx, "Invalid log format, using default", "format", cfg.Format, "error", err)
+		format = logger.FormatJSON // Default to JSON
+	}
+
+	// Parse log output
+	output, err := logger.ParseLogOutput(cfg.Output)
+	if err != nil {
+		logger.Warn(ctx, "Invalid log output, using default", "output", cfg.Output, "error", err)
+		output = os.Stdout // Default to stdout
+	}
+
+	// Get hostname
+	hostname, _ := os.Hostname()
+
+	// Create logger config
+	logConfig := &logger.LogConfig{
+		Level:     level,
+		Format:    format,
+		Output:    output,
+		Component: "api",
+		Version:   api.Version,
+		Hostname:  hostname,
+	}
+
+	// Initialize global logger
+	logger.InitGlobalLogger(logConfig)
+}