Refactor: Improve env utility (#803)

Refactored the environment variable utility (pkg/epp/util/env)
to enhance code quality, readability, and maintainability.

Key changes:
- Introduced generic helper functions `parseEnvWithValue` and
  `getEnvWithParser` to centralize common logic for fetching
  and parsing environment variables, significantly reducing
  code duplication.
- Standardized logging messages for consistency across all
  `GetEnv<Type>` functions.
- Added `GetEnvDuration`.

Author: LukeAVanDrie

pkg/epp/util/env/env.go

@@ -1,61 +1,71 @@
 package env
 
 import (
+	"fmt"
 	"os"
+	"reflect"
 	"strconv"
+	"time"
 
 	"github.com/go-logr/logr"
 )
 
-// getEnvFloat gets a float64 from an environment variable with a default value
-func GetEnvFloat(key string, defaultVal float64, logger logr.Logger) float64 {
-	val, exists := os.LookupEnv(key)
-	if !exists {
-		logger.Info("Environment variable not set, using default value",
-			"key", key, "defaultValue", defaultVal)
-		return defaultVal
-	}
-
-	floatVal, err := strconv.ParseFloat(val, 64)
+// parseEnvWithValue attempts to parse a string value using the provided
+// parser.
+// It logs success or failure and returns the parsed value or the default
+// value.
+// This helper is used when the environment variable is confirmed to exist.
+func parseEnvWithValue[T any](key string, valueStr string, defaultVal T,
+	parser func(string) (T, error), logger logr.Logger) T {
+	parsedVal, err := parser(valueStr)
 	if err != nil {
-		logger.Info("Failed to parse environment variable as float, using default value",
-			"key", key, "value", val, "error", err, "defaultValue", defaultVal)
+		logger.Info(fmt.Sprintf("Failed to parse environment variable as %s, using default value", reflect.TypeOf(defaultVal)),
+			"key", key, "rawValue", valueStr, "error", err,
+			"defaultValue", defaultVal)
 		return defaultVal
 	}
 
 	logger.Info("Successfully loaded environment variable",
-		"key", key, "value", floatVal)
-	return floatVal
+		"key", key, "value", parsedVal)
+	return parsedVal
 }
 
-// getEnvInt gets an int from an environment variable with a default value
-func GetEnvInt(key string, defaultVal int, logger logr.Logger) int {
-	val, exists := os.LookupEnv(key)
+// getEnvWithParser retrieves an environment variable. If set, it uses the
+// provided parser to convert it. Otherwise, it returns the default value.
+// It delegates to parseEnvWithValue for the actual parsing and detailed
+// logging once the variable is confirmed to exist.
+func getEnvWithParser[T any](key string, defaultVal T,
+	parser func(string) (T, error), logger logr.Logger) T {
+	valueStr, exists := os.LookupEnv(key)
 	if !exists {
 		logger.Info("Environment variable not set, using default value",
 			"key", key, "defaultValue", defaultVal)
 		return defaultVal
 	}
+	return parseEnvWithValue(key, valueStr, defaultVal, parser, logger)
+}
 
-	intVal, err := strconv.Atoi(val)
-	if err != nil {
-		logger.Info("Failed to parse environment variable as int, using default value",
-			"key", key, "value", val, "error", err, "defaultValue", defaultVal)
-		return defaultVal
-	}
+// GetEnvFloat gets a float64 from an environment variable with a default
+// value.
+func GetEnvFloat(key string, defaultVal float64, logger logr.Logger) float64 {
+	parser := func(s string) (float64, error) { return strconv.ParseFloat(s, 64) }
+	return getEnvWithParser(key, defaultVal, parser, logger)
+}
 
-	logger.Info("Successfully loaded environment variable",
-		"key", key, "value", intVal)
-	return intVal
+// GetEnvInt gets an int from an environment variable with a default value.
+func GetEnvInt(key string, defaultVal int, logger logr.Logger) int {
+	return getEnvWithParser(key, defaultVal, strconv.Atoi, logger)
+}
+
+// GetEnvDuration gets a time.Duration from an environment variable with a
+// default value.
+func GetEnvDuration(key string, defaultVal time.Duration, logger logr.Logger) time.Duration {
+	return getEnvWithParser(key, defaultVal, time.ParseDuration, logger)
 }
 
-// GetEnvString gets a string from an environment variable with a default value
+// GetEnvString gets a string from an environment variable with a default
+// value.
 func GetEnvString(key string, defaultVal string, logger logr.Logger) string {
-	val, exists := os.LookupEnv(key)
-	if !exists {
-		logger.Info("Environment variable not set, using default value",
-			"key", key, "defaultValue", defaultVal)
-		return defaultVal
-	}
-	return val
+	parser := func(s string) (string, error) { return s, nil }
+	return getEnvWithParser(key, defaultVal, parser, logger)
 }

pkg/epp/util/env/env_test.go

@@ -3,6 +3,7 @@ package env
 import (
 	"os"
 	"testing"
+	"time"
 
 	"github.com/go-logr/logr/testr"
 	logutil "sigs.k8s.io/gateway-api-inference-extension/pkg/epp/util/logging"
@@ -69,6 +70,80 @@ func TestGetEnvFloat(t *testing.T) {
 	}
 }
 
+func TestGetEnvDuration(t *testing.T) {
+	logger := testr.New(t)
+
+	tests := []struct {
+		name       string
+		key        string
+		value      string
+		defaultVal time.Duration
+		expected   time.Duration
+		setup      func()
+		teardown   func()
+	}{
+		{
+			name:       "env variable exists and is valid",
+			key:        "TEST_DURATION",
+			value:      "1h30m",
+			defaultVal: 0,
+			expected:   1*time.Hour + 30*time.Minute,
+			setup: func() {
+				os.Setenv("TEST_DURATION", "1h30m")
+			},
+			teardown: func() {
+				os.Unsetenv("TEST_DURATION")
+			},
+		},
+		{
+			name:       "env variable exists but is invalid",
+			key:        "TEST_DURATION",
+			value:      "invalid-duration",
+			defaultVal: 5 * time.Minute,
+			expected:   5 * time.Minute,
+			setup: func() {
+				os.Setenv("TEST_DURATION", "invalid-duration")
+			},
+			teardown: func() {
+				os.Unsetenv("TEST_DURATION")
+			},
+		},
+		{
+			name:       "env variable does not exist",
+			key:        "TEST_DURATION_MISSING",
+			defaultVal: 10 * time.Second,
+			expected:   10 * time.Second,
+			setup:      func() {},
+			teardown:   func() {},
+		},
+		{
+			name:       "env variable is empty string",
+			key:        "TEST_DURATION_EMPTY",
+			value:      "",
+			defaultVal: 1 * time.Millisecond,
+			expected:   1 * time.Millisecond,
+			setup: func() {
+				os.Setenv("TEST_DURATION_EMPTY", "")
+			},
+			teardown: func() {
+				os.Unsetenv("TEST_DURATION_EMPTY")
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			tc.setup()
+			defer tc.teardown()
+
+			result := GetEnvDuration(tc.key, tc.defaultVal, logger.V(logutil.VERBOSE))
+			if result != tc.expected {
+				t.Errorf("GetEnvDuration(%s, %v) = %v, expected %v", tc.key, tc.defaultVal, result, tc.expected)
+			}
+		})
+	}
+}
+
 func TestGetEnvInt(t *testing.T) {
 	logger := testr.New(t)