feat(cpuinfo): Added cpu info collector

  Added a collector for cpu info built in prometheus procfs

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

Author: vimalk78

go.mod

@@ -6,7 +6,9 @@ require (
 	github.com/alecthomas/kingpin/v2 v2.4.0
 	github.com/oklog/run v1.1.0
 	github.com/prometheus/client_golang v1.22.0
+	github.com/prometheus/client_model v0.6.1
 	github.com/prometheus/exporter-toolkit v0.14.0
+	github.com/prometheus/procfs v0.15.1
 	github.com/stretchr/testify v1.10.0
 	gopkg.in/yaml.v3 v3.0.1
 )
@@ -23,9 +25,7 @@ require (
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/prometheus/client_model v0.6.1 // indirect
 	github.com/prometheus/common v0.62.0 // indirect
-	github.com/prometheus/procfs v0.15.1 // indirect
 	github.com/stretchr/objx v0.5.2 // indirect
 	github.com/xhit/go-str2duration/v2 v2.1.0 // indirect
 	golang.org/x/crypto v0.32.0 // indirect

internal/exporter/prometheus/collectors/cpuinfo.go

@@ -0,0 +1,89 @@
+// SPDX-FileCopyrightText: 2025 The Kepler Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package collectors
+
+import (
+	"fmt"
+	"sync"
+
+	prom "github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/procfs"
+)
+
+// procFS is an interface for CPUInfo.
+type procFS interface {
+	CPUInfo() ([]procfs.CPUInfo, error)
+}
+
+type realProcFS struct {
+	fs procfs.FS
+}
+
+func (r *realProcFS) CPUInfo() ([]procfs.CPUInfo, error) {
+	return r.fs.CPUInfo()
+}
+
+func newProcFS(mountPoint string) (procFS, error) {
+	fs, err := procfs.NewFS(mountPoint)
+	if err != nil {
+		return nil, err
+	}
+	return &realProcFS{fs: fs}, nil
+}
+
+// cpuInfoCollector collects CPU info metrics from procfs.
+type cpuInfoCollector struct {
+	sync.Mutex
+
+	fs   procFS
+	desc *prom.Desc
+}
+
+// NewCPUInfoCollector creates a CPUInfoCollector using a procfs mount path.
+func NewCPUInfoCollector(procPath string) (*cpuInfoCollector, error) {
+	fs, err := newProcFS(procPath)
+	if err != nil {
+		return nil, fmt.Errorf("creating procfs failed: %w", err)
+	}
+	return newCPUInfoCollectorWithFS(fs), nil
+}
+
+// newCPUInfoCollectorWithFS injects a procFS interface
+func newCPUInfoCollectorWithFS(fs procFS) *cpuInfoCollector {
+	return &cpuInfoCollector{
+		fs: fs,
+		desc: prom.NewDesc(
+			prom.BuildFQName(namespace, "", "cpu_info"),
+			"CPU information from procfs",
+			[]string{"processor", "vendor_id", "model_name", "physical_id", "core_id"},
+			nil,
+		),
+	}
+}
+
+func (c *cpuInfoCollector) Describe(ch chan<- *prom.Desc) {
+	ch <- c.desc
+}
+
+func (c *cpuInfoCollector) Collect(ch chan<- prom.Metric) {
+	c.Lock()
+	defer c.Unlock()
+
+	cpuInfos, err := c.fs.CPUInfo()
+	if err != nil {
+		return
+	}
+	for _, ci := range cpuInfos {
+		ch <- prom.MustNewConstMetric(
+			c.desc,
+			prom.GaugeValue,
+			1,
+			fmt.Sprintf("%d", ci.Processor),
+			ci.VendorID,
+			ci.ModelName,
+			ci.PhysicalID,
+			ci.CoreID,
+		)
+	}
+}

internal/exporter/prometheus/collectors/cpuinfo_test.go

@@ -0,0 +1,189 @@
+// SPDX-FileCopyrightText: 2025 The Kepler Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package collectors
+
+import (
+	"errors"
+	"sync"
+	"testing"
+
+	"github.com/prometheus/client_golang/prometheus"
+	dto "github.com/prometheus/client_model/go"
+	"github.com/prometheus/procfs"
+	"github.com/stretchr/testify/assert"
+)
+
+// mockProcFS is a mock implementation of the procFS interface for testing.
+type mockProcFS struct {
+	cpuInfoFunc func() ([]procfs.CPUInfo, error)
+}
+
+func (m *mockProcFS) CPUInfo() ([]procfs.CPUInfo, error) {
+	return m.cpuInfoFunc()
+}
+
+// sampleCPUInfo returns a sample CPUInfo slice for testing.
+func sampleCPUInfo() []procfs.CPUInfo {
+	return []procfs.CPUInfo{
+		{
+			Processor:  0,
+			VendorID:   "GenuineIntel",
+			ModelName:  "Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz",
+			PhysicalID: "0",
+			CoreID:     "0",
+		},
+		{
+			Processor:  1,
+			VendorID:   "GenuineIntel",
+			ModelName:  "Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz",
+			PhysicalID: "0",
+			CoreID:     "1",
+		},
+	}
+}
+
+func expectedLabels() map[string]string {
+	return map[string]string{
+		"processor":   "",
+		"vendor_id":   "",
+		"model_name":  "",
+		"physical_id": "",
+		"core_id":     "",
+	}
+}
+
+// TestNewCPUInfoCollector tests the creation of a new CPUInfoCollector.
+func TestNewCPUInfoCollector(t *testing.T) {
+	// Test successful creation with a mock procfs
+	collector, err := NewCPUInfoCollector("/proc")
+	assert.NoError(t, err)
+	assert.NotNil(t, collector)
+	assert.NotNil(t, collector.fs)
+	assert.NotNil(t, collector.desc)
+}
+
+// TestNewCPUInfoCollectorWithFS tests the creation with an injected procFS.
+func TestNewCPUInfoCollectorWithFS(t *testing.T) {
+	mockFS := &mockProcFS{
+		cpuInfoFunc: func() ([]procfs.CPUInfo, error) {
+			return sampleCPUInfo(), nil
+		},
+	}
+	collector := newCPUInfoCollectorWithFS(mockFS)
+	assert.NotNil(t, collector)
+	assert.Equal(t, mockFS, collector.fs)
+	assert.NotNil(t, collector.desc)
+	assert.Contains(t, collector.desc.String(), "kepler_cpu_info")
+	assert.Contains(t, collector.desc.String(), "variableLabels: {processor,vendor_id,model_name,physical_id,core_id}")
+}
+
+// TestCPUInfoCollector_Describe tests the Describe method.
+func TestCPUInfoCollector_Describe(t *testing.T) {
+	mockFS := &mockProcFS{
+		cpuInfoFunc: func() ([]procfs.CPUInfo, error) {
+			return sampleCPUInfo(), nil
+		},
+	}
+	collector := newCPUInfoCollectorWithFS(mockFS)
+
+	ch := make(chan *prometheus.Desc, 1)
+	collector.Describe(ch)
+	close(ch)
+
+	desc := <-ch
+	assert.Equal(t, collector.desc, desc)
+}
+
+// TestCPUInfoCollector_Collect_Success tests the Collect method with valid CPU info.
+func TestCPUInfoCollector_Collect_Success(t *testing.T) {
+	mockFS := &mockProcFS{
+		cpuInfoFunc: func() ([]procfs.CPUInfo, error) {
+			return sampleCPUInfo(), nil
+		},
+	}
+	collector := newCPUInfoCollectorWithFS(mockFS)
+
+	ch := make(chan prometheus.Metric, 10)
+	collector.Collect(ch)
+	close(ch)
+
+	var metrics []prometheus.Metric
+	for m := range ch {
+		metrics = append(metrics, m)
+	}
+
+	assert.Len(t, metrics, 2, "expected two CPU info metrics")
+
+	el := expectedLabels()
+
+	for _, m := range metrics {
+		dtoMetric := &dto.Metric{}
+		err := m.Write(dtoMetric)
+		assert.NoError(t, err)
+		assert.NotNil(t, dtoMetric.Gauge)
+		assert.NotNil(t, dtoMetric.Gauge.Value)
+		assert.Equal(t, 1.0, *dtoMetric.Gauge.Value)
+		assert.NotNil(t, dtoMetric.Label)
+		for _, l := range dtoMetric.Label {
+			assert.NotNil(t, l.Name)
+			delete(el, *l.Name)
+		}
+	}
+	assert.Empty(t, el, "all expected labels not received")
+}
+
+// TestCPUInfoCollector_Collect_Error tests the Collect method when CPUInfo fails.
+func TestCPUInfoCollector_Collect_Error(t *testing.T) {
+	mockFS := &mockProcFS{
+		cpuInfoFunc: func() ([]procfs.CPUInfo, error) {
+			return nil, errors.New("failed to read CPU info")
+		},
+	}
+	collector := newCPUInfoCollectorWithFS(mockFS)
+
+	ch := make(chan prometheus.Metric, 10)
+	collector.Collect(ch)
+	close(ch)
+
+	var metrics []prometheus.Metric
+	for m := range ch {
+		metrics = append(metrics, m)
+	}
+
+	assert.Len(t, metrics, 0, "expected no metrics on error")
+}
+
+// TestCPUInfoCollector_Collect_Concurrency tests concurrent calls to Collect.
+func TestCPUInfoCollector_Collect_Concurrency(t *testing.T) {
+	mockFS := &mockProcFS{
+		cpuInfoFunc: func() ([]procfs.CPUInfo, error) {
+			return sampleCPUInfo(), nil
+		},
+	}
+	collector := newCPUInfoCollectorWithFS(mockFS)
+
+	const numGoroutines = 10
+	var wg sync.WaitGroup
+	ch := make(chan prometheus.Metric, numGoroutines*len(sampleCPUInfo()))
+
+	for i := 0; i < numGoroutines; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			collector.Collect(ch)
+		}()
+	}
+
+	wg.Wait()
+	close(ch)
+
+	var metrics []prometheus.Metric
+	for m := range ch {
+		metrics = append(metrics, m)
+	}
+
+	// Expect numGoroutines * number of CPUs metrics
+	expectedMetrics := numGoroutines * len(sampleCPUInfo())
+	assert.Equal(t, expectedMetrics, len(metrics), "expected metrics from all goroutines")
+}

internal/exporter/prometheus/prometheus.go

@@ -12,6 +12,7 @@ import (
 	prom "github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/collectors"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"github.com/sustainable-computing-io/kepler/config"
 	collector "github.com/sustainable-computing-io/kepler/internal/exporter/prometheus/collectors"
 	"github.com/sustainable-computing-io/kepler/internal/monitor"
 	"github.com/sustainable-computing-io/kepler/internal/service"
@@ -29,6 +30,7 @@ type APIRegistry interface {
 type Opts struct {
 	logger          *slog.Logger
 	debugCollectors map[string]bool
+	config          *config.Config
 }
 
 // DefaultOpts() returns a new Opts with defaults set
@@ -38,6 +40,7 @@ func DefaultOpts() Opts {
 		debugCollectors: map[string]bool{
 			"go": true,
 		},
+		config: config.DefaultConfig(),
 	}
 }
 
@@ -60,13 +63,20 @@ func WithDebugCollectors(c *[]string) OptionFn {
 	}
 }
 
+func WithConfig(config *config.Config) OptionFn {
+	return func(o *Opts) {
+		o.config = config
+	}
+}
+
 // Exporter exports power data to Prometheus
 type Exporter struct {
 	logger          *slog.Logger
 	monitor         Monitor
 	registry        *prom.Registry
 	server          APIRegistry
 	debugCollectors map[string]bool
+	config          *config.Config
 }
 
 var _ Service = (*Exporter)(nil)
@@ -78,15 +88,16 @@ func NewExporter(pm Monitor, s APIRegistry, applyOpts ...OptionFn) *Exporter {
 		apply(&opts)
 	}
 
-	monitor := &Exporter{
+	exporter := &Exporter{
 		monitor:         pm,
 		server:          s,
 		logger:          opts.logger.With("service", "prometheus"),
 		debugCollectors: opts.debugCollectors,
 		registry:        prom.NewRegistry(),
+		config:          opts.config,
 	}
 
-	return monitor
+	return exporter
 }
 
 func collectorForName(name string) (prom.Collector, error) {
@@ -118,7 +129,13 @@ func (e *Exporter) Start(ctx context.Context) error {
 	buildInfoCollector := collector.NewBuildInfoCollector()
 	e.registry.MustRegister(buildInfoCollector)
 
-	err := e.server.Register("/metrics", "Metrics", "Prometheus metrics",
+	cpuInfoCollector, err := collector.NewCPUInfoCollector(e.config.Host.ProcFS)
+	if err != nil {
+		return err
+	}
+	e.registry.MustRegister(cpuInfoCollector)
+
+	err = e.server.Register("/metrics", "Metrics", "Prometheus metrics",
 		promhttp.HandlerFor(
 			e.registry,
 			promhttp.HandlerOpts{