Configuration Management: Env, Flags & Viper

port := flag.String("port", envOr("PORT", "8080"), "HTTP listen port")
logLevel := flag.String("log-level", envOr("LOG_LEVEL", "info"), "slog level")
flag.Parse()

package main
 
import (
    "flag"
    "fmt"
    "log/slog"
    "os"
    "strings"
    "time"
 
    "github.com/spf13/viper"
)
 
type Config struct {
    Port         string
    LogLevel     slog.Level
    DBURL        string
    ReadTimeout  time.Duration
    EnableTracing bool
}
 
func main() {
    cfg, err := loadConfig()
    if err != nil {
        slog.Error("config invalid", "err", err)
        os.Exit(1)
    }
 
    logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: cfg.LogLevel}))
    slog.SetDefault(logger)
 
    slog.Info("startup config",
        "port", cfg.Port,
        "log_level", cfg.LogLevel.String(),
        "tracing", cfg.EnableTracing,
        "read_timeout", cfg.ReadTimeout.String(),
    )
 
    slog.Info("ready to serve", "addr", ":"+cfg.Port)
}
 
func loadConfig() (Config, error) {
    _ = flag.String("config", "", "optional config file path")
    flag.Parse()
 
    v := viper.New()
    v.SetDefault("port", "8080")
    v.SetDefault("log_level", "info")
    v.SetDefault("read_timeout", "5s")
    v.SetDefault("enable_tracing", false)
 
    v.SetEnvPrefix("APP")
    v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
    v.AutomaticEnv()
 
    if p := flag.Lookup("config").Value.String(); p != "" {
        v.SetConfigFile(p)
        if err := v.ReadInConfig(); err != nil {
            return Config{}, fmt.Errorf("read config: %w", err)
        }
    }
 
    level, err := parseLevel(v.GetString("log_level"))
    if err != nil {
        return Config{}, err
    }
    timeout, err := time.ParseDuration(v.GetString("read_timeout"))
    if err != nil {
        return Config{}, fmt.Errorf("read_timeout: %w", err)
    }
 
    db := v.GetString("db_url")
    if db == "" {
        return Config{}, fmt.Errorf("APP_DB_URL is required")
    }
 
    return Config{
        Port:          v.GetString("port"),
        LogLevel:      level,
        DBURL:         db,
        ReadTimeout:   timeout,
        EnableTracing: v.GetBool("enable_tracing"),
    }, nil
}
 
func parseLevel(s string) (slog.Level, error) {
    switch strings.ToLower(s) {
    case "debug":
        return slog.LevelDebug, nil
    case "info":
        return slog.LevelInfo, nil
    case "warn", "warning":
        return slog.LevelWarn, nil
    case "error":
        return slog.LevelError, nil
    default:
        return slog.LevelInfo, fmt.Errorf("unknown log level %q", s)
    }
}

// Small services: skip Viper
func envOr(key, fallback string) string {
    if v := os.Getenv(key); v != "" {
        return v
    }
    return fallback
}
 
// Validate once, pass struct - do not read env deep in handlers
type Config struct { Port string }
func NewServer(cfg Config) *http.Server { /* ... */ }