feat(metrics): add configurable metrics level filtering for Prometheus exporter

  - Add configurable metrics level filtering to control which metric types are exported by the Prometheus exporter
  - Implement metrics level configuration via command line flags and YAML config
  - Add support for granular control over node, process, container, VM, and pod metrics
  - Added tests

  Supported metric levels: node, process, container, vm, pod, all, none

Signed-off-by: Vimal Kumar <vimal78@gmail.com>

Author: vimalk78

cmd/kepler/main.go

@@ -194,11 +194,15 @@ func createServices(logger *slog.Logger, cfg *config.Config) ([]service.Service,
 func createPrometheusExporter(logger *slog.Logger, cfg *config.Config, apiServer *server.APIServer, pm *monitor.PowerMonitor) (*prometheus.Exporter, error) {
 	logger.Debug("Creating Prometheus exporter")
 
+	// Use metrics level from configuration (already parsed)
+	metricsLevel := cfg.Exporter.Prometheus.MetricsLevel
+
 	collectors, err := prometheus.CreateCollectors(
 		pm,
 		prometheus.WithLogger(logger),
 		prometheus.WithProcFSPath(cfg.Host.ProcFS),
 		prometheus.WithNodeName(cfg.Kube.Node),
+		prometheus.WithMetricsLevel(metricsLevel),
 	)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create Prometheus collectors: %w", err)

compose/dev/kepler-dev/etc/kepler/config.yaml

@@ -36,6 +36,11 @@ exporter:
     debugCollectors:
       - go
       - process
+    # metricsLevel: all
+    metricsLevel:
+        - node
+        - container
+        - process
 
 debug: # debug related config
   pprof: # pprof related config

config/config.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/alecthomas/kingpin/v2"
+	"github.com/sustainable-computing-io/kepler/internal/exporter/prometheus/metrics"
 	"gopkg.in/yaml.v3"
 	"k8s.io/utils/ptr"
 )
@@ -53,8 +54,9 @@ type (
 	}
 
 	PrometheusExporter struct {
-		Enabled         *bool    `yaml:"enabled"`
-		DebugCollectors []string `yaml:"debugCollectors"`
+		Enabled         *bool           `yaml:"enabled"`
+		DebugCollectors []string        `yaml:"debugCollectors"`
+		MetricsLevel    metrics.Level   `yaml:"metricsLevel"`
 	}
 
 	Exporter struct {
@@ -91,6 +93,55 @@ type (
 	}
 )
 
+// MetricsLevelValue is a custom kingpin.Value that parses metrics levels directly into metrics.Level
+type MetricsLevelValue struct {
+	level *metrics.Level
+}
+
+// NewMetricsLevelValue creates a new MetricsLevelValue with the given target
+func NewMetricsLevelValue(target *metrics.Level) *MetricsLevelValue {
+	return &MetricsLevelValue{level: target}
+}
+
+// Set implements kingpin.Value interface - parses and accumulates metrics levels
+func (m *MetricsLevelValue) Set(value string) error {
+	// Parse the single value into a level
+	level, err := metrics.ParseLevel([]string{value})
+	if err != nil {
+		return err
+	}
+	
+	// If this is the first value and it's not a special "all" or "none" case,
+	// initialize to none first to clear any default
+	if *m.level == metrics.MetricsLevelAll && value != "all" {
+		*m.level = metrics.MetricsLevelNone
+	}
+	
+	// Handle special cases
+	if value == "all" {
+		*m.level = metrics.MetricsLevelAll
+		return nil
+	}
+	if value == "none" {
+		*m.level = metrics.MetricsLevelNone
+		return nil
+	}
+	
+	// Accumulate the level using bitwise OR
+	*m.level |= level
+	return nil
+}
+
+// String implements kingpin.Value interface
+func (m *MetricsLevelValue) String() string {
+	return m.level.String()
+}
+
+// IsCumulative implements kingpin.Value interface to support multiple values
+func (m *MetricsLevelValue) IsCumulative() bool {
+	return true
+}
+
 type SkipValidation int
 
 const (
@@ -122,6 +173,7 @@ const (
 	ExporterPrometheusEnabledFlag = "exporter.prometheus"
 	// NOTE: not a flag
 	ExporterPrometheusDebugCollectors = "exporter.prometheus.debug-collectors"
+	ExporterPrometheusMetricsFlag     = "metrics"
 
 	// kubernetes flags
 	KubernetesFlag   = "kube.enable"
@@ -156,6 +208,7 @@ func DefaultConfig() *Config {
 			Prometheus: PrometheusExporter{
 				Enabled:         ptr.To(true),
 				DebugCollectors: []string{"go"},
+				MetricsLevel:    metrics.MetricsLevelAll,
 			},
 		},
 		Debug: Debug{
@@ -252,6 +305,9 @@ func RegisterFlags(app *kingpin.Application) ConfigUpdaterFn {
 
 	prometheusExporterEnabled := app.Flag(ExporterPrometheusEnabledFlag, "Enable Prometheus exporter").Default("true").Bool()
 
+	var metricsLevel = metrics.MetricsLevelAll
+	app.Flag(ExporterPrometheusMetricsFlag, "Metrics levels to export (node,process,container,vm,pod,all,none)").SetValue(NewMetricsLevelValue(&metricsLevel))
+
 	kubernetes := app.Flag(KubernetesFlag, "Monitor kubernetes").Default("false").Bool()
 	kubeconfig := app.Flag(KubeConfigFlag, "Path to a kubeconfig. Only required if out-of-cluster.").ExistingFile()
 	nodeName := app.Flag(KubeNodeNameFlag, "Name of kubernetes node on which kepler is running.").String()
@@ -295,6 +351,10 @@ func RegisterFlags(app *kingpin.Application) ConfigUpdaterFn {
 			cfg.Exporter.Prometheus.Enabled = prometheusExporterEnabled
 		}
 
+		if flagsSet[ExporterPrometheusMetricsFlag] {
+			cfg.Exporter.Prometheus.MetricsLevel = metricsLevel
+		}
+
 		if flagsSet[KubernetesFlag] {
 			cfg.Kube.Enabled = kubernetes
 		}
@@ -468,6 +528,7 @@ func (c *Config) manualString() string {
 		{ExporterStdoutEnabledFlag, fmt.Sprintf("%v", c.Exporter.Stdout.Enabled)},
 		{ExporterPrometheusEnabledFlag, fmt.Sprintf("%v", c.Exporter.Prometheus.Enabled)},
 		{ExporterPrometheusDebugCollectors, strings.Join(c.Exporter.Prometheus.DebugCollectors, ", ")},
+		{ExporterPrometheusMetricsFlag, c.Exporter.Prometheus.MetricsLevel.String()},
 		{pprofEnabledFlag, fmt.Sprintf("%v", c.Debug.Pprof.Enabled)},
 		{KubeConfigFlag, fmt.Sprintf("%v", c.Kube.Config)},
 	}

config/config_test.go

@@ -12,6 +12,8 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/stretchr/testify/assert"
+	"github.com/sustainable-computing-io/kepler/internal/exporter/prometheus/metrics"
+	"gopkg.in/yaml.v3"
 	"k8s.io/utils/ptr"
 )
 
@@ -805,3 +807,63 @@ exporter:
 		assert.Equal(t, exp.String(), cfg.String())
 	})
 }
+
+func TestMetricsLevelYAMLMarshalling(t *testing.T) {
+	tests := []struct {
+		name         string
+		metricsLevel metrics.Level
+		expectedYAML string
+	}{
+		{
+			name:         "None",
+			metricsLevel: metrics.MetricsLevelNone,
+			expectedYAML: "none",
+		},
+		{
+			name:         "All",
+			metricsLevel: metrics.MetricsLevelAll,
+			expectedYAML: "all",
+		},
+		{
+			name:         "Node only",
+			metricsLevel: metrics.MetricsLevelNode,
+			expectedYAML: "node",
+		},
+		{
+			name:         "Pod and Node",
+			metricsLevel: metrics.MetricsLevelPod | metrics.MetricsLevelNode,
+			expectedYAML: "metricsLevel:\n    - node\n    - pod",
+		},
+		{
+			name:         "Node and Process",
+			metricsLevel: metrics.MetricsLevelNode | metrics.MetricsLevelProcess,
+			expectedYAML: "metricsLevel:\n    - node\n    - process",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cfg := DefaultConfig()
+			cfg.Exporter.Prometheus.MetricsLevel = tt.metricsLevel
+
+			// Marshal the prometheus exporter section
+			data, err := yaml.Marshal(cfg.Exporter.Prometheus)
+			assert.NoError(t, err)
+
+			yamlStr := string(data)
+
+			// Check that the YAML contains the expected metrics level representation
+			assert.Contains(t, yamlStr, tt.expectedYAML, "YAML should contain expected metrics level representation")
+
+			// Importantly, it should NOT contain the integer representation
+			integerStr := fmt.Sprintf("metricsLevel: %d", tt.metricsLevel)
+			assert.NotContains(t, yamlStr, integerStr, "YAML should not contain integer representation")
+
+			// Test round-trip: unmarshal back and verify it's the same
+			var unmarshaled PrometheusExporter
+			err = yaml.Unmarshal(data, &unmarshaled)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.metricsLevel, unmarshaled.MetricsLevel)
+		})
+	}
+}

hack/gen-metric-docs/main.go

@@ -15,6 +15,7 @@ import (
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/sustainable-computing-io/kepler/internal/exporter/prometheus/collector"
+	"github.com/sustainable-computing-io/kepler/internal/exporter/prometheus/metrics"
 	"github.com/sustainable-computing-io/kepler/internal/monitor"
 )
 
@@ -260,7 +261,7 @@ func main() {
 	fmt.Println("Creating collectors...")
 	// Create a logger for the collectors
 	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
-	powerCollector := collector.NewPowerCollector(mockMonitor, "test-node", logger)
+	powerCollector := collector.NewPowerCollector(mockMonitor, "test-node", logger, metrics.MetricsLevelAll)
 	fmt.Println("Created power collector")
 	buildInfoCollector := collector.NewKeplerBuildInfoCollector()
 	fmt.Println("Created build info collector")

internal/exporter/prometheus/collector/power_collector.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/prometheus/client_golang/prometheus"
+	"github.com/sustainable-computing-io/kepler/internal/exporter/prometheus/metrics"
 	"github.com/sustainable-computing-io/kepler/internal/monitor"
 )
 
@@ -20,8 +21,9 @@ type PowerDataProvider = monitor.PowerDataProvider
 // PowerCollector combines Node, Process, and Container collectors to ensure data consistency
 // by fetching all data in a single atomic operation during collection
 type PowerCollector struct {
-	pm     PowerDataProvider
-	logger *slog.Logger
+	pm           PowerDataProvider
+	logger       *slog.Logger
+	metricsLevel metrics.Level
 
 	// Lock to ensure thread safety during collection
 	mutex sync.RWMutex
@@ -95,7 +97,7 @@ func timeDesc(level, device, nodeName string, labels []string) *prometheus.Desc
 
 // NewPowerCollector creates a collector that provides consistent metrics
 // by fetching all data in a single snapshot during collection
-func NewPowerCollector(monitor PowerDataProvider, nodeName string, logger *slog.Logger) *PowerCollector {
+func NewPowerCollector(monitor PowerDataProvider, nodeName string, logger *slog.Logger, metricsLevel metrics.Level) *PowerCollector {
 	const (
 		// these labels should remain the same across all descriptors to ease querying
 		zone   = "zone"
@@ -105,8 +107,9 @@ func NewPowerCollector(monitor PowerDataProvider, nodeName string, logger *slog.
 	)
 
 	c := &PowerCollector{
-		pm:     monitor,
-		logger: logger.With("collector", "power"),
+		pm:           monitor,
+		logger:       logger.With("collector", "power"),
+		metricsLevel: metricsLevel,
 
 		nodeCPUJoulesDescriptor: joulesDesc("node", "cpu", nodeName, []string{zone, "path"}),
 		nodeCPUWattsDescriptor:  wattsDesc("node", "cpu", nodeName, []string{zone, "path"}),
@@ -151,33 +154,43 @@ func (c *PowerCollector) waitForData() {
 // Describe implements the prometheus.Collector interface
 func (c *PowerCollector) Describe(ch chan<- *prometheus.Desc) {
 	// node
-	ch <- c.nodeCPUJoulesDescriptor
-	ch <- c.nodeCPUWattsDescriptor
-	ch <- c.nodeCPUUsageRatioDescriptor
-	// node cpu active
-	ch <- c.nodeCPUActiveJoulesDesc
-	ch <- c.nodeCPUActiveWattsDesc
-	// node cpu idle
-	ch <- c.nodeCPUIdleJoulesDesc
-	ch <- c.nodeCPUIdleWattsDesc
+	if c.metricsLevel.IsNodeEnabled() {
+		ch <- c.nodeCPUJoulesDescriptor
+		ch <- c.nodeCPUWattsDescriptor
+		ch <- c.nodeCPUUsageRatioDescriptor
+		// node cpu active
+		ch <- c.nodeCPUActiveJoulesDesc
+		ch <- c.nodeCPUActiveWattsDesc
+		// node cpu idle
+		ch <- c.nodeCPUIdleJoulesDesc
+		ch <- c.nodeCPUIdleWattsDesc
+	}
 
 	// process
-	ch <- c.processCPUJoulesDescriptor
-	ch <- c.processCPUWattsDescriptor
-	ch <- c.processCPUTimeDescriptor
+	if c.metricsLevel.IsProcessEnabled() {
+		ch <- c.processCPUJoulesDescriptor
+		ch <- c.processCPUWattsDescriptor
+		ch <- c.processCPUTimeDescriptor
+	}
 
 	// container
-	ch <- c.containerCPUJoulesDescriptor
-	ch <- c.containerCPUWattsDescriptor
-	// ch <- c.containerCPUTimeDescriptor // TODO: add conntainerCPUTimeDescriptor
+	if c.metricsLevel.IsContainerEnabled() {
+		ch <- c.containerCPUJoulesDescriptor
+		ch <- c.containerCPUWattsDescriptor
+		// ch <- c.containerCPUTimeDescriptor // TODO: add conntainerCPUTimeDescriptor
+	}
 
 	// vm
-	ch <- c.vmCPUJoulesDescriptor
-	ch <- c.vmCPUWattsDescriptor
+	if c.metricsLevel.IsVMEnabled() {
+		ch <- c.vmCPUJoulesDescriptor
+		ch <- c.vmCPUWattsDescriptor
+	}
 
 	// pod
-	ch <- c.podCPUJoulesDescriptor
-	ch <- c.podCPUWattsDescriptor
+	if c.metricsLevel.IsPodEnabled() {
+		ch <- c.podCPUJoulesDescriptor
+		ch <- c.podCPUWattsDescriptor
+	}
 }
 
 func (c *PowerCollector) isReady() bool {
@@ -205,13 +218,26 @@ func (c *PowerCollector) Collect(ch chan<- prometheus.Metric) {
 		return
 	}
 
-	c.collectNodeMetrics(ch, snapshot.Node)
-	c.collectProcessMetrics(ch, "running", snapshot.Processes)
-	c.collectProcessMetrics(ch, "terminated", snapshot.TerminatedProcesses)
+	if c.metricsLevel.IsNodeEnabled() {
+		c.collectNodeMetrics(ch, snapshot.Node)
+	}
 
-	c.collectContainerMetrics(ch, snapshot.Containers)
-	c.collectVMMetrics(ch, snapshot.VirtualMachines)
-	c.collectPodMetrics(ch, snapshot.Pods)
+	if c.metricsLevel.IsProcessEnabled() {
+		c.collectProcessMetrics(ch, "running", snapshot.Processes)
+		c.collectProcessMetrics(ch, "terminated", snapshot.TerminatedProcesses)
+	}
+
+	if c.metricsLevel.IsContainerEnabled() {
+		c.collectContainerMetrics(ch, snapshot.Containers)
+	}
+
+	if c.metricsLevel.IsVMEnabled() {
+		c.collectVMMetrics(ch, snapshot.VirtualMachines)
+	}
+
+	if c.metricsLevel.IsPodEnabled() {
+		c.collectPodMetrics(ch, snapshot.Pods)
+	}
 }
 
 // collectNodeMetrics collects node-level power metrics