sustainable-computing-io
diff --git a/‎cmd/kepler/main.go‎
Lines changed: 3 additions & 74 deletions b/‎cmd/kepler/main.go‎
Lines changed: 3 additions & 74 deletions
diff --git a/‎compose/dev/kepler-dev/etc/kepler/config.yaml‎
Lines changed: 8 additions & 2 deletions b/‎compose/dev/kepler-dev/etc/kepler/config.yaml‎
Lines changed: 8 additions & 2 deletions
diff --git a/‎config/config.go‎
Lines changed: 55 additions & 0 deletions b/‎config/config.go‎
Lines changed: 55 additions & 0 deletions
diff --git a/‎config/config_cpu_test.go‎
Lines changed: 147 additions & 0 deletions b/‎config/config_cpu_test.go‎
Lines changed: 147 additions & 0 deletions
@@ -45,6 +45,8 @@ func main() {
 	logVersionInfo(logger)
 	printConfigInfo(logger, cfg)
 
+	cfg.ApplyCpuMeterDeprecations(logger)
+
 	services, err := createServices(logger, cfg)
 	if err != nil {
 		logger.Error("failed to create services", "error", err)
@@ -127,7 +129,7 @@ Configuration
 
 func createServices(logger *slog.Logger, cfg *config.Config) ([]service.Service, error) {
 	logger.Debug("Creating all services")
-	cpuPowerMeter, err := createCPUMeter(logger, cfg)
+	cpuPowerMeter, err := device.CreateCPUMeter(logger, cfg)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create CPU power meter: %w", err)
 	}
@@ -309,79 +311,6 @@ func createPrometheusExporter(
 	return promExporter, nil
 }
 
-func createCPUMeter(logger *slog.Logger, cfg *config.Config) (device.CPUPowerMeter, error) {
-	// If fake meter is explicitly enabled, use it directly
-	if fake := cfg.Dev.FakeCpuMeter; *fake.Enabled {
-		return device.NewFakeCPUMeter(fake.Zones, device.WithFakeLogger(logger))
-	}
-
-	// If hwmon is explicitly enabled, use it directly
-	if cfg.IsFeatureEnabled(config.ExperimentalHwmonFeature) {
-		logger.Info("hwmon explicitly enabled via config")
-		return createHwmonMeter(logger, cfg)
-	}
-
-	// Try RAPL first (default logic -> attempt RAPL, then attempt HWMON)
-	if len(cfg.Rapl.Zones) > 0 {
-		logger.Info("rapl zones are filtered", "zones-enabled", cfg.Rapl.Zones)
-	}
-
-	raplMeter, err := device.NewCPUPowerMeter(
-		cfg.Host.SysFS,
-		device.WithRaplLogger(logger),
-		device.WithZoneFilter(cfg.Rapl.Zones),
-	)
-	if err != nil {
-		logger.Warn("RAPL not available, falling back to hwmon", "error", err)
-		return createHwmonMeter(logger, cfg)
-	}
-
-	// Verify RAPL can actually read energy data
-	if initErr := raplMeter.Init(); initErr != nil {
-		logger.Warn("RAPL initialization failed, falling back to hwmon", "error", initErr)
-		return createHwmonMeter(logger, cfg)
-	}
-
-	logger.Info("using RAPL power meter")
-	return raplMeter, nil
-}
-
-func createHwmonMeter(logger *slog.Logger, cfg *config.Config) (device.CPUPowerMeter, error) {
-	var hwmonZones []string
-	var chipRules []device.ConfigChipRule
-
-	if cfg.Experimental != nil {
-		hwmon := cfg.Experimental.Hwmon
-
-		if len(hwmon.Zones) > 0 {
-			logger.Info("hwmon zones are filtered", "zones-enabled", hwmon.Zones)
-			hwmonZones = hwmon.Zones
-		}
-
-		for _, cr := range hwmon.ChipRules {
-			chipRules = append(chipRules, device.ConfigChipRule{
-				Name:         cr.Name,
-				Pairings:     cr.Pairings,
-				SkipVoltages: cr.SkipVoltages,
-				SkipCurrents: cr.SkipCurrents,
-				UseSameIndex: cr.UseSameIndex,
-			})
-		}
-
-		if len(chipRules) > 0 {
-			logger.Info("hwmon chip rules configured", "count", len(chipRules))
-		}
-	}
-
-	logger.Info("using hwmon power meter")
-	return device.NewHwmonPowerMeter(
-		cfg.Host.SysFS,
-		device.WithHwmonLogger(logger),
-		device.WithHwmonZoneFilter(hwmonZones),
-		device.WithHwmonChipRules(chipRules),
-	)
-}
-
 // createGPUMeters discovers and initializes GPU power meters for all vendors.
 // Uses the registry pattern to support multiple GPU vendors (NVIDIA, AMD, Intel).
 // Returns empty slice if GPU is not enabled or no GPUs are available (soft-fail).
 
@@ -32,6 +32,12 @@ host:
   sysfs: /host/sys # Path to sysfs filesystem (default: /sys)
   procfs: /host/proc # Path to procfs filesystem (default: /proc)
 
+cpu:
+  # Ordered list of CPU power-meter backends. The first backend that
+  # initializes successfully and reports zones is used.
+  # Built-in backends: rapl, hwmon, fake.
+  meters: [rapl, hwmon]
+
 rapl:
   zones: [] # zones to be enabled, empty enables all default zones
 
@@ -71,7 +77,7 @@ kube: # kubernetes related config
 # WARN DO NOT ENABLE THIS IN PRODUCTION - for development / testing only
 dev:
   fake-cpu-meter:
-    enabled: false
+    enabled: false # DEPRECATED: set cpu.meters: ["fake"] instead. Overrides cpu.meters and emits a deprecation warning when true.
     zones: [] # zones to be enabled, empty enables all default zones
 
 # EXPERIMENTAL FEATURES - These features are experimental and may be unstable
@@ -84,7 +90,7 @@ experimental:
       nodeName: kepler-dev # Node name to use (overrides Kubernetes node name and hostname fallback)
       httpTimeout: 5s # HTTP client timeout for BMC requests (default: 5s)
   hwmon:
-    forceEnabled: false # Force hwmon as the power meter, skipping RAPL auto-detection
+    forceEnabled: false # DEPRECATED: set cpu.meters: ["hwmon"] instead. Emits a deprecation warning when true.
     zones: [] # List of zones to enable (default enable all)
     chipRules: [] # User-defined chip pairing rules (override/add to hardcoded defaults)
   gpu:
 
@@ -6,6 +6,7 @@ package config
 import (
 	"fmt"
 	"io"
+	"log/slog"
 	"net"
 	"net/url"
 	"os"
@@ -53,6 +54,13 @@ type (
 		ProcFS string `yaml:"procfs"`
 	}
 
+	// Cpu configuration controls how CPU power meters are selected.
+	// Meters lists backends in priority order. The first backend that
+	// initializes successfully and reports zones is used.
+	Cpu struct {
+		Meters []string `yaml:"meters"`
+	}
+
 	// Rapl configuration
 	Rapl struct {
 		Zones []string `yaml:"zones"`
@@ -192,6 +200,7 @@ type (
 		Log      Log      `yaml:"log"`
 		Host     Host     `yaml:"host"`
 		Monitor  Monitor  `yaml:"monitor"`
+		Cpu      Cpu      `yaml:"cpu"`
 		Rapl     Rapl     `yaml:"rapl"`
 		Exporter Exporter `yaml:"exporter"`
 		Web      Web      `yaml:"web"`
@@ -264,6 +273,9 @@ const (
 	MonitorStaleness         = "monitor.staleness" // not a flag
 	MonitorMaxTerminatedFlag = "monitor.max-terminated"
 
+	// CPU
+	CpuMeters = "cpu.meters" // not a flag
+
 	// RAPL
 	RaplZones = "rapl.zones" // not a flag
 
@@ -313,6 +325,9 @@ func DefaultConfig() *Config {
 			SysFS:  "/sys",
 			ProcFS: "/proc",
 		},
+		Cpu: Cpu{
+			Meters: []string{"rapl", "hwmon"},
+		},
 		Rapl: Rapl{
 			Zones: []string{},
 		},
@@ -358,6 +373,28 @@ func DefaultConfig() *Config {
 	return cfg
 }
 
+// ApplyCpuMeterDeprecations translates legacy CPU-meter selectors into an
+// effective cpu.meters value and logs a deprecation warning per translation.
+//
+// Legacy selectors:
+//   - experimental.hwmon.forceEnabled=true → cpu.meters: ["hwmon"]
+//   - dev.fake-cpu-meter.enabled=true     → cpu.meters: ["fake"]
+//
+// Legacy selectors win over an explicit cpu.meters when set, since operators
+// who set them today expect the legacy behavior. When both legacy keys are set,
+// fake takes precedence over hwmon. The legacy keys will stop working in a
+// future release.
+func (c *Config) ApplyCpuMeterDeprecations(logger *slog.Logger) {
+	switch {
+	case ptr.Deref(c.Dev.FakeCpuMeter.Enabled, false):
+		logger.Warn(`dev.fake-cpu-meter.enabled is deprecated; set cpu.meters: ["fake"] instead`)
+		c.Cpu.Meters = []string{"fake"}
+	case c.Experimental != nil && ptr.Deref(c.Experimental.Hwmon.ForceEnabled, false):
+		logger.Warn(`experimental.hwmon.forceEnabled is deprecated; set cpu.meters: ["hwmon"] instead`)
+		c.Cpu.Meters = []string{"hwmon"}
+	}
+}
+
 // Load loads configuration from an io.Reader
 func Load(r io.Reader) (*Config, error) {
 	cfg := DefaultConfig()
@@ -786,6 +823,10 @@ func (c *Config) sanitize() {
 		c.Web.ListenAddresses[i] = strings.TrimSpace(c.Web.ListenAddresses[i])
 	}
 
+	for i := range c.Cpu.Meters {
+		c.Cpu.Meters[i] = strings.TrimSpace(c.Cpu.Meters[i])
+	}
+
 	for i := range c.Rapl.Zones {
 		c.Rapl.Zones[i] = strings.TrimSpace(c.Rapl.Zones[i])
 	}
@@ -875,6 +916,19 @@ func (c *Config) Validate(skips ...SkipValidation) error {
 			}
 		}
 	}
+	{ // cpu.meters
+		// Keep this list in sync with the switch in internal/device/cpu_power_meter.go.
+		validCpuMeters := map[string]bool{
+			"rapl":  true,
+			"hwmon": true,
+			"fake":  true,
+		}
+		for _, name := range c.Cpu.Meters {
+			if !validCpuMeters[name] {
+				errs = append(errs, fmt.Sprintf("invalid cpu.meters entry %q, must be one of %q, %q, %q", name, "rapl", "hwmon", "fake"))
+			}
+		}
+	}
 	{ // Monitor
 		if c.Monitor.Interval < 0 {
 			errs = append(errs, fmt.Sprintf("invalid monitor interval: %s can't be negative", c.Monitor.Interval))
@@ -1076,6 +1130,7 @@ func (c *Config) manualString() string {
 		{MonitorIntervalFlag, c.Monitor.Interval.String()},
 		{MonitorStaleness, c.Monitor.Staleness.String()},
 		{MonitorMaxTerminatedFlag, fmt.Sprintf("%d", c.Monitor.MaxTerminated)},
+		{CpuMeters, strings.Join(c.Cpu.Meters, ", ")},
 		{RaplZones, strings.Join(c.Rapl.Zones, ", ")},
 		{ExporterStdoutEnabledFlag, fmt.Sprintf("%v", c.Exporter.Stdout.Enabled)},
 		{ExporterPrometheusEnabledFlag, fmt.Sprintf("%v", c.Exporter.Prometheus.Enabled)},
 
@@ -0,0 +1,147 @@
+// SPDX-FileCopyrightText: 2025 The Kepler Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package config
+
+import (
+	"log/slog"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"k8s.io/utils/ptr"
+)
+
+// TestCpuMeters covers cfg.Cpu.Meters defaults, deprecation translation, and
+// precedence. Each case sets up a Config and asserts the resulting Meters
+// after ApplyCpuMeterDeprecations runs. Log output is discarded; behaviour
+// is verified solely via cfg.Cpu.Meters.
+func TestCpuMeters(t *testing.T) {
+	tests := []struct {
+		name  string
+		setup func(*Config)
+		want  []string
+	}{
+		{
+			name:  "default: rapl then hwmon",
+			setup: func(*Config) {},
+			want:  []string{"rapl", "hwmon"},
+		},
+		{
+			name: "fake-cpu-meter overrides cpu.meters",
+			setup: func(c *Config) {
+				c.Dev.FakeCpuMeter.Enabled = ptr.To(true)
+			},
+			want: []string{"fake"},
+		},
+		{
+			name: "hwmon forceEnabled overrides cpu.meters",
+			setup: func(c *Config) {
+				c.Experimental = &Experimental{}
+				c.Experimental.Hwmon.ForceEnabled = ptr.To(true)
+			},
+			want: []string{"hwmon"},
+		},
+		{
+			name: "fake wins when both legacy keys are set",
+			setup: func(c *Config) {
+				c.Dev.FakeCpuMeter.Enabled = ptr.To(true)
+				c.Experimental = &Experimental{}
+				c.Experimental.Hwmon.ForceEnabled = ptr.To(true)
+			},
+			want: []string{"fake"},
+		},
+		{
+			name: "no legacy: explicit cpu.meters preserved",
+			setup: func(c *Config) {
+				c.Cpu.Meters = []string{"rapl"}
+			},
+			want: []string{"rapl"},
+		},
+	}
+
+	logger := slog.New(slog.DiscardHandler)
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			cfg := DefaultConfig()
+			tc.setup(cfg)
+			cfg.ApplyCpuMeterDeprecations(logger)
+			assert.Equal(t, tc.want, cfg.Cpu.Meters)
+		})
+	}
+}
+
+func TestCpuMetersValidation(t *testing.T) {
+	tests := []struct {
+		name    string
+		meters  []string
+		wantErr string
+	}{
+		{
+			name:   "all known backends",
+			meters: []string{"rapl", "hwmon", "fake"},
+		},
+		{
+			name:    "unknown backend",
+			meters:  []string{"rappl"},
+			wantErr: `invalid cpu.meters entry "rappl"`,
+		},
+		{
+			name:    "typo before valid backend still rejected",
+			meters:  []string{"rappl", "hwmon"},
+			wantErr: `invalid cpu.meters entry "rappl"`,
+		},
+		{
+			name:   "empty list passes Validate (CreateCPUMeter handles emptiness)",
+			meters: []string{},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			cfg := DefaultConfig()
+			cfg.Cpu.Meters = tc.meters
+			err := cfg.Validate(SkipHostValidation)
+			if tc.wantErr == "" {
+				assert.NoError(t, err)
+				return
+			}
+			require.Error(t, err)
+			assert.Contains(t, err.Error(), tc.wantErr)
+		})
+	}
+}
+
+func TestLoadCpuMetersFromYAML(t *testing.T) {
+	tests := []struct {
+		name     string
+		yamlData string
+		want     []string
+	}{
+		{
+			name:     "explicit hwmon-first",
+			yamlData: "cpu:\n  meters: [hwmon, rapl]\n",
+			want:     []string{"hwmon", "rapl"},
+		},
+		{
+			name:     "single backend",
+			yamlData: "cpu:\n  meters: [fake]\n",
+			want:     []string{"fake"},
+		},
+		{
+			name:     "empty list",
+			yamlData: "cpu:\n  meters: []\n",
+			want:     []string{},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			cfg, err := Load(strings.NewReader(tc.yamlData))
+			require.NoError(t, err)
+			assert.Equal(t, tc.want, cfg.Cpu.Meters)
+		})
+	}
+}