diff --git a/.github/workflows/unit_test.yml b/.github/workflows/unit_test.yml
index a36477fa0d..b4689a5480 100644
--- a/.github/workflows/unit_test.yml
+++ b/.github/workflows/unit_test.yml
@@ -27,17 +27,26 @@ jobs:
       env:
           GOPATH: /home/runner/go
           GOBIN: /home/runner/go/bin
-    - name: install libbpf
-      uses: sustainable-computing-io/kepler-action@v0.0.4
-      with:
-        ebpfprovider: libbpf
     - name: Prepare environment 
       run: |
-          sudo apt-get install -y cpuid
+          sudo apt-get install -y cpuid clang
           cd doc/ && sudo ./dev/prepare_dev_env.sh && cd - 
           git config --global --add safe.directory /kepler
+    - name: install libbpf
+      uses: sustainable-computing-io/kepler-action@v0.0.3
+      with:
+        ebpfprovider: libbpf
     - name: Run 
       run: |
+          sudo apt remove libbpf-dev
+          mkdir temp-libbpf
+          cd temp-libbpf
+          git clone https://github.com/libbpf/libbpf
+          cd libbpf/src
+          sudo make install_headers
+          sudo make install_uapi_headers
+          sudo prefix=/usr  BUILD_STATIC_ONLY=y make install
+          cd ../../../
           ATTACHER_TAG=libbpf make test-verbose
           go tool cover -func=coverage.out -o=coverage.out
     - name: Go Coverage Badge  # Pass the `coverage.out` output to this action
diff --git a/.golangci.yml b/.golangci.yml
index a5f791c0b9..59b42409a0 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -94,4 +94,4 @@ issues:
       text: "could not import C"
     - linters:
         - dupl
-      text: ".*pkg/collector/metric/types/types_test.go.*" # false positive, https://github.com/mibk/dupl/issues/20
\ No newline at end of file
+      text: ".*pkg/collector/stats/types/types_test.go.*" # false positive, https://github.com/mibk/dupl/issues/20
\ No newline at end of file
diff --git a/Makefile b/Makefile
index c54cf5b18a..0c200d808d 100644
--- a/Makefile
+++ b/Makefile
@@ -9,6 +9,7 @@ export TIMESTAMP ?=$(shell echo $(BIN_TIMESTAMP) | tr -d ':' | tr 'T' '-' | tr -
 # restrict included verify-* targets to only process project files
 SOURCE_GIT_TAG     := $(shell git describe --tags --always --abbrev=7 --match 'v*')
 SRC_ROOT           := $(shell pwd)
+ARCH               := $(shell arch)
 OUTPUT_DIR         := _output
 CROSS_BUILD_BINDIR := $(OUTPUT_DIR)/bin
 GIT_VERSION        := $(shell git describe --dirty --tags --always --match='v*')
diff --git a/README.md b/README.md
index f139ac192b..ce56f2220e 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,7 @@
 <img align="right" width="250px" src="https://user-images.githubusercontent.com/17484350/138557170-d8079b94-a517-4366-ade8-8d473e3f3f1d.jpg">
 
 ![GitHub Workflow Status (event)](https://img.shields.io/github/actions/workflow/status/sustainable-computing-io/kepler/unit_test.yml?branch=main&label=CI)
+
 ![Coverage](https://img.shields.io/badge/Coverage-42.1%25-yellow)
 [![OpenSSF Best Practices](https://bestpractices.coreinfrastructure.org/projects/7391/badge)](https://bestpractices.coreinfrastructure.org/projects/7391)
 <!--
diff --git a/bpfassets/bcc/bcc.c b/bpfassets/bcc/bcc.c
index 89d787a7d0..c85d44068f 100644
--- a/bpfassets/bcc/bcc.c
+++ b/bpfassets/bcc/bcc.c
@@ -215,7 +215,7 @@ int kprobe__finish_task_switch(struct pt_regs *ctx, struct task_struct *prev)
 #ifdef SET_GROUP_ID
     u64 cgroup_id = bpf_get_current_cgroup_id();
 #else
-    u64 cgroup_id = 0;
+    u64 cgroup_id = task->cgroups->subsys[0]->cgroup->id;
 #endif
 
     u64 cur_ts = bpf_ktime_get_ns();
diff --git a/bpfassets/libbpf/bpf.o/amd64_kepler.bpf.o b/bpfassets/libbpf/bpf.o/amd64_kepler.bpf.o
index 0812129110..69191b12a6 100644
Binary files a/bpfassets/libbpf/bpf.o/amd64_kepler.bpf.o and b/bpfassets/libbpf/bpf.o/amd64_kepler.bpf.o differ
diff --git a/bpfassets/libbpf/src/kepler.bpf.c b/bpfassets/libbpf/src/kepler.bpf.c
index c6fb1926a7..de01d121e7 100644
--- a/bpfassets/libbpf/src/kepler.bpf.c
+++ b/bpfassets/libbpf/src/kepler.bpf.c
@@ -225,6 +225,7 @@ int kepler_trace(struct sched_switch_args *ctx)
 
     u32 cur_pid = bpf_get_current_pid_tgid();
     u64 cgroup_id = bpf_get_current_cgroup_id(); // the cgroup id is the cgroup id of the running process (this is not next_pid or prev_pid)
+
     u64 cur_ts = bpf_ktime_get_ns();
     u32 cpu_id = bpf_get_smp_processor_id();
     u32 prev_pid = ctx->prev_pid;
diff --git a/cmd/exporter/exporter.go b/cmd/exporter/exporter.go
index 0dd76ffa31..fe8529113a 100644
--- a/cmd/exporter/exporter.go
+++ b/cmd/exporter/exporter.go
@@ -29,18 +29,16 @@ import (
 	"time"
 
 	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
 	"github.com/sustainable-computing-io/kepler/pkg/manager"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/qat"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components"
-	"github.com/sustainable-computing-io/kepler/pkg/power/platform"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/qat"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/platform"
 	kversion "github.com/sustainable-computing-io/kepler/pkg/version"
 
-	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
-	"github.com/prometheus/common/version"
 
 	"k8s.io/klog/v2"
 )
@@ -197,7 +195,7 @@ func main() {
 	components.InitPowerImpl()
 	platform.InitPowerImpl()
 
-	collector_metric.InitAvailableParamAndMetrics()
+	stats.InitAvailableParamAndMetrics()
 
 	if config.EnabledGPU {
 		klog.Infof("Initializing the GPU collector")
@@ -218,7 +216,7 @@ func main() {
 		}
 	}
 
-	if config.EnabledQAT {
+	if config.IsExposeQATMetricsEnabled() {
 		klog.Infof("Initializing the QAT collector")
 		err := qat.Init()
 		if err == nil {
@@ -229,9 +227,8 @@ func main() {
 	}
 
 	m := manager.New()
-	prometheus.MustRegister(version.NewCollector("kepler_exporter"))
-	prometheus.MustRegister(m.PrometheusCollector)
-	defer m.MetricCollector.Destroy()
+	reg := m.PrometheusCollector.RegisterMetrics()
+	defer m.StatsCollector.Destroy()
 	defer components.StopPower()
 
 	// starting a new gorotine to collect data and report metrics
@@ -242,7 +239,12 @@ func main() {
 	metricPathConfig := config.GetMetricPath(*metricsPath)
 	bindAddressConfig := config.GetBindAddress(*address)
 
-	http.Handle(metricPathConfig, promhttp.Handler())
+	http.Handle(metricPathConfig, promhttp.HandlerFor(
+		reg,
+		promhttp.HandlerOpts{
+			Registry: reg,
+		},
+	))
 	http.HandleFunc("/healthz", healthProbe)
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		_, err := w.Write([]byte(`<html>
diff --git a/cmd/validator/validator.go b/cmd/validator/validator.go
index 7af16c5f1d..3f4c43be89 100644
--- a/cmd/validator/validator.go
+++ b/cmd/validator/validator.go
@@ -29,9 +29,9 @@ import (
 	"time"
 
 	"github.com/jaypipes/ghw"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
-	"github.com/sustainable-computing-io/kepler/pkg/power/platform"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components/source"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/platform"
 )
 
 const (
diff --git a/e2e/integration-test/e2e_metric_test.go b/e2e/integration-test/e2e_metric_test.go
index 89769c9a48..879bc3e40c 100644
--- a/e2e/integration-test/e2e_metric_test.go
+++ b/e2e/integration-test/e2e_metric_test.go
@@ -93,6 +93,7 @@ func getEnvOrDefault(envName, defaultValue string) string {
 }
 
 var _ = Describe("Metrics check should pass", Ordered, func() {
+
 	var keplerMetric *TestKeplerMetric
 
 	_ = BeforeAll(func() {
@@ -177,7 +178,6 @@ var _ = Describe("Metrics check should pass", Ordered, func() {
 		Entry(nil, "kepler_node_core_joules_total"),     // node level check by instance
 		Entry(nil, "kepler_node_dram_joules_total"),     // node level check by instance
 		Entry(nil, "kepler_node_info"),                  // node level missing labels
-		Entry(nil, "kepler_node_other_joules_total"),    // node level check by instance
 		Entry(nil, "kepler_node_package_joules_total"),  // node levelcheck by instance
 		Entry(nil, "kepler_node_platform_joules_total"), // node levelcheck by instance
 		Entry(nil, "kepler_node_uncore_joules_total"),   // node levelcheck by instance
@@ -214,7 +214,6 @@ var _ = Describe("Metrics check should pass", Ordered, func() {
 		Entry(nil, "kepler_container_core_joules_total"),    // pod level
 		Entry(nil, "kepler_container_dram_joules_total"),    // pod level
 		Entry(nil, "kepler_container_joules_total"),         // pod level
-		Entry(nil, "kepler_container_other_joules_total"),   // pod level
 		Entry(nil, "kepler_container_package_joules_total"), // pod level
 		Entry(nil, "kepler_container_uncore_joules_total"),  // pod level
 	)
diff --git a/hack/cluster-deploy.sh b/hack/cluster-deploy.sh
index 5f22cd8306..1bdacc285d 100755
--- a/hack/cluster-deploy.sh
+++ b/hack/cluster-deploy.sh
@@ -40,10 +40,7 @@ build_manifest() {
 		return 0
 	}
 	header "Build Kepler Manifest"
-	run make build-manifest \
-		OPTS="$OPTS" \
-		IMAGE_REPO="$IMAGE_REPO" \
-		IMAGE_TAG="$IMAGE_TAG"
+	run make build-manifest OPTS="$OPTS"
 }
 
 build_kepler() {
diff --git a/pkg/bpfassets/attacher/bpf_perf.go b/pkg/bpfassets/attacher/bpf_perf.go
index 402933976a..9aa1d56b03 100644
--- a/pkg/bpfassets/attacher/bpf_perf.go
+++ b/pkg/bpfassets/attacher/bpf_perf.go
@@ -82,8 +82,8 @@ func getCounters() map[string]perfCounter {
 func GetEnabledBPFHWCounters() []string {
 	Counters = getCounters()
 	var metrics []string
-	klog.V(5).Infof("hardeware counter metrics config %t", config.ExposeHardwareCounterMetrics)
-	if !config.ExposeHardwareCounterMetrics {
+	klog.V(5).Infof("hardeware counter metrics config %t", config.IsHCMetricsEnabled())
+	if !config.IsHCMetricsEnabled() {
 		klog.V(5).Info("hardeware counter metrics not enabled")
 		return metrics
 	}
diff --git a/pkg/bpfassets/attacher/libbpf_attacher_stub.go b/pkg/bpfassets/attacher/libbpf_attacher_stub.go
index 0f9293a92f..b0eb315b16 100644
--- a/pkg/bpfassets/attacher/libbpf_attacher_stub.go
+++ b/pkg/bpfassets/attacher/libbpf_attacher_stub.go
@@ -30,6 +30,9 @@ const (
 var libbpfCounters = map[string]perfCounter{}
 
 func attachLibbpfModule() (interface{}, error) {
+	if LibbpfBuilt {
+		return nil, nil
+	}
 	return nil, fmt.Errorf("no libbpf build tag")
 }
 
diff --git a/pkg/cgroup/cgroup_interface.go b/pkg/cgroup/cgroup_interface.go
index a27e80088e..a5c2e8ec0b 100644
--- a/pkg/cgroup/cgroup_interface.go
+++ b/pkg/cgroup/cgroup_interface.go
@@ -16,7 +16,7 @@ limitations under the License.
 
 package cgroup
 
-import "github.com/sustainable-computing-io/kepler/pkg/collector/metric/types"
+import "github.com/sustainable-computing-io/kepler/pkg/collector/stats/types"
 
 type CCgroupStatHandler interface {
 	SetCGroupStat(containerID string, CgroupStatMap map[string]*types.UInt64StatCollection) error
diff --git a/pkg/cgroup/cgroup_stats_linux.go b/pkg/cgroup/cgroup_stats_linux.go
index b2b152a43f..5a45cef0cb 100644
--- a/pkg/cgroup/cgroup_stats_linux.go
+++ b/pkg/cgroup/cgroup_stats_linux.go
@@ -28,7 +28,7 @@ import (
 	"github.com/opencontainers/runc/libcontainer/cgroups/fs2"
 	"github.com/opencontainers/runc/libcontainer/configs"
 
-	"github.com/sustainable-computing-io/kepler/pkg/collector/metric/types"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats/types"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
 )
 
diff --git a/pkg/cgroup/resolve_container.go b/pkg/cgroup/resolve_container.go
index b2b79d9458..5f02fe676d 100644
--- a/pkg/cgroup/resolve_container.go
+++ b/pkg/cgroup/resolve_container.go
@@ -76,23 +76,22 @@ func GetContainerID(cGroupID, pid uint64, withCGroupID bool) (string, error) {
 	return info.ContainerID, err
 }
 
-func GetContainerMetrics() (containerCPU, containerMem map[string]float64, retErr error) {
-	return podLister.ListMetrics()
-}
-
-func GetAvailableKubeletMetrics() []string {
-	return podLister.GetAvailableMetrics()
-}
-
 func GetContainerInfo(cGroupID, pid uint64, withCGroupID bool) (*ContainerInfo, error) {
 	var err error
 	var containerID string
 
+	name := utils.SystemProcessName
+	namespace := utils.SystemProcessNamespace
+	if cGroupID == 1 {
+		// some kernel processes have cgroup id equal 1 or 0
+		name = utils.KernelProcessName
+		namespace = utils.KernelProcessNamespace
+	}
 	info := &ContainerInfo{
-		ContainerID:   utils.SystemProcessName,
-		ContainerName: utils.SystemProcessName,
-		PodName:       utils.SystemProcessName,
-		Namespace:     utils.SystemProcessNamespace,
+		ContainerID:   name,
+		ContainerName: name,
+		PodName:       name,
+		Namespace:     namespace,
 	}
 
 	if containerID, err = getContainerIDFromPath(cGroupID, pid, withCGroupID); err != nil {
@@ -113,6 +112,9 @@ func ParseContainerIDFromPodStatus(containerID string) string {
 }
 
 func getContainerIDFromPath(cGroupID, pid uint64, withCGroupID bool) (string, error) {
+	if cGroupID == 1 {
+		return utils.KernelProcessName, nil
+	}
 	var err error
 	var containerID string
 	if withCGroupID {
diff --git a/pkg/collector/container_accelerator_collector.go b/pkg/collector/container_accelerator_collector.go
deleted file mode 100644
index 5b8c564123..0000000000
--- a/pkg/collector/container_accelerator_collector.go
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-Copyright 2021.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package collector
-
-import (
-	"time"
-
-	"github.com/sustainable-computing-io/kepler/pkg/cgroup"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
-	gpu_source "github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu/source"
-	"k8s.io/klog/v2"
-)
-
-var (
-	// lastUtilizationTimestamp represents the CPU timestamp in microseconds at which utilization samples were last read
-	lastUtilizationTimestamp time.Time = time.Now()
-)
-
-// updateBPFMetrics reads the BPF tables with process/pid/cgroupid metrics (CPU time, available HW counters)
-func (c *Collector) updateGPUMetrics() {
-	var err error
-	var processesUtilization map[uint32]gpu_source.ProcessUtilizationSample
-	// calculate the gpu's processes energy consumption for each gpu
-	for _, device := range gpu.GetGpus() {
-		if processesUtilization, err = gpu.GetProcessResourceUtilizationPerDevice(device, time.Since(lastUtilizationTimestamp)); err != nil {
-			klog.Infoln(err)
-			continue
-		}
-
-		var containerID string
-		for pid, processUtilization := range processesUtilization {
-			if containerID, err = cgroup.GetContainerIDFromPID(uint64(pid)); err != nil {
-				klog.V(5).Infof("failed to resolve container for Pid %v: %v, set containerID=%s", pid, err, c.systemProcessName)
-				containerID = c.systemProcessName
-			}
-
-			c.createContainersMetricsIfNotExist(containerID, 0, uint64(pid), false)
-			if config.EnableProcessMetrics {
-				c.createProcessMetricsIfNotExist(uint64(pid), "")
-			}
-
-			// When a container or pod is deleted, the associated process data may still exist for some time. However, the createContainersMetricsIfNotExist function
-			// will not create an entry in the c.ContainersMetrics map if the container or pod no longer exists. Therefore, even if the function attempted to initialize
-			// the map with the deleted containerID, it may not have been added to the map due to the absence of container information. As a result, these processes
-			// may be classified as system processes rather than being attributed to the deleted container or pod.
-			if _, exist := c.ContainersMetrics[containerID]; !exist {
-				continue
-			}
-
-			if err = c.ContainersMetrics[containerID].BPFStats[config.GPUSMUtilization].AddNewDelta(uint64(processUtilization.SmUtil)); err != nil {
-				klog.V(5).Infoln(err)
-			}
-			if err = c.ContainersMetrics[containerID].BPFStats[config.GPUMemUtilization].AddNewDelta(uint64(processUtilization.MemUtil)); err != nil {
-				klog.V(5).Infoln(err)
-			}
-
-			if containerID == c.systemProcessName && config.EnableProcessMetrics {
-				// update process metrics
-				if err = c.ProcessMetrics[uint64(pid)].BPFStats[config.GPUSMUtilization].AddNewDelta(uint64(processUtilization.SmUtil)); err != nil {
-					klog.V(5).Infoln(err)
-				}
-				if err = c.ProcessMetrics[uint64(pid)].BPFStats[config.GPUMemUtilization].AddNewDelta(uint64(processUtilization.MemUtil)); err != nil {
-					klog.V(5).Infoln(err)
-				}
-			}
-		}
-	}
-
-	lastUtilizationTimestamp = time.Now()
-}
diff --git a/pkg/collector/container_energy_collector.go b/pkg/collector/container_energy_collector.go
deleted file mode 100644
index 614f061ba4..0000000000
--- a/pkg/collector/container_energy_collector.go
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
-Copyright 2021.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package collector
-
-import (
-	"github.com/sustainable-computing-io/kepler/pkg/model"
-)
-
-// updateContainerEnergy matches the container resource usage with the node energy consumption
-func (c *Collector) updateContainerEnergy() {
-	model.UpdateContainerEnergy(c.ContainersMetrics, &c.NodeMetrics)
-}
diff --git a/pkg/collector/container_hc_collector.go b/pkg/collector/container_hc_collector.go
deleted file mode 100644
index 6eeb0920c9..0000000000
--- a/pkg/collector/container_hc_collector.go
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
-Copyright 2021.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package collector
-
-import (
-	"strconv"
-	"unsafe"
-
-	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
-	"github.com/sustainable-computing-io/kepler/pkg/cgroup"
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/libvirt"
-
-	"k8s.io/klog/v2"
-)
-
-// #define CPU_VECTOR_SIZE 128
-import "C"
-
-type ProcessBPFMetrics = attacher.ProcessBPFMetrics
-
-// updateSWCounters
-func (c *Collector) updateSWCounters(containerID string, ct *ProcessBPFMetrics, isSystemProcess, isSystemVM bool) {
-	// update ebpf metrics
-	// first update CPU time and Page Cache Hit
-	err := c.ContainersMetrics[containerID].BPFStats[config.CPUTime].AddNewDelta(ct.ProcessRunTime)
-	if err != nil {
-		klog.V(5).Infoln(err)
-	}
-	err = c.ContainersMetrics[containerID].BPFStats[config.PageCacheHit].AddNewDelta(ct.PageCacheHit / 1000)
-	if err != nil {
-		klog.V(5).Infoln(err)
-	}
-
-	// update IRQ vector. Soft IRQ events has the events ordered
-	for i, event := range attacher.SoftIRQEvents {
-		err := c.ContainersMetrics[containerID].BPFStats[event].AddNewDelta(uint64(ct.VecNR[i]))
-		if err != nil {
-			klog.V(5).Infoln(err)
-		}
-	}
-	// track system process metrics
-	if isSystemProcess && config.EnableProcessMetrics {
-		for i, event := range attacher.SoftIRQEvents {
-			err := c.ProcessMetrics[ct.PID].BPFStats[event].AddNewDelta(uint64(ct.VecNR[i]))
-			if err != nil {
-				klog.V(5).Infoln(err)
-			}
-		}
-	}
-	// track virtual machine metrics
-	// TODO: remove duplicated code, we don;t need to have a map with duplicated data for VMs
-	if isSystemVM && config.EnableProcessMetrics {
-		for _, event := range attacher.SoftIRQEvents {
-			c.VMMetrics[ct.PID].BPFStats[event] = c.ProcessMetrics[ct.PID].BPFStats[event]
-		}
-	}
-}
-
-// updateHWCounters
-func (c *Collector) updateHWCounters(containerID string, ct *ProcessBPFMetrics, isSystemProcess, isSystemVM bool) {
-	// update HW counters
-	for _, counterKey := range collector_metric.AvailableBPFHWCounters {
-		var val uint64
-		switch counterKey {
-		case attacher.CPUCycleLabel:
-			val = ct.CPUCycles
-		case attacher.CPUInstructionLabel:
-			val = ct.CPUInstr
-		case attacher.CacheMissLabel:
-			val = ct.CacheMisses
-		default:
-			val = 0
-		}
-		err := c.ContainersMetrics[containerID].BPFStats[counterKey].AddNewDelta(val)
-		if err != nil {
-			klog.V(5).Infoln(err)
-		}
-		// track system process metrics
-		if isSystemProcess && config.EnableProcessMetrics {
-			err := c.ProcessMetrics[ct.PID].BPFStats[counterKey].AddNewDelta(val)
-			if err != nil {
-				klog.V(5).Infoln(err)
-			}
-		}
-		// track virtual machine metrics
-		// TODO: remove VMMetrics and ContainersMetrics, we should keep only ProcessMetrics to avoid data and code duplication for efficiency and consistency
-		if isSystemVM && config.EnableProcessMetrics {
-			c.VMMetrics[ct.PID].BPFStats = c.ProcessMetrics[ct.PID].BPFStats
-		}
-	}
-}
-
-// updateBPFMetrics reads the BPF tables with process/pid/cgroupid metrics (CPU time, available HW counters)
-func (c *Collector) updateBPFMetrics() {
-	foundContainer := make(map[string]bool)
-	foundProcess := make(map[uint64]bool)
-	foundVM := make(map[uint64]bool)
-	processesData, err := attacher.CollectProcesses()
-	vmPIDList, _ := libvirt.GetCurrentVMPID()
-	if err != nil {
-		return
-	}
-	// TODO(mamaral): instead of aggregate the process data per container ID, keep the data per cgroup, so that we can show cgroup metrics of system processes
-	// this will also help to expose metrics per processes without code duplication
-	for _, ct := range processesData {
-		comm := C.GoString((*C.char)(unsafe.Pointer(&ct.Command)))
-		containerID, err := cgroup.GetContainerID(ct.CGroupID, ct.PID, config.EnabledEBPFCgroupID)
-		if err != nil {
-			klog.V(5).Infof("failed to resolve container for cGroup ID %v (command=%s): %v, set containerID=%s", ct.CGroupID, comm, err, c.systemProcessName)
-		}
-		c.createContainersMetricsIfNotExist(containerID, ct.CGroupID, ct.PID, config.EnabledEBPFCgroupID)
-
-		// System process is the aggregation of all background process running outside kubernetes
-		// this means that the list of process might be very large, so we will not add this information to the cache
-		isSystemProcess := containerID == c.systemProcessName
-		if !isSystemProcess {
-			c.ContainersMetrics[containerID].SetLatestProcess(ct.CGroupID, ct.PID, comm)
-		} else if config.EnableProcessMetrics {
-			c.createProcessMetricsIfNotExist(ct.PID, comm)
-			err := c.ProcessMetrics[ct.PID].BPFStats[config.CPUTime].AddNewDelta(ct.ProcessRunTime)
-			if err != nil {
-				klog.V(5).Infoln(err)
-			}
-			for vmpid, name := range vmPIDList {
-				pid, _ := strconv.ParseUint(vmpid, 10, 64)
-
-				if pid == ct.PID {
-					c.createVMMetricsIfNotExist(ct.PID, name)
-					foundVM[pid] = true
-					c.VMMetrics[ct.PID].BPFStats = c.ProcessMetrics[ct.PID].BPFStats
-				}
-			}
-		}
-
-		c.ContainersMetrics[containerID].CurrProcesses++
-
-		c.updateSWCounters(containerID, &ct, isSystemProcess, foundVM[ct.PID])
-		c.updateHWCounters(containerID, &ct, isSystemProcess, foundVM[ct.PID])
-
-		// TODO: improve the removal of deleted containers from ContainersMetrics. Currently we verify the maxInactiveContainers using the foundContainer map
-		foundContainer[containerID] = true
-		if isSystemProcess {
-			foundProcess[ct.PID] = true
-		}
-	}
-	c.handleInactiveContainers(foundContainer)
-	if config.EnableProcessMetrics {
-		c.handleInactiveProcesses(foundProcess)
-		c.handleInactiveVM(foundVM)
-	}
-}
-
-// handleInactiveContainers
-func (c *Collector) handleInactiveContainers(foundContainer map[string]bool) {
-	numOfInactive := len(c.ContainersMetrics) - len(foundContainer)
-	if numOfInactive > maxInactiveContainers {
-		aliveContainers, err := cgroup.GetAliveContainers()
-		if err != nil {
-			klog.V(5).Infoln(err)
-			return
-		}
-		for containerID := range c.ContainersMetrics {
-			if containerID == c.systemProcessName {
-				continue
-			}
-			if _, found := aliveContainers[containerID]; !found {
-				delete(c.ContainersMetrics, containerID)
-			}
-		}
-	}
-}
-
-// handleInactiveProcesses
-func (c *Collector) handleInactiveProcesses(foundProcess map[uint64]bool) {
-	numOfInactive := len(c.ProcessMetrics) - len(foundProcess)
-	if numOfInactive > maxInactiveProcesses {
-		for pid := range c.ProcessMetrics {
-			if _, found := foundProcess[pid]; !found {
-				delete(c.ProcessMetrics, pid)
-			}
-		}
-	}
-}
-
-// handleInactiveVirtualMachine
-func (c *Collector) handleInactiveVM(foundVM map[uint64]bool) {
-	numOfInactive := len(c.VMMetrics) - len(foundVM)
-	if numOfInactive > maxInactiveVM {
-		for pid := range c.VMMetrics {
-			if _, found := foundVM[pid]; !found {
-				delete(c.VMMetrics, pid)
-			}
-		}
-	}
-}
diff --git a/pkg/collector/energy/node_energy_collector.go b/pkg/collector/energy/node_energy_collector.go
new file mode 100644
index 0000000000..9742c90da2
--- /dev/null
+++ b/pkg/collector/energy/node_energy_collector.go
@@ -0,0 +1,108 @@
+/*
+Copyright 2021.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package energy
+
+import (
+	"fmt"
+	"strconv"
+	"sync"
+
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/model"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/platform"
+
+	"k8s.io/klog/v2"
+)
+
+// UpdatePlatformEnergy updates the node platform power consumption, i.e, the node total power consumption
+func UpdatePlatformEnergy(nodeStats *stats.NodeStats) {
+	if platform.IsSystemCollectionSupported() {
+		nodePlatformEnergy, _ := platform.GetAbsEnergyFromPlatform()
+		for sourceID, energy := range nodePlatformEnergy {
+			nodeStats.EnergyUsage[config.AbsEnergyInPlatform].SetAggrStat(sourceID, uint64(energy))
+		}
+	} else if model.IsNodePlatformPowerModelEnabled() {
+		model.UpdateNodePlatformEnergy(nodeStats)
+	}
+}
+
+// UpdateNodeComponentsEnergy updates each node component power consumption, i.e., the CPU core, uncore, package/socket and DRAM
+func UpdateNodeComponentsEnergy(nodeStats *stats.NodeStats, wg *sync.WaitGroup) {
+	defer wg.Done()
+	if components.IsSystemCollectionSupported() {
+		nodeComponentsEnergy := components.GetAbsEnergyFromNodeComponents()
+		// the RAPL metrics return counter metrics not gauge
+		for socket, energy := range nodeComponentsEnergy {
+			strID := strconv.Itoa(socket)
+			nodeStats.EnergyUsage[config.AbsEnergyInPkg].SetAggrStat(strID, energy.Pkg)
+			nodeStats.EnergyUsage[config.AbsEnergyInCore].SetAggrStat(strID, energy.Core)
+			nodeStats.EnergyUsage[config.AbsEnergyInUnCore].SetAggrStat(strID, energy.Uncore)
+			nodeStats.EnergyUsage[config.AbsEnergyInDRAM].SetAggrStat(strID, energy.DRAM)
+		}
+	} else if model.IsNodeComponentPowerModelEnabled() {
+		model.UpdateNodeComponentEnergy(nodeStats)
+	} else {
+		klog.V(5).Info("No nodeComponentsEnergy found, node components energy metrics is not exposed ")
+	}
+}
+
+// UpdateNodeGPUEnergy updates each GPU power consumption. Right now we don't support other types of accelerators
+func UpdateNodeGPUEnergy(nodeStats *stats.NodeStats, wg *sync.WaitGroup) {
+	defer wg.Done()
+	if config.EnabledGPU {
+		gpuEnergy := gpu.GetAbsEnergyFromGPU()
+		for gpu, energy := range gpuEnergy {
+			nodeStats.EnergyUsage[config.AbsEnergyInGPU].SetDeltaStat(fmt.Sprintf("%d", gpu), uint64(energy))
+		}
+	}
+}
+
+// UpdateNodeIdleEnergy calculates the node idle energy consumption based on the minimum power consumption when real-time system power metrics are accessible.
+// When the node power model estimator is utilized, the idle power is updated with the estimated power considering minimal resource utilization.
+func UpdateNodeIdleEnergy(nodeStats *stats.NodeStats) {
+	isComponentsSystemCollectionSupported := components.IsSystemCollectionSupported()
+	// the idle energy is only updated if we find the node using less resources than previously observed
+	// TODO: Use regression to estimate the idle power when real-time system power metrics are available, instead of relying on the minimum power consumption.
+	nodeStats.UpdateIdleEnergyWithMinValue(isComponentsSystemCollectionSupported)
+	if !isComponentsSystemCollectionSupported {
+		// if power collection on components is not supported, try using estimator to update idle energy
+		if model.IsNodeComponentPowerModelEnabled() {
+			model.UpdateNodeComponentIdleEnergy(nodeStats)
+		}
+		if model.IsNodePlatformPowerModelEnabled() {
+			model.UpdateNodePlatformIdleEnergy(nodeStats)
+		}
+	}
+}
+
+// UpdateNodeEnergyMetrics updates the node energy consumption of each component
+func UpdateNodeEnergyMetrics(nodeStats *stats.NodeStats) {
+	var wgNode sync.WaitGroup
+	wgNode.Add(2)
+	go UpdateNodeComponentsEnergy(nodeStats, &wgNode)
+	go UpdateNodeGPUEnergy(nodeStats, &wgNode)
+	wgNode.Wait()
+	// update platform power later to avoid race condition when using estimation power model
+	UpdatePlatformEnergy(nodeStats)
+	// after updating the total energy we calculate the idle, dynamic and other components energy
+	UpdateNodeIdleEnergy(nodeStats)
+	nodeStats.UpdateDynEnergy()
+	nodeStats.SetNodeOtherComponentsEnergy()
+}
diff --git a/pkg/collector/process_energy_collector.go b/pkg/collector/energy/process_energy_collector.go
similarity index 68%
rename from pkg/collector/process_energy_collector.go
rename to pkg/collector/energy/process_energy_collector.go
index db9f6d89a0..c57f730b63 100644
--- a/pkg/collector/process_energy_collector.go
+++ b/pkg/collector/energy/process_energy_collector.go
@@ -14,13 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package collector
+package energy
 
 import (
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
 	"github.com/sustainable-computing-io/kepler/pkg/model"
 )
 
-// updateProcessEnergy matches the process resource usage with the node energy consumption
-func (c *Collector) updateProcessEnergy() {
-	model.UpdateProcessEnergy(c.ProcessMetrics, &c.NodeMetrics)
+// UpdateProcessEnergy matches the process resource usage with the node energy consumption
+func UpdateProcessEnergy(processStats map[uint64]*stats.ProcessStats, nodeStats *stats.NodeStats) {
+	model.UpdateProcessEnergy(processStats, nodeStats)
 }
diff --git a/pkg/collector/metric/benchmark_test.go b/pkg/collector/metric/benchmark_test.go
deleted file mode 100644
index 3b5e2d2cbb..0000000000
--- a/pkg/collector/metric/benchmark_test.go
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-Copyright 2023.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package metric_test
-
-import (
-	"strconv"
-	"testing"
-
-	"github.com/sustainable-computing-io/kepler/pkg/collector/metric"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-)
-
-func benchmarkNtesting(b *testing.B, containerNumber int) {
-	metric.AvailableBPFSWCounters = []string{
-		config.CPUTime,
-	}
-	var containerMetrics map[string]*metric.ContainerMetrics
-	nodeMetrics := metric.NewNodeMetrics()
-	containerMetrics = make(map[string]*metric.ContainerMetrics)
-	for i := 0; i < containerNumber; i++ {
-		containerMetrics["container"+strconv.Itoa(i)] = createMockContainerMetrics("container"+strconv.Itoa(i), "podA", "test")
-	}
-	b.ReportAllocs()
-	b.ResetTimer()
-	nodeMetrics.AddNodeResUsageFromContainerResUsage(containerMetrics)
-	b.StopTimer()
-}
-
-func BenchmarkAddNodeResUsageFromContainerResUsageWith1000Contianer(b *testing.B) {
-	benchmarkNtesting(b, 1000)
-}
-
-func BenchmarkAddNodeResUsageFromContainerResUsageWith2000Contianer(b *testing.B) {
-	benchmarkNtesting(b, 2000)
-}
-
-func BenchmarkAddNodeResUsageFromContainerResUsageWith5000Contianer(b *testing.B) {
-	benchmarkNtesting(b, 5000)
-}
-
-func BenchmarkAddNodeResUsageFromContainerResUsageWith10000Contianer(b *testing.B) {
-	benchmarkNtesting(b, 10000)
-}
-
-// see usageMetrics for the list of used metrics. For the sake of visibility we add all metrics, but only few of them will be used.
-func createMockContainerMetrics(containerName, podName, namespace string) *metric.ContainerMetrics {
-	containerMetrics := metric.NewContainerMetrics(containerName, podName, namespace, containerName)
-	// bpf - cpu time
-	_ = containerMetrics.BPFStats[config.CPUTime].AddNewDelta(30000) // config.CPUTime
-	return containerMetrics
-}
diff --git a/pkg/collector/metric/container_metric.go b/pkg/collector/metric/container_metric.go
deleted file mode 100644
index 95f99ce83c..0000000000
--- a/pkg/collector/metric/container_metric.go
+++ /dev/null
@@ -1,279 +0,0 @@
-/*
-Copyright 2021.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package metric
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/sustainable-computing-io/kepler/pkg/cgroup"
-	"github.com/sustainable-computing-io/kepler/pkg/collector/metric/types"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
-	"k8s.io/klog/v2"
-)
-
-var (
-	// ContainerFloatFeatureNames holds the feature name of the container float collector_metric. This is specific for the machine-learning based models.
-	ContainerFloatFeatureNames []string = []string{}
-	// ContainerUintFeaturesNames holds the feature name of the container utint collector_metric. This is specific for the machine-learning based models.
-	ContainerUintFeaturesNames []string = []string{}
-	// ContainerFeaturesNames holds all the feature name of the container collector_metric. This is specific for the machine-learning based models.
-	ContainerFeaturesNames []string = []string{}
-)
-
-type ContainerMetrics struct {
-	ProcessMetrics
-
-	CGroupPID     uint64
-	PIDS          []uint64
-	ContainerName string
-	PodName       string
-	Namespace     string
-	ContainerID   string
-
-	CurrProcesses int
-
-	CgroupStatHandler cgroup.CCgroupStatHandler
-	CgroupStatMap     map[string]*types.UInt64StatCollection
-}
-
-// NewContainerMetrics creates a new ContainerMetrics instance
-func NewContainerMetrics(containerName, podName, podNamespace, containerID string) *ContainerMetrics {
-	c := &ContainerMetrics{
-		PodName:       podName,
-		ContainerName: containerName,
-		Namespace:     podNamespace,
-		ContainerID:   containerID,
-		ProcessMetrics: ProcessMetrics{
-			BPFStats:             make(map[string]*types.UInt64Stat),
-			DynEnergyInCore:      &types.UInt64Stat{},
-			DynEnergyInDRAM:      &types.UInt64Stat{},
-			DynEnergyInUncore:    &types.UInt64Stat{},
-			DynEnergyInPkg:       &types.UInt64Stat{},
-			DynEnergyInOther:     &types.UInt64Stat{},
-			DynEnergyInGPU:       &types.UInt64Stat{},
-			DynEnergyInPlatform:  &types.UInt64Stat{},
-			IdleEnergyInCore:     &types.UInt64Stat{},
-			IdleEnergyInDRAM:     &types.UInt64Stat{},
-			IdleEnergyInUncore:   &types.UInt64Stat{},
-			IdleEnergyInPkg:      &types.UInt64Stat{},
-			IdleEnergyInOther:    &types.UInt64Stat{},
-			IdleEnergyInGPU:      &types.UInt64Stat{},
-			IdleEnergyInPlatform: &types.UInt64Stat{},
-		},
-		CgroupStatMap: make(map[string]*types.UInt64StatCollection),
-	}
-	for _, metricName := range AvailableBPFSWCounters {
-		c.BPFStats[metricName] = &types.UInt64Stat{}
-	}
-	for _, metricName := range AvailableBPFHWCounters {
-		c.BPFStats[metricName] = &types.UInt64Stat{}
-	}
-	// TODO: transparently list the other metrics and do not initialize them when they are not supported, e.g. HC
-	if gpu.IsGPUCollectionSupported() {
-		c.BPFStats[config.GPUSMUtilization] = &types.UInt64Stat{}
-		c.BPFStats[config.GPUMemUtilization] = &types.UInt64Stat{}
-	}
-	for _, metricName := range AvailableCGroupMetrics {
-		c.CgroupStatMap[metricName] = &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		}
-	}
-	return c
-}
-
-// ResetCurr reset all current value to 0
-func (c *ContainerMetrics) ResetDeltaValues() {
-	c.CurrProcesses = 0
-	c.PIDS = c.PIDS[:0]
-	for counterKey := range c.BPFStats {
-		c.BPFStats[counterKey].ResetDeltaValues()
-	}
-	for cgroupFSKey := range c.CgroupStatMap {
-		c.CgroupStatMap[cgroupFSKey].ResetDeltaValues()
-	}
-	c.DynEnergyInCore.ResetDeltaValues()
-	c.DynEnergyInDRAM.ResetDeltaValues()
-	c.DynEnergyInUncore.ResetDeltaValues()
-	c.DynEnergyInPkg.ResetDeltaValues()
-	c.DynEnergyInOther.ResetDeltaValues()
-	c.DynEnergyInGPU.ResetDeltaValues()
-	c.DynEnergyInPlatform.ResetDeltaValues()
-	c.IdleEnergyInCore.ResetDeltaValues()
-	c.IdleEnergyInDRAM.ResetDeltaValues()
-	c.IdleEnergyInUncore.ResetDeltaValues()
-	c.IdleEnergyInPkg.ResetDeltaValues()
-	c.IdleEnergyInOther.ResetDeltaValues()
-	c.IdleEnergyInGPU.ResetDeltaValues()
-	c.IdleEnergyInPlatform.ResetDeltaValues()
-}
-
-// SetLatestProcess set cgroupPID, PID, and command to the latest captured process
-// NOTICE: can lose main container info for multi-container pod
-func (c *ContainerMetrics) SetLatestProcess(cgroupPID, pid uint64, comm string) {
-	c.CGroupPID = cgroupPID
-
-	// TODO: review if we can remove the PIDS list as it's for GPU consumption and likely will remove this dependency
-	notexist := true
-	for _, v := range c.PIDS {
-		if v == pid {
-			notexist = false
-		}
-	}
-	if notexist {
-		c.PIDS = append(c.PIDS, pid)
-	}
-
-	c.Command = comm
-}
-
-// getFloatCurrAndAggrValue return curr, aggr float64 values of specific uint metric
-func (c *ContainerMetrics) getFloatCurrAndAggrValue(metric string) (curr, aggr float64, err error) {
-	// TO-ADD
-	return 0, 0, nil
-}
-
-// getIntDeltaAndAggrValue return curr, aggr uint64 values of specific uint metric
-func (c *ContainerMetrics) getIntDeltaAndAggrValue(metric string) (curr, aggr uint64, err error) {
-	if val, exists := c.BPFStats[metric]; exists {
-		return val.Delta, val.Aggr, nil
-	}
-	if val, exists := c.CgroupStatMap[metric]; exists {
-		return val.SumAllDeltaValues(), val.SumAllAggrValues(), nil
-	}
-	klog.V(4).Infof("cannot extract: %s", metric)
-	return 0, 0, fmt.Errorf("cannot extract: %s", metric)
-}
-
-// ToEstimatorValues return values regarding metricNames.
-// Since Kepler collects metrics at intervals of SamplePeriodSec, which is greater than 1 second, and the power models are trained to estimate power in 1 second interval.
-// It is necessary to normalize the resource utilization by the SamplePeriodSec. Note that this is important because the power curve can be different for higher or lower resource usage within 1 second interval.
-func (c *ContainerMetrics) ToEstimatorValues(featuresName []string, shouldNormalize bool) (values []float64) {
-	for _, metric := range featuresName {
-		curr, _, _ := c.getIntDeltaAndAggrValue(metric)
-		values = append(values, normalize(float64(curr), shouldNormalize))
-	}
-	return
-}
-
-// ToPrometheusValue return the value regarding metric label
-func (c *ContainerMetrics) ToPrometheusValue(metric string) string {
-	currentValue := false
-	if strings.Contains(metric, "curr_") {
-		currentValue = true
-		metric = strings.ReplaceAll(metric, "curr_", "")
-	}
-	metric = strings.ReplaceAll(metric, "total_", "")
-
-	if curr, aggr, err := c.getIntDeltaAndAggrValue(metric); err == nil {
-		if currentValue {
-			return strconv.FormatUint(curr, 10)
-		}
-		return strconv.FormatUint(aggr, 10)
-	}
-	if curr, aggr, err := c.getFloatCurrAndAggrValue(metric); err == nil {
-		if currentValue {
-			return fmt.Sprintf("%f", curr)
-		}
-		return fmt.Sprintf("%f", aggr)
-	}
-	klog.Errorf("cannot extract metric: %s", metric)
-	return ""
-}
-
-func (c *ContainerMetrics) SumAllDynDeltaValues() uint64 {
-	return c.DynEnergyInPkg.Delta + c.DynEnergyInGPU.Delta + c.DynEnergyInOther.Delta
-}
-
-func (c *ContainerMetrics) SumAllDynAggrValues() uint64 {
-	return c.DynEnergyInPkg.Aggr + c.DynEnergyInGPU.Aggr + c.DynEnergyInOther.Aggr
-}
-
-func (c *ContainerMetrics) String() string {
-	return fmt.Sprintf("energy from pod/container (%d active processes): name: %s/%s namespace: %s \n"+
-		"\tcgrouppid: %d pid: %d comm: %s containerid:%s\n"+
-		"\tDyn ePkg (mJ): %s (eCore: %s eDram: %s eUncore: %s) eGPU (mJ): %s eOther (mJ): %s \n"+
-		"\tIdle ePkg (mJ): %s (eCore: %s eDram: %s eUncore: %s) eGPU (mJ): %s eOther (mJ): %s \n"+
-		"\tcounters: %v\n"+
-		"\tcgroupfs: %v\n",
-		c.CurrProcesses, c.PodName, c.ContainerName, c.Namespace,
-		c.CGroupPID, c.PIDS, c.Command, c.ContainerID,
-		c.DynEnergyInPkg, c.DynEnergyInCore, c.DynEnergyInDRAM, c.DynEnergyInUncore, c.DynEnergyInGPU, c.DynEnergyInOther,
-		c.IdleEnergyInPkg, c.IdleEnergyInCore, c.IdleEnergyInDRAM, c.IdleEnergyInUncore, c.IdleEnergyInGPU, c.IdleEnergyInOther,
-		c.BPFStats,
-		c.CgroupStatMap)
-}
-
-func (c *ContainerMetrics) UpdateCgroupMetrics() error {
-	if c.CgroupStatHandler == nil {
-		return nil
-	}
-	err := c.CgroupStatHandler.SetCGroupStat(c.ContainerID, c.CgroupStatMap)
-	if err != nil {
-		klog.V(3).Infof("Error reading cgroup stats for container %s (%s): %v", c.ContainerName, c.ContainerID, err)
-	}
-	return err
-}
-
-func (c *ContainerMetrics) GetDynEnergyStat(component string) (energyStat *types.UInt64Stat) {
-	if c == nil {
-		return
-	}
-	switch component {
-	case PKG:
-		return c.DynEnergyInPkg
-	case CORE:
-		return c.DynEnergyInCore
-	case DRAM:
-		return c.DynEnergyInDRAM
-	case UNCORE:
-		return c.DynEnergyInUncore
-	case GPU:
-		return c.DynEnergyInGPU
-	case OTHER:
-		return c.DynEnergyInOther
-	case PLATFORM:
-		return c.DynEnergyInPlatform
-	default:
-		klog.Fatalf("DynEnergy component type %s is unknown\n", component)
-	}
-	return
-}
-
-func (c *ContainerMetrics) GetIdleEnergyStat(component string) (energyStat *types.UInt64Stat) {
-	switch component {
-	case PKG:
-		return c.IdleEnergyInPkg
-	case CORE:
-		return c.IdleEnergyInCore
-	case DRAM:
-		return c.IdleEnergyInDRAM
-	case UNCORE:
-		return c.IdleEnergyInUncore
-	case GPU:
-		return c.IdleEnergyInGPU
-	case OTHER:
-		return c.IdleEnergyInOther
-	case PLATFORM:
-		return c.IdleEnergyInPlatform
-	default:
-		klog.Fatalf("IdleEnergy component type %s is unknown\n", component)
-	}
-	return
-}
diff --git a/pkg/collector/metric/container_metric_test.go b/pkg/collector/metric/container_metric_test.go
deleted file mode 100644
index f3f8c5dc85..0000000000
--- a/pkg/collector/metric/container_metric_test.go
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
-Copyright 2021.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package metric
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-	"github.com/sustainable-computing-io/kepler/pkg/collector/metric/types"
-)
-
-var _ = Describe("Test Container Metric", func() {
-
-	c := ContainerMetrics{
-		ProcessMetrics: ProcessMetrics{
-			DynEnergyInCore:   &types.UInt64Stat{Delta: uint64(1), Aggr: uint64(2)},
-			DynEnergyInDRAM:   &types.UInt64Stat{Delta: uint64(3), Aggr: uint64(4)},
-			DynEnergyInUncore: &types.UInt64Stat{Delta: uint64(5), Aggr: uint64(6)},
-			DynEnergyInPkg:    &types.UInt64Stat{Delta: uint64(7), Aggr: uint64(8)},
-			DynEnergyInGPU:    &types.UInt64Stat{Delta: uint64(9), Aggr: uint64(10)},
-			DynEnergyInOther:  &types.UInt64Stat{Delta: uint64(11), Aggr: uint64(12)},
-		},
-		CgroupStatMap: map[string]*types.UInt64StatCollection{
-			CORE: {
-				Stat: map[string]*types.UInt64Stat{
-					"usage": {Delta: uint64(13), Aggr: uint64(14)},
-				},
-			},
-			DRAM: {
-				Stat: map[string]*types.UInt64Stat{
-					"usage": {Delta: uint64(15), Aggr: uint64(16)},
-				},
-			},
-			UNCORE: {
-				Stat: map[string]*types.UInt64Stat{
-					"usage": {Delta: uint64(17), Aggr: uint64(18)},
-				},
-			},
-			PKG: {
-				Stat: map[string]*types.UInt64Stat{
-					"usage": {Delta: uint64(19), Aggr: uint64(20)},
-				},
-			},
-			GPU: {
-				Stat: map[string]*types.UInt64Stat{
-					"usage": {Delta: uint64(21), Aggr: uint64(22)},
-				},
-			},
-			OTHER: {
-				Stat: map[string]*types.UInt64Stat{
-					"usage": {Delta: uint64(23), Aggr: uint64(24)},
-				},
-			},
-		},
-	}
-
-	It("Test getIntDeltaAndAggrValue", func() {
-		delta, aggr, err := c.getIntDeltaAndAggrValue(CORE)
-		Expect(err).NotTo(HaveOccurred())
-		Expect(delta).To(Equal(uint64(13)))
-		Expect(aggr).To(Equal(uint64(14)))
-		delta, aggr, err = c.getIntDeltaAndAggrValue(DRAM)
-		Expect(err).NotTo(HaveOccurred())
-		Expect(delta).To(Equal(uint64(15)))
-		Expect(aggr).To(Equal(uint64(16)))
-		delta, aggr, err = c.getIntDeltaAndAggrValue(UNCORE)
-		Expect(err).NotTo(HaveOccurred())
-		Expect(delta).To(Equal(uint64(17)))
-		Expect(aggr).To(Equal(uint64(18)))
-		delta, aggr, err = c.getIntDeltaAndAggrValue(PKG)
-		Expect(err).NotTo(HaveOccurred())
-		Expect(delta).To(Equal(uint64(19)))
-		Expect(aggr).To(Equal(uint64(20)))
-		delta, aggr, err = c.getIntDeltaAndAggrValue(GPU)
-		Expect(err).NotTo(HaveOccurred())
-		Expect(delta).To(Equal(uint64(21)))
-		Expect(aggr).To(Equal(uint64(22)))
-		delta, aggr, err = c.getIntDeltaAndAggrValue(OTHER)
-		Expect(err).NotTo(HaveOccurred())
-		Expect(delta).To(Equal(uint64(23)))
-		Expect(aggr).To(Equal(uint64(24)))
-	})
-
-	It("Test ResetDeltaValues", func() {
-		instance := NewContainerMetrics("container", "PodName", "Namespace", "container")
-		instance.ResetDeltaValues()
-		Expect(0).To(Equal(instance.CurrProcesses))
-	})
-
-	It("Test SumAllDynDeltaValues", func() {
-		instance := NewContainerMetrics("container", "PodName", "Namespace", "container")
-		exp := instance.DynEnergyInPkg.Delta + instance.DynEnergyInGPU.Delta + instance.DynEnergyInOther.Delta
-		cur := instance.SumAllDynDeltaValues()
-		Expect(exp).To(Equal(cur))
-	})
-
-	It("Test SumAllDynAggrValues", func() {
-		instance := NewContainerMetrics("container", "PodName", "Namespace", "container")
-		exp := instance.DynEnergyInPkg.Aggr + instance.DynEnergyInGPU.Aggr + instance.DynEnergyInOther.Aggr
-		cur := instance.SumAllDynAggrValues()
-		Expect(exp).To(Equal(cur))
-	})
-})
diff --git a/pkg/collector/metric/node_metric.go b/pkg/collector/metric/node_metric.go
deleted file mode 100644
index f7628bf8b5..0000000000
--- a/pkg/collector/metric/node_metric.go
+++ /dev/null
@@ -1,594 +0,0 @@
-/*
-Copyright 2021.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package metric
-
-import (
-	"fmt"
-	"math"
-	"strconv"
-
-	"k8s.io/klog/v2"
-
-	"github.com/sustainable-computing-io/kepler/pkg/collector/metric/types"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
-	qat "github.com/sustainable-computing-io/kepler/pkg/power/accelerator/qat/source"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
-)
-
-const (
-	CORE      = "core"
-	DRAM      = "dram"
-	UNCORE    = "uncore"
-	PKG       = "package"
-	GPU       = "gpu"
-	OTHER     = "other"
-	PLATFORM  = "platform"
-	FREQUENCY = "frequency"
-	DYN       = "_DYN"
-	IDLE      = "_IDLE"
-)
-
-var (
-	NodeName            = GetNodeName()
-	NodeCPUArchitecture = getCPUArch()
-	NodeCPUPackageMap   = getCPUPackageMap()
-
-	// NodeMetricNames holds the name of the system metadata information.
-	NodeMetadataFeatureNames []string = []string{"cpu_architecture"}
-	// SystemMetadata holds the metadata regarding the system information
-	NodeMetadataFeatureValues []string = []string{NodeCPUArchitecture}
-)
-
-type NodeMetrics struct {
-	ResourceUsage map[string]float64
-
-	// Absolute energy is the sum of Idle + Dynamic energy.
-	AbsEnergyInCore     *types.UInt64StatCollection
-	AbsEnergyInDRAM     *types.UInt64StatCollection
-	AbsEnergyInUncore   *types.UInt64StatCollection
-	AbsEnergyInPkg      *types.UInt64StatCollection
-	AbsEnergyInGPU      *types.UInt64StatCollection
-	AbsEnergyInOther    *types.UInt64StatCollection
-	AbsEnergyInPlatform *types.UInt64StatCollection
-
-	DynEnergyInCore     *types.UInt64StatCollection
-	DynEnergyInDRAM     *types.UInt64StatCollection
-	DynEnergyInUncore   *types.UInt64StatCollection
-	DynEnergyInPkg      *types.UInt64StatCollection
-	DynEnergyInGPU      *types.UInt64StatCollection
-	DynEnergyInOther    *types.UInt64StatCollection
-	DynEnergyInPlatform *types.UInt64StatCollection
-
-	IdleEnergyInCore     *types.UInt64StatCollection
-	IdleEnergyInDRAM     *types.UInt64StatCollection
-	IdleEnergyInUncore   *types.UInt64StatCollection
-	IdleEnergyInPkg      *types.UInt64StatCollection
-	IdleEnergyInGPU      *types.UInt64StatCollection
-	IdleEnergyInOther    *types.UInt64StatCollection
-	IdleEnergyInPlatform *types.UInt64StatCollection
-
-	CPUFrequency map[int32]uint64
-
-	// IdleCPUUtilization is used to determine idle periods
-	IdleCPUUtilization uint64
-	FoundNewIdleState  bool
-
-	// Accelerator-QAT Utilization
-	QATUtilization map[string]qat.DeviceUtilizationSample
-}
-
-func NewNodeMetrics() *NodeMetrics {
-	return &NodeMetrics{
-		ResourceUsage: make(map[string]float64),
-		AbsEnergyInCore: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		AbsEnergyInDRAM: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		AbsEnergyInUncore: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		AbsEnergyInPkg: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		AbsEnergyInGPU: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		AbsEnergyInOther: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		AbsEnergyInPlatform: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-
-		DynEnergyInCore: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		DynEnergyInDRAM: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		DynEnergyInUncore: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		DynEnergyInPkg: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		DynEnergyInGPU: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		DynEnergyInOther: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		DynEnergyInPlatform: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-
-		IdleEnergyInCore: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		IdleEnergyInDRAM: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		IdleEnergyInUncore: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		IdleEnergyInPkg: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		IdleEnergyInGPU: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		IdleEnergyInOther: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-		IdleEnergyInPlatform: &types.UInt64StatCollection{
-			Stat: make(map[string]*types.UInt64Stat),
-		},
-	}
-}
-
-func (ne *NodeMetrics) ResetDeltaValues() {
-	ne.AbsEnergyInCore.ResetDeltaValues()
-	ne.AbsEnergyInDRAM.ResetDeltaValues()
-	ne.AbsEnergyInUncore.ResetDeltaValues()
-	ne.AbsEnergyInPkg.ResetDeltaValues()
-	ne.AbsEnergyInGPU.ResetDeltaValues()
-	ne.AbsEnergyInPlatform.ResetDeltaValues()
-	ne.DynEnergyInCore.ResetDeltaValues()
-	ne.DynEnergyInDRAM.ResetDeltaValues()
-	ne.DynEnergyInUncore.ResetDeltaValues()
-	ne.DynEnergyInPkg.ResetDeltaValues()
-	// gpu metric
-	if config.EnabledGPU && gpu.IsGPUCollectionSupported() {
-		ne.DynEnergyInGPU.ResetDeltaValues()
-	}
-	ne.DynEnergyInPlatform.ResetDeltaValues()
-	ne.ResourceUsage = make(map[string]float64)
-}
-
-// AddNodeResResourceUsageFromContainerResResourceUsage adds the sum of all container resource usage as the node resource usage
-func (ne *NodeMetrics) AddNodeResUsageFromContainerResUsage(containersMetrics map[string]*ContainerMetrics) {
-	var IdleCPUUtilization uint64
-	nodeResourceUsage := make(map[string]float64)
-	for _, metricName := range ContainerFeaturesNames {
-		nodeResourceUsage[metricName] = 0
-		for _, container := range containersMetrics {
-			delta, _, _ := container.getIntDeltaAndAggrValue(metricName)
-			nodeResourceUsage[metricName] += float64(delta)
-			if metricName == config.CPUInstruction {
-				IdleCPUUtilization += delta
-			}
-		}
-	}
-	ne.ResourceUsage = nodeResourceUsage
-	if (ne.IdleCPUUtilization > IdleCPUUtilization) || (ne.IdleCPUUtilization == 0) {
-		ne.FoundNewIdleState = true
-		ne.IdleCPUUtilization = IdleCPUUtilization
-	}
-}
-
-func normalize(val float64, shouldNormalize bool) float64 {
-	if shouldNormalize {
-		return val / float64(config.SamplePeriodSec)
-	}
-	return val
-}
-
-// ToEstimatorValues return values regarding metricNames.
-// The metrics can be related to resource utilization or power consumption.
-// Since Kepler collects metrics at intervals of SamplePeriodSec, which is greater than 1 second, and the power models are trained to estimate power in 1 second interval.
-// It is necessary to normalize the resource utilization by the SamplePeriodSec. Note that this is important because the power curve can be different for higher or lower resource usage within 1 second interval.
-func (ne *NodeMetrics) ToEstimatorValues(featuresName []string, shouldNormalize bool) []float64 {
-	featureValues := []float64{}
-	for _, feature := range featuresName {
-		// verify all metrics that are part of the node resource usage metrics
-		if value, exists := ne.ResourceUsage[feature]; exists {
-			featureValues = append(featureValues, normalize(value, shouldNormalize))
-			continue
-		}
-		// some features are not related to resource utilization, such as power metrics
-		switch feature {
-		case config.GeneralUsageMetric: // for UNCORE and OTHER resource usage
-			featureValues = append(featureValues, 0)
-
-		case config.GpuUsageMetric: // for GPU resource usage
-			featureValues = append(featureValues, normalize(ne.ResourceUsage[config.GpuUsageMetric], shouldNormalize))
-
-		case PKG + DYN: // for dynamic PKG power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaDynEnergyFromAllSources(PKG)), shouldNormalize))
-
-		case CORE + DYN: // for dynamic CORE power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaDynEnergyFromAllSources(CORE)), shouldNormalize))
-
-		case DRAM + DYN: // for dynamic DRAM power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaDynEnergyFromAllSources(DRAM)), shouldNormalize))
-
-		case UNCORE + DYN: // for dynamic UNCORE power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaDynEnergyFromAllSources(UNCORE)), shouldNormalize))
-
-		case OTHER + DYN: // for dynamic OTHER power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaDynEnergyFromAllSources(OTHER)), shouldNormalize))
-
-		case PLATFORM + DYN: // for dynamic PLATFORM power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaDynEnergyFromAllSources(PLATFORM)), shouldNormalize))
-
-		case GPU + DYN: // for dynamic GPU power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaDynEnergyFromAllSources(GPU)), shouldNormalize))
-
-		case PKG + IDLE: // for idle PKG power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaIdleEnergyFromAllSources(PKG)), shouldNormalize))
-
-		case CORE + IDLE: // for idle CORE power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaIdleEnergyFromAllSources(CORE)), shouldNormalize))
-
-		case DRAM + IDLE: // for idle DRAM power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaIdleEnergyFromAllSources(DRAM)), shouldNormalize))
-
-		case UNCORE + IDLE: // for idle UNCORE power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaIdleEnergyFromAllSources(UNCORE)), shouldNormalize))
-
-		case OTHER + IDLE: // for idle OTHER power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaIdleEnergyFromAllSources(OTHER)), shouldNormalize))
-
-		case PLATFORM + IDLE: // for idle PLATFORM power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaIdleEnergyFromAllSources(PLATFORM)), shouldNormalize))
-
-		case GPU + IDLE: // for idle GPU power consumption
-			featureValues = append(featureValues, normalize(float64(ne.GetSumDeltaIdleEnergyFromAllSources(GPU)), shouldNormalize))
-
-		default:
-			klog.V(5).Infof("Unknown node feature: %s, adding 0 value", feature)
-			featureValues = append(featureValues, 0)
-		}
-	}
-	return featureValues
-}
-
-// SetNodePlatformEnergy adds the idle or absolute energy consumption from the node sensor.
-// Absolute energy is the sum of Idle + Dynamic energy.
-func (ne *NodeMetrics) SetNodePlatformEnergy(platformEnergy map[string]float64, gauge, isIdleEnergy bool) {
-	for sensorID, energy := range platformEnergy {
-		if gauge {
-			if isIdleEnergy {
-				ne.IdleEnergyInPlatform.SetDeltaStat(sensorID, uint64(math.Ceil(energy)))
-			} else {
-				ne.AbsEnergyInPlatform.SetDeltaStat(sensorID, uint64(math.Ceil(energy)))
-			}
-		} else {
-			if isIdleEnergy {
-				ne.IdleEnergyInPlatform.SetAggrStat(sensorID, uint64(math.Ceil(energy)))
-			} else {
-				ne.AbsEnergyInPlatform.SetAggrStat(sensorID, uint64(math.Ceil(energy)))
-			}
-		}
-	}
-}
-
-// SetNodeComponentsEnergy adds the idle or absolute energy consumption collected from the node's components (e.g., using RAPL).
-// Absolute energy is the sum of Idle + Dynamic energy.
-func (ne *NodeMetrics) SetNodeComponentsEnergy(componentsEnergy map[int]source.NodeComponentsEnergy, gauge, isIdleEnergy bool) {
-	for pkgID, energy := range componentsEnergy {
-		key := strconv.Itoa(pkgID)
-		if gauge {
-			if isIdleEnergy {
-				ne.IdleEnergyInCore.SetDeltaStat(key, energy.Core)
-				ne.IdleEnergyInDRAM.SetDeltaStat(key, energy.DRAM)
-				ne.IdleEnergyInUncore.SetDeltaStat(key, energy.Uncore)
-				ne.IdleEnergyInPkg.SetDeltaStat(key, energy.Pkg)
-			} else {
-				ne.AbsEnergyInCore.SetDeltaStat(key, energy.Core)
-				ne.AbsEnergyInDRAM.SetDeltaStat(key, energy.DRAM)
-				ne.AbsEnergyInUncore.SetDeltaStat(key, energy.Uncore)
-				ne.AbsEnergyInPkg.SetDeltaStat(key, energy.Pkg)
-			}
-		} else {
-			if isIdleEnergy {
-				ne.IdleEnergyInCore.SetAggrStat(key, energy.Core)
-				ne.IdleEnergyInDRAM.SetAggrStat(key, energy.DRAM)
-				ne.IdleEnergyInUncore.SetAggrStat(key, energy.Uncore)
-				ne.IdleEnergyInPkg.SetAggrStat(key, energy.Pkg)
-			} else {
-				ne.AbsEnergyInCore.SetAggrStat(key, energy.Core)
-				ne.AbsEnergyInDRAM.SetAggrStat(key, energy.DRAM)
-				ne.AbsEnergyInUncore.SetAggrStat(key, energy.Uncore)
-				ne.AbsEnergyInPkg.SetAggrStat(key, energy.Pkg)
-			}
-		}
-	}
-}
-
-// SetNodeGPUEnergy adds the lastest energy consumption of each GPU power consumption.
-// Right now we don't support other types of accelerators than GPU, but we will in the future.
-func (ne *NodeMetrics) SetNodeGPUEnergy(gpuEnergy []uint32, isIdleEnergy bool) {
-	for gpuID, energy := range gpuEnergy {
-		key := strconv.Itoa(gpuID)
-		if isIdleEnergy {
-			ne.IdleEnergyInGPU.SetDeltaStat(key, uint64(energy))
-		} else {
-			ne.AbsEnergyInGPU.SetDeltaStat(key, uint64(energy))
-		}
-	}
-}
-
-func (ne *NodeMetrics) UpdateIdleEnergyWithMinValue(isComponentsSystemCollectionSupported bool) {
-	// gpu metric
-	if config.EnabledGPU && gpu.IsGPUCollectionSupported() {
-		ne.CalcIdleEnergy(GPU)
-	}
-
-	if isComponentsSystemCollectionSupported {
-		ne.CalcIdleEnergy(CORE)
-		ne.CalcIdleEnergy(DRAM)
-		ne.CalcIdleEnergy(UNCORE)
-		ne.CalcIdleEnergy(PKG)
-		ne.CalcIdleEnergy(PLATFORM)
-	}
-	// reset
-	ne.FoundNewIdleState = false
-}
-
-func (ne *NodeMetrics) CalcIdleEnergy(component string) {
-	totalStatCollection := ne.getAbsoluteEnergyStatCollection(component)
-	idleStatCollection := ne.getIdleEnergyStatCollection(component)
-	for id := range totalStatCollection.Stat {
-		delta := totalStatCollection.Stat[id].Delta
-		if _, exist := idleStatCollection.Stat[id]; !exist {
-			idleStatCollection.SetDeltaStat(id, delta)
-		} else {
-			idleDelta := idleStatCollection.Stat[id].Delta
-			// only updates the idle energy if the resource utilization is low. i.e., ne.FoundNewIdleState == true
-			if ((idleDelta == 0) || (idleDelta > delta)) && ((ne.FoundNewIdleState) || (ne.IdleCPUUtilization == 0)) {
-				idleStatCollection.SetDeltaStat(id, delta)
-			} else {
-				idleStatCollection.SetDeltaStat(id, idleDelta)
-			}
-		}
-	}
-}
-
-// UpdateDynEnergy calculates the dynamic energy
-func (ne *NodeMetrics) UpdateDynEnergy() {
-	for pkgID := range ne.AbsEnergyInPkg.Stat {
-		ne.CalcDynEnergy(PKG, pkgID)
-		ne.CalcDynEnergy(CORE, pkgID)
-		ne.CalcDynEnergy(UNCORE, pkgID)
-		ne.CalcDynEnergy(DRAM, pkgID)
-	}
-	for sensorID := range ne.AbsEnergyInPlatform.Stat {
-		ne.CalcDynEnergy(PLATFORM, sensorID)
-	}
-	// gpu metric
-	if config.EnabledGPU && gpu.IsGPUCollectionSupported() {
-		for gpuID := range ne.AbsEnergyInGPU.Stat {
-			ne.CalcDynEnergy(GPU, gpuID)
-		}
-	}
-}
-
-func (ne *NodeMetrics) CalcDynEnergy(component, id string) {
-	total := ne.getAbsoluteEnergyStatCollection(component).Stat[id].Delta
-	klog.V(5).Infof("Energy stat: %v (%s)", ne.getIdleEnergyStatCollection(component).Stat, id)
-	idle := uint64(0)
-	if idleStat, found := ne.getIdleEnergyStatCollection(component).Stat[id]; found {
-		idle = idleStat.Delta
-	}
-	dyn := calcDynEnergy(total, idle)
-	ne.getDynEnergyStatCollection(component).SetDeltaStat(id, dyn)
-}
-
-func calcDynEnergy(totalE, idleE uint64) uint64 {
-	if (totalE == 0) || (idleE == 0) || (totalE < idleE) {
-		return 0
-	}
-	return totalE - idleE
-}
-
-// SetNodeOtherComponentsEnergy adds the lastest energy consumption collected from the other node's components than CPU and DRAM
-// Other components energy is a special case where the energy is calculated and not measured
-func (ne *NodeMetrics) SetNodeOtherComponentsEnergy() {
-	dynCPUComponentsEnergy := ne.DynEnergyInPkg.SumAllDeltaValues() +
-		ne.DynEnergyInDRAM.SumAllDeltaValues() +
-		ne.DynEnergyInGPU.SumAllDeltaValues()
-	dynPlatformEnergy := ne.DynEnergyInPlatform.SumAllDeltaValues()
-	if dynPlatformEnergy > dynCPUComponentsEnergy {
-		otherComponentEnergy := dynPlatformEnergy - dynCPUComponentsEnergy
-		ne.DynEnergyInOther.SetDeltaStat(OTHER, otherComponentEnergy)
-	}
-
-	idleCPUComponentsEnergy := ne.IdleEnergyInPkg.SumAllDeltaValues() +
-		ne.IdleEnergyInDRAM.SumAllDeltaValues() +
-		ne.IdleEnergyInGPU.SumAllDeltaValues()
-	idlePlatformEnergy := ne.IdleEnergyInPlatform.SumAllDeltaValues()
-	if idlePlatformEnergy > idleCPUComponentsEnergy {
-		otherComponentEnergy := idlePlatformEnergy - idleCPUComponentsEnergy
-		ne.IdleEnergyInOther.SetDeltaStat(OTHER, otherComponentEnergy)
-	}
-}
-
-func (ne *NodeMetrics) GetNodeResUsagePerResType(resource string) (float64, error) {
-	data, ok := ne.ResourceUsage[resource]
-	if ok {
-		return data, nil
-	}
-	return 0, fmt.Errorf("resource %s not found", resource)
-}
-
-func (ne *NodeMetrics) String() string {
-	return fmt.Sprintf("node delta energy (mJ): \n"+
-		"\tePkg: %d (eCore: %d eDram: %d eUncore: %d) eGPU: %d eOther: %d \n",
-		ne.AbsEnergyInPkg.SumAllDeltaValues(), ne.AbsEnergyInCore.SumAllDeltaValues(), ne.AbsEnergyInDRAM.SumAllDeltaValues(), ne.AbsEnergyInUncore.SumAllDeltaValues(), ne.AbsEnergyInGPU.SumAllDeltaValues(), ne.AbsEnergyInOther.SumAllDeltaValues())
-}
-
-// GetAggrDynEnergyPerID returns the aggr dynamic energy from all source (e.g. package or gpu ids)
-func (ne *NodeMetrics) GetAggrDynEnergyPerID(component, id string) uint64 {
-	statCollection := ne.getDynEnergyStatCollection(component)
-	if _, exist := statCollection.Stat[id]; exist {
-		return statCollection.Stat[id].Aggr
-	}
-	return uint64(0)
-}
-
-// GetDeltaDynEnergyPerID returns the delta dynamic energy from all source (e.g. package or gpu ids)
-func (ne *NodeMetrics) GetDeltaDynEnergyPerID(component, id string) uint64 {
-	statCollection := ne.getDynEnergyStatCollection(component)
-	if _, exist := statCollection.Stat[id]; exist {
-		return statCollection.Stat[id].Delta
-	}
-	return uint64(0)
-}
-
-// GetSumAggrDynEnergyFromAllSources returns the sum of aggr dynamic energy of all source (e.g. package or gpu ids)
-func (ne *NodeMetrics) GetSumAggrDynEnergyFromAllSources(component string) uint64 {
-	var dynamicEnergy uint64
-	for _, val := range ne.getDynEnergyStatCollection(component).Stat {
-		dynamicEnergy += val.Aggr
-	}
-	return dynamicEnergy
-}
-
-// GetSumDeltaDynEnergyFromAllSources returns the sum of delta dynamic energy of all source (e.g. package or gpu ids)
-func (ne *NodeMetrics) GetSumDeltaDynEnergyFromAllSources(component string) uint64 {
-	var dynamicEnergy uint64
-	for _, val := range ne.getDynEnergyStatCollection(component).Stat {
-		dynamicEnergy += val.Delta
-	}
-	return dynamicEnergy
-}
-
-// GetAggrIdleEnergyPerID returns the aggr idle energy for a given id
-func (ne *NodeMetrics) GetAggrIdleEnergyPerID(component, id string) uint64 {
-	statCollection := ne.getIdleEnergyStatCollection(component)
-	if _, exist := statCollection.Stat[id]; exist {
-		return statCollection.Stat[id].Aggr
-	}
-	return uint64(0)
-}
-
-// GetDeltaIdleEnergyPerID returns the delta idle energy from all source (e.g. package or gpu ids)
-func (ne *NodeMetrics) GetDeltaIdleEnergyPerID(component, id string) uint64 {
-	statCollection := ne.getIdleEnergyStatCollection(component)
-	if _, exist := statCollection.Stat[id]; exist {
-		return statCollection.Stat[id].Delta
-	}
-	return uint64(0)
-}
-
-// GetSumDeltaIdleEnergyFromAllSources returns the sum of delta idle energy of all source (e.g. package or gpu ids)
-func (ne *NodeMetrics) GetSumDeltaIdleEnergyFromAllSources(component string) uint64 {
-	var idleEnergy uint64
-	for _, val := range ne.getIdleEnergyStatCollection(component).Stat {
-		idleEnergy += val.Delta
-	}
-	return idleEnergy
-}
-
-// GetSumAggrIdleEnergyFromAllSources returns the sum of aggr idle energy of all source (e.g. package or gpu ids)
-func (ne *NodeMetrics) GetSumAggrIdleEnergyFromAllSources(component string) uint64 {
-	var idleEnergy uint64
-	for _, val := range ne.getIdleEnergyStatCollection(component).Stat {
-		idleEnergy += val.Aggr
-	}
-	return idleEnergy
-}
-
-func (ne *NodeMetrics) getAbsoluteEnergyStatCollection(component string) (energyStat *types.UInt64StatCollection) {
-	switch component {
-	case PKG:
-		return ne.AbsEnergyInPkg
-	case CORE:
-		return ne.AbsEnergyInCore
-	case DRAM:
-		return ne.AbsEnergyInDRAM
-	case UNCORE:
-		return ne.AbsEnergyInUncore
-	case GPU:
-		return ne.AbsEnergyInGPU
-	case OTHER:
-		return ne.AbsEnergyInOther
-	case PLATFORM:
-		return ne.AbsEnergyInPlatform
-	default:
-		klog.Fatalf("AbsoluteEnergy component type %s is unknown\n", component)
-	}
-	return
-}
-
-func (ne *NodeMetrics) getDynEnergyStatCollection(component string) (energyStat *types.UInt64StatCollection) {
-	switch component {
-	case PKG:
-		return ne.DynEnergyInPkg
-	case CORE:
-		return ne.DynEnergyInCore
-	case DRAM:
-		return ne.DynEnergyInDRAM
-	case UNCORE:
-		return ne.DynEnergyInUncore
-	case GPU:
-		return ne.DynEnergyInGPU
-	case OTHER:
-		return ne.DynEnergyInOther
-	case PLATFORM:
-		return ne.DynEnergyInPlatform
-	default:
-		klog.Fatalf("DynEnergy component type %s is unknown\n", component)
-	}
-	return
-}
-
-func (ne *NodeMetrics) getIdleEnergyStatCollection(component string) (energyStat *types.UInt64StatCollection) {
-	switch component {
-	case PKG:
-		return ne.IdleEnergyInPkg
-	case CORE:
-		return ne.IdleEnergyInCore
-	case DRAM:
-		return ne.IdleEnergyInDRAM
-	case UNCORE:
-		return ne.IdleEnergyInUncore
-	case GPU:
-		return ne.IdleEnergyInGPU
-	case OTHER:
-		return ne.IdleEnergyInOther
-	case PLATFORM:
-		return ne.IdleEnergyInPlatform
-	default:
-		klog.Fatalf("IdleEnergy component type %s is unknown\n", component)
-	}
-	return
-}
diff --git a/pkg/collector/metric/node_metric_test.go b/pkg/collector/metric/node_metric_test.go
deleted file mode 100644
index 92f130c3a0..0000000000
--- a/pkg/collector/metric/node_metric_test.go
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
-Copyright 2021.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package metric
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
-)
-
-// we need to add all metric to a container, otherwise it will not create the right usageMetric with all elements. The usageMetric is used in the Prediction Power Models
-// TODO: do not use a fixed usageMetric array in the power models, a structured data is more disarable.
-func setCollectorMetrics() {
-	// initialize the Available metrics since they are used to create a new containersMetrics instance
-	AvailableCGroupMetrics = []string{config.CgroupfsMemory, config.CgroupfsKernelMemory, config.CgroupfsTCPMemory}
-	ContainerUintFeaturesNames = append(ContainerUintFeaturesNames, AvailableCGroupMetrics...)
-	// ContainerFeaturesNames is used by the nodeMetrics to extract the resource usage. Only the metrics in ContainerFeaturesNames will be used.
-	ContainerFeaturesNames = ContainerUintFeaturesNames
-}
-
-// add two containers with all metrics initialized
-func createMockContainersMetrics() map[string]*ContainerMetrics {
-	containersMetrics := map[string]*ContainerMetrics{}
-	containersMetrics["containerA"] = createMockContainerMetrics("containerA", "podA", "test")
-
-	return containersMetrics
-}
-
-// see usageMetrics for the list of used metrics. For the sake of visibility we add all metrics, but only few of them will be used.
-func createMockContainerMetrics(containerName, podName, namespace string) *ContainerMetrics {
-	containerMetrics := NewContainerMetrics(containerName, podName, namespace, containerName)
-	// cgroup - cgroup package
-	// we need to add two aggregated values to the stats so that it can calculate a current value (i.e. agg diff)
-	containerMetrics.CgroupStatMap[config.CgroupfsMemory].SetDeltaStat(containerName, 10)
-	containerMetrics.CgroupStatMap[config.CgroupfsKernelMemory].SetDeltaStat(containerName, 20)
-	containerMetrics.CgroupStatMap[config.CgroupfsTCPMemory].SetDeltaStat(containerName, 30)
-	return containerMetrics
-}
-
-func createMockNodeMetrics(containersMetrics map[string]*ContainerMetrics) *NodeMetrics {
-	nodeMetrics := NewNodeMetrics()
-	nodeMetrics.AddNodeResUsageFromContainerResUsage(containersMetrics)
-	componentsEnergies := make(map[int]source.NodeComponentsEnergy)
-	machineSocketID := 0
-
-	// the NodeComponentsEnergy is the aggregated energy consumption of the node components
-	// then, the components energy consumption is added to the in the nodeMetrics as Agg data
-	// this means that, to have a Delta value, we must have at least two Agg data (to have Agg diff)
-	// therefore, we need to add two values for NodeComponentsEnergy to have energy values to test
-	componentsEnergies[machineSocketID] = source.NodeComponentsEnergy{
-		Pkg:  10,
-		Core: 10,
-		DRAM: 10,
-	}
-	nodeMetrics.SetNodeComponentsEnergy(componentsEnergies, false, false)
-	componentsEnergies[machineSocketID] = source.NodeComponentsEnergy{
-		Pkg:  18,
-		Core: 15,
-		DRAM: 11,
-	}
-	nodeMetrics.SetNodeComponentsEnergy(componentsEnergies, false, false)
-
-	return nodeMetrics
-}
-
-var _ = Describe("Test Node Metric", func() {
-	var (
-		containerMetrics map[string]*ContainerMetrics
-		nodeMetrics      *NodeMetrics
-	)
-
-	BeforeEach(func() {
-		setCollectorMetrics()
-		containerMetrics = createMockContainersMetrics()
-		nodeMetrics = createMockNodeMetrics(containerMetrics)
-	})
-
-	It("Test nodeMetrics ResourceUsage", func() {
-		v, ok := nodeMetrics.ResourceUsage[config.CgroupfsMemory]
-		Expect(ok).To(Equal(true))
-		Expect(v).To(Equal(float64(10)))
-	})
-
-	It("test SetNodeGPUEnergy", func() {
-		gpuEnergy := make([]uint32, 1)
-		nodeMetrics.SetNodeGPUEnergy(gpuEnergy, false)
-	})
-
-	It("test ResetDeltaValues", func() {
-		nodeMetrics.ResetDeltaValues()
-		Expect("0 (15)").To(Equal(nodeMetrics.AbsEnergyInCore.String()))
-	})
-
-	It("test UpdateIdleEnergyWithMinValue", func() {
-		nodeMetrics.UpdateIdleEnergyWithMinValue(true)
-		Expect(nodeMetrics.FoundNewIdleState).To(BeFalse())
-	})
-
-	It("test String", func() {
-		str := nodeMetrics.String()
-		Expect("node delta energy (mJ):").To(Equal(str[0:len("node delta energy (mJ):")]))
-	})
-
-	It("test GetNodeResUsagePerResType", func() {
-		val, _ := nodeMetrics.GetNodeResUsagePerResType("")
-		Expect(float64(0)).To(Equal(val))
-	})
-})
diff --git a/pkg/collector/metric/process_metric.go b/pkg/collector/metric/process_metric.go
deleted file mode 100644
index 501c496dad..0000000000
--- a/pkg/collector/metric/process_metric.go
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
-Copyright 2023.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package metric
-
-import (
-	"fmt"
-
-	"github.com/sustainable-computing-io/kepler/pkg/collector/metric/types"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
-	"k8s.io/klog/v2"
-)
-
-var (
-	// ProcessMetricNames holds the list of names of the container metric
-	ProcessMetricNames []string
-	// ProcessFloatFeatureNames holds the feature name of the container float collector_metric. This is specific for the machine-learning based models.
-	ProcessFloatFeatureNames []string = []string{}
-	// ProcessUintFeaturesNames holds the feature name of the container utint collector_metric. This is specific for the machine-learning based models.
-	ProcessUintFeaturesNames []string
-	// ProcessFeaturesNames holds all the feature name of the container collector_metric. This is specific for the machine-learning based models.
-	ProcessFeaturesNames []string
-)
-
-type ProcessMetrics struct {
-	PID     uint64
-	Command string
-
-	// ebpf metrics
-	BPFStats map[string]*types.UInt64Stat
-
-	// Energy metrics
-	DynEnergyInCore     *types.UInt64Stat
-	DynEnergyInDRAM     *types.UInt64Stat
-	DynEnergyInUncore   *types.UInt64Stat
-	DynEnergyInPkg      *types.UInt64Stat
-	DynEnergyInGPU      *types.UInt64Stat
-	DynEnergyInOther    *types.UInt64Stat
-	DynEnergyInPlatform *types.UInt64Stat
-
-	IdleEnergyInCore     *types.UInt64Stat
-	IdleEnergyInDRAM     *types.UInt64Stat
-	IdleEnergyInUncore   *types.UInt64Stat
-	IdleEnergyInPkg      *types.UInt64Stat
-	IdleEnergyInGPU      *types.UInt64Stat
-	IdleEnergyInOther    *types.UInt64Stat
-	IdleEnergyInPlatform *types.UInt64Stat
-}
-
-// NewProcessMetrics creates a new ProcessMetrics instance
-func NewProcessMetrics(pid uint64, command string) *ProcessMetrics {
-	p := &ProcessMetrics{
-		PID:                  pid,
-		Command:              command,
-		BPFStats:             make(map[string]*types.UInt64Stat),
-		DynEnergyInCore:      &types.UInt64Stat{},
-		DynEnergyInDRAM:      &types.UInt64Stat{},
-		DynEnergyInUncore:    &types.UInt64Stat{},
-		DynEnergyInPkg:       &types.UInt64Stat{},
-		DynEnergyInOther:     &types.UInt64Stat{},
-		DynEnergyInGPU:       &types.UInt64Stat{},
-		DynEnergyInPlatform:  &types.UInt64Stat{},
-		IdleEnergyInCore:     &types.UInt64Stat{},
-		IdleEnergyInDRAM:     &types.UInt64Stat{},
-		IdleEnergyInUncore:   &types.UInt64Stat{},
-		IdleEnergyInPkg:      &types.UInt64Stat{},
-		IdleEnergyInOther:    &types.UInt64Stat{},
-		IdleEnergyInGPU:      &types.UInt64Stat{},
-		IdleEnergyInPlatform: &types.UInt64Stat{},
-	}
-	for _, metricName := range AvailableBPFSWCounters {
-		p.BPFStats[metricName] = &types.UInt64Stat{}
-	}
-	for _, metricName := range AvailableBPFHWCounters {
-		p.BPFStats[metricName] = &types.UInt64Stat{}
-	}
-	// TODO: transparently list the other metrics and do not initialize them when they are not supported, e.g. HC
-	if gpu.IsGPUCollectionSupported() {
-		p.BPFStats[config.GPUSMUtilization] = &types.UInt64Stat{}
-		p.BPFStats[config.GPUMemUtilization] = &types.UInt64Stat{}
-	}
-	return p
-}
-
-// ResetCurr reset all current value to 0
-func (p *ProcessMetrics) ResetDeltaValues() {
-	for counterKey := range p.BPFStats {
-		p.BPFStats[counterKey].ResetDeltaValues()
-	}
-	p.DynEnergyInCore.ResetDeltaValues()
-	p.DynEnergyInDRAM.ResetDeltaValues()
-	p.DynEnergyInUncore.ResetDeltaValues()
-	p.DynEnergyInPkg.ResetDeltaValues()
-	p.DynEnergyInOther.ResetDeltaValues()
-	p.DynEnergyInGPU.ResetDeltaValues()
-	p.DynEnergyInPlatform.ResetDeltaValues()
-	p.IdleEnergyInCore.ResetDeltaValues()
-	p.IdleEnergyInDRAM.ResetDeltaValues()
-	p.IdleEnergyInUncore.ResetDeltaValues()
-	p.IdleEnergyInPkg.ResetDeltaValues()
-	p.IdleEnergyInOther.ResetDeltaValues()
-	p.IdleEnergyInGPU.ResetDeltaValues()
-	p.IdleEnergyInPlatform.ResetDeltaValues()
-}
-
-// getFloatCurrAndAggrValue return curr, aggr float64 values of specific uint metric
-func (p *ProcessMetrics) getFloatCurrAndAggrValue(metric string) (curr, aggr float64, err error) {
-	// TO-ADD
-	return 0, 0, nil
-}
-
-// getIntDeltaAndAggrValue return curr, aggr uint64 values of specific uint metric
-func (p *ProcessMetrics) getIntDeltaAndAggrValue(metric string) (curr, aggr uint64, err error) {
-	if val, exists := p.BPFStats[metric]; exists {
-		return val.Delta, val.Aggr, nil
-	}
-	klog.V(4).Infof("cannot extract: %s", metric)
-	return 0, 0, fmt.Errorf("cannot extract: %s", metric)
-}
-
-// ToEstimatorValues return values regarding metricNames.
-// Since Kepler collects metrics at intervals of SamplePeriodSec, which is greater than 1 second, and the power models are trained to estimate power in 1 second interval.
-// It is necessary to normalize the resource utilization by the SamplePeriodSec. Note that this is important because the power curve can be different for higher or lower resource usage within 1 second interval.
-func (p *ProcessMetrics) ToEstimatorValues(featuresName []string, shouldNormalize bool) (values []float64) {
-	for _, metric := range featuresName {
-		curr, _, _ := p.getFloatCurrAndAggrValue(metric)
-		values = append(values, normalize(curr, shouldNormalize))
-	}
-	for _, metric := range featuresName {
-		curr, _, _ := p.getIntDeltaAndAggrValue(metric)
-		values = append(values, normalize(float64(curr), shouldNormalize))
-	}
-	return
-}
-
-func (p *ProcessMetrics) SumAllDynDeltaValues() uint64 {
-	return p.DynEnergyInPkg.Delta + p.DynEnergyInGPU.Delta + p.DynEnergyInOther.Delta
-}
-
-func (p *ProcessMetrics) SumAllDynAggrValues() uint64 {
-	return p.DynEnergyInPkg.Aggr + p.DynEnergyInGPU.Aggr + p.DynEnergyInOther.Aggr
-}
-
-func (p *ProcessMetrics) String() string {
-	return fmt.Sprintf("energy from process pid: %d comm: %s\n"+
-		"\tDyn ePkg (mJ): %s (eCore: %s eDram: %s eUncore: %s) eGPU (mJ): %s eOther (mJ): %s \n"+
-		"\tIdle ePkg (mJ): %s (eCore: %s eDram: %s eUncore: %s) eGPU (mJ): %s eOther (mJ): %s \n"+
-		"\tcounters: %v\n",
-		p.PID, p.Command,
-		p.DynEnergyInPkg, p.DynEnergyInCore, p.DynEnergyInDRAM, p.DynEnergyInUncore, p.DynEnergyInGPU, p.DynEnergyInOther,
-		p.IdleEnergyInPkg, p.IdleEnergyInCore, p.IdleEnergyInDRAM, p.IdleEnergyInUncore, p.IdleEnergyInGPU, p.IdleEnergyInOther,
-		p.BPFStats)
-}
-
-func (p *ProcessMetrics) GetDynEnergyStat(component string) *types.UInt64Stat {
-	switch component {
-	case PKG:
-		return p.DynEnergyInPkg
-	case CORE:
-		return p.DynEnergyInCore
-	case DRAM:
-		return p.DynEnergyInDRAM
-	case UNCORE:
-		return p.DynEnergyInUncore
-	case GPU:
-		return p.DynEnergyInGPU
-	case OTHER:
-		return p.DynEnergyInOther
-	case PLATFORM:
-		return p.DynEnergyInPlatform
-	default:
-		klog.Fatalf("DynEnergy component type %s is unknown\n", component)
-	}
-	energyStat := types.UInt64Stat{}
-	return &energyStat
-}
-
-func (p *ProcessMetrics) GetIdleEnergyStat(component string) *types.UInt64Stat {
-	switch component {
-	case PKG:
-		return p.IdleEnergyInPkg
-	case CORE:
-		return p.IdleEnergyInCore
-	case DRAM:
-		return p.IdleEnergyInDRAM
-	case UNCORE:
-		return p.IdleEnergyInUncore
-	case GPU:
-		return p.IdleEnergyInGPU
-	case OTHER:
-		return p.IdleEnergyInOther
-	case PLATFORM:
-		return p.IdleEnergyInPlatform
-	default:
-		klog.Fatalf("IdleEnergy component type %s is unknown\n", component)
-	}
-	energyStat := types.UInt64Stat{}
-	return &energyStat
-}
diff --git a/pkg/collector/metric/process_metric_test.go b/pkg/collector/metric/process_metric_test.go
deleted file mode 100644
index be70a6f56d..0000000000
--- a/pkg/collector/metric/process_metric_test.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package metric
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-)
-
-var _ = Describe("ProcessMetric", func() {
-
-	AvailableBPFSWCounters = []string{
-		config.CPUTime,
-		config.PageCacheHit,
-	}
-
-	It("Test ResetDeltaValues", func() {
-		p := NewProcessMetrics(0, "command")
-		p.ResetDeltaValues()
-		Expect(p.BPFStats[config.CPUTime].Delta).To(Equal(uint64(0)))
-	})
-
-	It("Test SumAllDynDeltaValues", func() {
-		p := NewProcessMetrics(0, "command")
-		exp := p.DynEnergyInPkg.Delta + p.DynEnergyInGPU.Delta + p.DynEnergyInOther.Delta
-		cur := p.SumAllDynDeltaValues()
-		Expect(exp).To(Equal(cur))
-	})
-
-	It("Test SumAllDynAggrValues", func() {
-		p := NewProcessMetrics(0, "command")
-		exp := p.DynEnergyInPkg.Aggr + p.DynEnergyInGPU.Aggr + p.DynEnergyInOther.Aggr
-		cur := p.SumAllDynAggrValues()
-		Expect(exp).To(Equal(cur))
-	})
-})
diff --git a/pkg/collector/metric/stats.go b/pkg/collector/metric/stats.go
deleted file mode 100644
index 5d88156fc9..0000000000
--- a/pkg/collector/metric/stats.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package metric
-
-import (
-	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
-	"github.com/sustainable-computing-io/kepler/pkg/cgroup"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-)
-
-const (
-	// TO-DO: merge to cgroup stat
-	ByteReadLabel    = config.BytesReadIO
-	ByteWriteLabel   = config.BytesWriteIO
-	blockDeviceLabel = config.BlockDevicesIO
-
-	DeltaPrefix = "curr_"
-	AggrPrefix  = "total_"
-)
-
-var (
-	// AvailableBPFSWCounters holds a list of eBPF counters that might be collected
-	AvailableBPFSWCounters []string
-	// AvailableBPFHWCounters holds a list of hardware counters that might be collected
-	AvailableBPFHWCounters []string
-	// AvailableCGroupMetrics holds a list of cgroup metrics exposed by the cgroup that might be collected
-	AvailableCGroupMetrics []string
-	// AvailableKubeletMetrics holds a list of cgrpup metrics exposed by kubelet that might be collected
-	AvailableKubeletMetrics []string
-	// AvailableContainerKubeletMetrics holds a list of cgrpup metrics exposed by kubelet specific to container
-	AvailableContainerKubeletMetrics []string
-	// AvailableNodeKubeletMetrics holds a list of cgroup metrics exposed by kubelet specific to node
-	AvailableNodeKubeletMetrics []string
-	// CPUHardwareCounterEnabled defined if hardware counters should be accounted and exported
-	CPUHardwareCounterEnabled = false
-)
-
-func InitAvailableParamAndMetrics() {
-	AvailableBPFHWCounters = attacher.GetEnabledBPFHWCounters()
-	AvailableBPFSWCounters = attacher.GetEnabledBPFSWCounters()
-	AvailableCGroupMetrics = []string{
-		config.CgroupfsMemory, config.CgroupfsKernelMemory, config.CgroupfsTCPMemory,
-		config.CgroupfsCPU, config.CgroupfsSystemCPU, config.CgroupfsUserCPU,
-		config.CgroupfsReadIO, config.CgroupfsWriteIO, config.BlockDevicesIO,
-	}
-	AvailableKubeletMetrics = cgroup.GetAvailableKubeletMetrics()
-	CPUHardwareCounterEnabled = isCounterStatEnabled(attacher.CPUInstructionLabel)
-
-	// defined in utils to init metrics
-	setEnabledMetrics()
-}
diff --git a/pkg/collector/metric/vm_metric.go b/pkg/collector/metric/vm_metric.go
deleted file mode 100644
index 414e9c91f9..0000000000
--- a/pkg/collector/metric/vm_metric.go
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-Copyright 2023.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package metric
-
-import (
-	"github.com/sustainable-computing-io/kepler/pkg/collector/metric/types"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
-)
-
-var (
-	// VMMetricNames holds the list of names of the vm metric
-	VMMetricNames []string
-	// VMFloatFeatureNames holds the feature name of the vm float collector_metric. This is specific for the machine-learning based models.
-	VMFloatFeatureNames []string = []string{}
-	// VMUintFeaturesNames holds the feature name of the vm utint collector_metric. This is specific for the machine-learning based models.
-	VMUintFeaturesNames []string
-	// VMFeaturesNames holds all the feature name of the vm collector_metric. This is specific for the machine-learning based models.
-	VMFeaturesNames []string
-)
-
-type VMMetrics struct {
-	PID      uint64
-	Name     string
-	BPFStats map[string]*types.UInt64Stat
-	// ebpf metrics
-	DynEnergyInCore     *types.UInt64Stat
-	DynEnergyInDRAM     *types.UInt64Stat
-	DynEnergyInUncore   *types.UInt64Stat
-	DynEnergyInPkg      *types.UInt64Stat
-	DynEnergyInGPU      *types.UInt64Stat
-	DynEnergyInOther    *types.UInt64Stat
-	DynEnergyInPlatform *types.UInt64Stat
-
-	IdleEnergyInCore     *types.UInt64Stat
-	IdleEnergyInDRAM     *types.UInt64Stat
-	IdleEnergyInUncore   *types.UInt64Stat
-	IdleEnergyInPkg      *types.UInt64Stat
-	IdleEnergyInGPU      *types.UInt64Stat
-	IdleEnergyInOther    *types.UInt64Stat
-	IdleEnergyInPlatform *types.UInt64Stat
-}
-
-// NewVMMetrics creates a new VMMetrics instance
-func NewVMMetrics(pid uint64, name string) *VMMetrics {
-	p := &VMMetrics{
-		PID:                  pid,
-		Name:                 name,
-		BPFStats:             make(map[string]*types.UInt64Stat),
-		DynEnergyInCore:      &types.UInt64Stat{},
-		DynEnergyInDRAM:      &types.UInt64Stat{},
-		DynEnergyInUncore:    &types.UInt64Stat{},
-		DynEnergyInPkg:       &types.UInt64Stat{},
-		DynEnergyInOther:     &types.UInt64Stat{},
-		DynEnergyInGPU:       &types.UInt64Stat{},
-		DynEnergyInPlatform:  &types.UInt64Stat{},
-		IdleEnergyInCore:     &types.UInt64Stat{},
-		IdleEnergyInDRAM:     &types.UInt64Stat{},
-		IdleEnergyInUncore:   &types.UInt64Stat{},
-		IdleEnergyInPkg:      &types.UInt64Stat{},
-		IdleEnergyInOther:    &types.UInt64Stat{},
-		IdleEnergyInGPU:      &types.UInt64Stat{},
-		IdleEnergyInPlatform: &types.UInt64Stat{},
-	}
-	for _, metricName := range AvailableBPFSWCounters {
-		p.BPFStats[metricName] = &types.UInt64Stat{}
-	}
-	for _, metricName := range AvailableBPFHWCounters {
-		p.BPFStats[metricName] = &types.UInt64Stat{}
-	}
-	// TODO: transparently list the other metrics and do not initialize them when they are not supported, e.g. HC
-	if gpu.IsGPUCollectionSupported() {
-		p.BPFStats[config.GPUSMUtilization] = &types.UInt64Stat{}
-		p.BPFStats[config.GPUMemUtilization] = &types.UInt64Stat{}
-	}
-	return p
-}
-
-// ResetCurr reset all current value to 0
-func (p *VMMetrics) ResetDeltaValues() {
-	for counterKey := range p.BPFStats {
-		p.BPFStats[counterKey].ResetDeltaValues()
-	}
-	p.DynEnergyInCore.ResetDeltaValues()
-	p.DynEnergyInDRAM.ResetDeltaValues()
-	p.DynEnergyInUncore.ResetDeltaValues()
-	p.DynEnergyInPkg.ResetDeltaValues()
-	p.DynEnergyInOther.ResetDeltaValues()
-	p.DynEnergyInGPU.ResetDeltaValues()
-	p.DynEnergyInPlatform.ResetDeltaValues()
-	p.IdleEnergyInCore.ResetDeltaValues()
-	p.IdleEnergyInDRAM.ResetDeltaValues()
-	p.IdleEnergyInUncore.ResetDeltaValues()
-	p.IdleEnergyInPkg.ResetDeltaValues()
-	p.IdleEnergyInOther.ResetDeltaValues()
-	p.IdleEnergyInGPU.ResetDeltaValues()
-	p.IdleEnergyInPlatform.ResetDeltaValues()
-}
diff --git a/pkg/collector/metric/vm_metric_test.go b/pkg/collector/metric/vm_metric_test.go
deleted file mode 100644
index 2f9a89ffe6..0000000000
--- a/pkg/collector/metric/vm_metric_test.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package metric
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-)
-
-var _ = Describe("VMMetric", func() {
-
-	It("Test ResetDeltaValues", func() {
-		p := NewVMMetrics(0, "name")
-		p.ResetDeltaValues()
-		Expect(p.BPFStats[config.CPUTime].Delta).To(Equal(uint64(0)))
-	})
-})
diff --git a/pkg/collector/metric_collector.go b/pkg/collector/metric_collector.go
index f1d2e8f09d..c732edd906 100644
--- a/pkg/collector/metric_collector.go
+++ b/pkg/collector/metric_collector.go
@@ -18,54 +18,53 @@ package collector
 
 import (
 	"fmt"
+	"os"
+	"sync"
+	"syscall"
 	"time"
 
 	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
-	"github.com/sustainable-computing-io/kepler/pkg/cgroup"
+	cgroup_api "github.com/sustainable-computing-io/kepler/pkg/cgroup"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/energy"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/resourceutilization/accelerator"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/resourceutilization/bpf"
+	cgroup_collector "github.com/sustainable-computing-io/kepler/pkg/collector/resourceutilization/cgroup"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
 	"github.com/sustainable-computing-io/kepler/pkg/model"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/qat"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/qat"
 	"github.com/sustainable-computing-io/kepler/pkg/utils"
 
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
-
-	corev1 "k8s.io/api/core/v1"
 	"k8s.io/klog/v2"
 )
 
 const (
-	maxInactiveContainers = 10
-	maxInactiveProcesses  = 5
-	maxInactiveVM         = 3
+	maxInactiveContainers        = 10
+	maxInactiveVM                = 3
+	procPath              string = "/proc/%d/cgroup"
 )
 
 type Collector struct {
-	// NodeMetrics holds all node energy and resource usage metrics
-	NodeMetrics collector_metric.NodeMetrics
-
-	// ContainersMetrics holds all container energy and resource usage metrics
-	ContainersMetrics map[string]*collector_metric.ContainerMetrics
+	// NodeStats holds all node energy and resource usage metrics
+	NodeStats stats.NodeStats
 
-	// ProcessMetrics hold all process energy and resource usage metrics
-	ProcessMetrics map[uint64]*collector_metric.ProcessMetrics
+	// ProcessStats hold all process energy and resource usage metrics
+	ProcessStats map[uint64]*stats.ProcessStats
 
-	// VMMetrics hold all Virtual Machine energy and resource usage metrics
-	VMMetrics map[uint64]*collector_metric.VMMetrics
+	// ContainerStats holds the aggregated processes metrics for all containers
+	ContainerStats map[string]*stats.ContainerStats
 
-	// generic names to be used for process that are not within a pod
-	systemProcessName      string
-	systemProcessNamespace string
+	// VMStats holds the aggregated processes metrics for all virtual machines
+	VMStats map[string]*stats.VMStats
 }
 
 func NewCollector() *Collector {
 	c := &Collector{
-		NodeMetrics:            *collector_metric.NewNodeMetrics(),
-		ContainersMetrics:      map[string]*collector_metric.ContainerMetrics{},
-		ProcessMetrics:         map[uint64]*collector_metric.ProcessMetrics{},
-		VMMetrics:              map[uint64]*collector_metric.VMMetrics{},
-		systemProcessName:      utils.SystemProcessName,
-		systemProcessNamespace: utils.SystemProcessNamespace,
+		NodeStats:      *stats.NewNodeStats(),
+		ContainerStats: map[string]*stats.ContainerStats{},
+		ProcessStats:   map[uint64]*stats.ProcessStats{},
+		VMStats:        map[string]*stats.VMStats{},
 	}
 	return c
 }
@@ -76,23 +75,22 @@ func (c *Collector) Initialize() error {
 		return fmt.Errorf("failed to attach bpf assets: %v", err)
 	}
 
-	pods, err := cgroup.Init()
-	if err != nil && !config.EnableProcessMetrics {
-		klog.V(5).Infoln(err)
-		return err
+	if config.IsCgroupMetricsEnabled() {
+		_, err = cgroup_api.Init()
+		if err != nil && !config.EnableProcessStats {
+			klog.V(5).Infoln(err)
+			return err
+		}
 	}
 
 	// For local estimator, there is endpoint provided, thus we should let
 	// model component decide whether/how to init
 	model.CreatePowerEstimatorModels(
-		collector_metric.ContainerFeaturesNames,
-		collector_metric.NodeMetadataFeatureNames,
-		collector_metric.NodeMetadataFeatureValues,
+		stats.ProcessFeaturesNames,
+		stats.NodeMetadataFeatureNames,
+		stats.NodeMetadataFeatureValues,
 	)
 
-	c.prePopulateContainerMetrics(pods)
-	c.updateNodeEnergyMetrics()
-
 	return nil
 }
 
@@ -104,87 +102,243 @@ func (c *Collector) Destroy() {
 func (c *Collector) Update() {
 	start := time.Now()
 
-	// reset the previous collected value because not all containers will have new data
-	// that is, a container that was inactive will not have any update but we need to set its metrics to 0
+	// reset the previous collected value because not all process will have new data
+	// that is, a process that was inactive will not have any update but we need to set its metrics to 0
 	c.resetDeltaValue()
 
-	// update container metrics regarding the resource utilization to be used to calculate the energy consumption
-	// we first updates the bpf which is resposible to include new containers in the ContainersMetrics collection
-	// the bpf collects metrics per processes and then map the process ids to container ids
-	// TODO: when bpf is not running, the ContainersMetrics will not be updated with new containers.
-	// The ContainersMetrics will only have the containers that were identified during the initialization (initContainersMetrics)
-	c.updateBPFMetrics() // collect new hardware counter metrics if possible
+	// collect process resource utilization and aggregate it per node, container and VMs
+	c.updateResourceUtilizationMetrics()
 
-	// TODO: collect cgroup metrics only from cgroup to avoid unnecessary overhead to kubelet
-	if config.IsCgroupMetricsEnabled() {
-		c.updateCgroupMetrics() // collect new cgroup metrics from cgroup
+	// collect node power and estimate process power
+	c.UpdateEnergyUtilizationMetrics()
+
+	c.printDebugMetrics()
+	klog.V(5).Infof("Collector Update elapsed time: %s", time.Since(start))
+}
+
+// resetDeltaValue resets existing podEnergy previous curr value
+func (c *Collector) resetDeltaValue() {
+	c.NodeStats.ResetDeltaValues()
+	for _, v := range c.ProcessStats {
+		v.ResetDeltaValues()
 	}
+	if config.IsExposeContainerStatsEnabled() {
+		for _, v := range c.ContainerStats {
+			v.ResetDeltaValues()
+		}
+	}
+	if config.IsExposeVMStatsEnabled() {
+		for _, v := range c.VMStats {
+			v.ResetDeltaValues()
+		}
+	}
+}
+
+func (c *Collector) UpdateEnergyUtilizationMetrics() {
+	c.UpdateNodeEnergyUtilizationMetrics()
+	c.UpdateProcessEnergyUtilizationMetrics()
+	// aggregate the process metrics per container and/or VMs
+	c.AggregateProcessEnergyUtilizationMetrics()
+}
+
+// UpdateEnergyUtilizationMetrics collects real-time node's resource power utilization
+// if there is no real-time power meter, use the container's resource usage metrics to estimate the node's resource power
+func (c *Collector) UpdateNodeEnergyUtilizationMetrics() {
+	energy.UpdateNodeEnergyMetrics(&c.NodeStats)
+}
+
+// UpdateProcessEnergyUtilizationMetrics estimates the process energy consumption using its resource utilization and the node components energy consumption
+func (c *Collector) UpdateProcessEnergyUtilizationMetrics() {
+	energy.UpdateProcessEnergy(c.ProcessStats, &c.NodeStats)
+}
+
+func (c *Collector) updateResourceUtilizationMetrics() {
+	var wg sync.WaitGroup
+	wg.Add(2)
+	c.updateNodeResourceUtilizationMetrics(&wg)
+	c.updateProcessResourceUtilizationMetrics(&wg)
+	wg.Wait()
+	// aggregate processes' resource utilization metrics to containers, virtual machines and nodes
+	c.AggregateProcessResourceUtilizationMetrics()
+	// update the deprecated cgroup metrics. Note that we only call this function after all process metrics were aggregated per container
+	c.updateContainerResourceUtilizationMetrics()
+}
+
+// updateNodeAvgCPUFrequencyFromEBPF updates the average CPU frequency in each core
+func (c *Collector) updateNodeAvgCPUFrequencyFromEBPF() {
+	// update the cpu frequency using hardware counters when available because reading files can be very expensive
+	if config.IsExposeCPUFrequencyMetricsEnabled() && attacher.HardwareCountersEnabled {
+		cpuFreq, err := attacher.CollectCPUFreq()
+		if err == nil {
+			for cpu, freq := range cpuFreq {
+				c.NodeStats.EnergyUsage[config.CPUFrequency].SetDeltaStat(fmt.Sprintf("%d", cpu), freq)
+			}
+		}
+	}
+}
 
+// update the node metrics that are not related to aggregated resource utilization of processes
+func (c *Collector) updateNodeResourceUtilizationMetrics(wg *sync.WaitGroup) {
+	defer wg.Done()
 	if config.EnabledGPU && gpu.IsGPUCollectionSupported() {
-		c.updateGPUMetrics()
+		accelerator.UpdateNodeGPUUtilizationMetrics(c.ProcessStats)
 	}
 
-	if config.EnabledQAT && qat.IsQATCollectionSupported() {
-		c.updateQATMetrics()
+	if config.IsExposeQATMetricsEnabled() && qat.IsQATCollectionSupported() {
+		accelerator.UpdateNodeQATMetrics(stats.NewNodeStats())
 	}
 
-	// use the container's resource usage metrics to update the node metrics
-	c.updateNodeResourceUsage()
-	c.updateNodeEnergyMetrics()
+	if config.ExposeCPUFrequencyMetrics {
+		c.updateNodeAvgCPUFrequencyFromEBPF()
+	}
+}
 
-	// calculate the container energy consumption using its resource utilization and the node components energy consumption
-	c.updateContainerEnergy()
+func (c *Collector) updateProcessResourceUtilizationMetrics(wg *sync.WaitGroup) {
+	defer wg.Done()
+	// update process metrics regarding the resource utilization to be used to calculate the energy consumption
+	// we first updates the bpf which is resposible to include new processes in the ProcessStats collection
+	bpf.UpdateProcessBPFMetrics(c.ProcessStats)
+}
 
-	// calculate the process energy consumption using its resource utilization and the node components energy consumption
-	if config.EnableProcessMetrics {
-		c.updateProcessEnergy()
-		c.updateVMEnergy()
+// this is only for cgroup metrics, as these metrics are deprecated we might remove thi in the future
+func (c *Collector) updateContainerResourceUtilizationMetrics() {
+	if config.IsExposeContainerStatsEnabled() {
+		if config.IsCgroupMetricsEnabled() {
+			// collect cgroup metrics from cgroup api
+			cgroup_collector.UpdateContainerCgroupMetrics(c.ContainerStats)
+		}
 	}
+}
 
-	// check the log verbosity level before iterating in all container
-	if klog.V(3).Enabled() {
-		for _, v := range c.ContainersMetrics {
-			klog.V(3).Infoln(v)
+// AggregateProcessResourceUtilizationMetrics aggregates processes' resource utilization metrics to containers, virtual machines and nodes
+func (c *Collector) AggregateProcessResourceUtilizationMetrics() {
+	foundContainer := make(map[string]bool)
+	foundVM := make(map[string]bool)
+	for _, process := range c.ProcessStats {
+		if process.IdleCounter > 0 {
+			// if the process metrics were not updated for multiple interations, very if the process still exist, otherwise delete it from the map
+			c.handleIdlingProcess(process)
+		}
+		for metricName, resource := range process.ResourceUsage {
+			for id := range resource.Stat {
+				delta := resource.Stat[id].GetDelta() // currently the process metrics are single socket
+
+				// aggregate metrics per container
+				if config.IsExposeContainerStatsEnabled() {
+					if process.ContainerID != "" {
+						c.createContainerStatsIfNotExist(process.ContainerID, process.CGroupID, process.PID, config.EnabledEBPFCgroupID)
+						c.ContainerStats[process.ContainerID].ResourceUsage[metricName].AddDeltaStat(id, delta)
+						foundContainer[process.ContainerID] = true
+					}
+				}
+
+				// aggregate metrics per Virtual Machine
+				if config.IsExposeVMStatsEnabled() {
+					if process.VMID != "" {
+						if _, ok := c.VMStats[process.VMID]; !ok {
+							c.VMStats[process.VMID] = stats.NewVMStats(process.PID, process.VMID)
+						}
+						c.VMStats[process.VMID].ResourceUsage[metricName].AddDeltaStat(id, delta)
+						foundVM[process.VMID] = true
+					}
+				}
+
+				// aggregate metrics from all process to represent the node resource utilization
+				c.NodeStats.ResourceUsage[metricName].AddDeltaStat(id, delta)
+			}
 		}
-		klog.V(3).Infoln(c.NodeMetrics.String())
 	}
-	klog.V(5).Infof("Collector Update elapsed time: %s", time.Since(start))
-}
 
-// resetDeltaValue reset existing podEnergy previous curr value
-func (c *Collector) resetDeltaValue() {
-	for _, v := range c.ContainersMetrics {
-		v.ResetDeltaValues()
+	// clean up the cache
+	// TODO: improve the removal of deleted containers from ContainerStats. Currently we verify the maxInactiveContainers using the found map
+	if config.IsExposeContainerStatsEnabled() {
+		c.handleInactiveContainers(foundContainer)
 	}
-	for _, v := range c.ProcessMetrics {
-		v.ResetDeltaValues()
+	if config.IsExposeVMStatsEnabled() {
+		c.handleInactiveVM(foundVM)
 	}
-	c.NodeMetrics.ResetDeltaValues()
 }
 
-// init adds the information of containers that were already running before kepler has been created
-// This is a necessary hacking to export metrics of idle containers, since we can only include in
-// the containers list the containers that present any updates from the bpf metrics
-func (c *Collector) prePopulateContainerMetrics(pods *[]corev1.Pod) {
-	if pods == nil {
+// handleInactiveProcesses
+func (c *Collector) handleIdlingProcess(pStat *stats.ProcessStats) {
+	proc, _ := os.FindProcess(int(pStat.PID))
+	err := proc.Signal(syscall.Signal(0))
+	if err != nil {
+		// delete if the process does not exist anymore
+		delete(c.ProcessStats, pStat.PID)
 		return
 	}
-	for i := 0; i < len(*pods); i++ {
-		pod := (*pods)[i]
-		for j := 0; j < len(pod.Status.InitContainerStatuses); j++ {
-			container := pod.Status.InitContainerStatuses[j]
-			containerID := cgroup.ParseContainerIDFromPodStatus(container.ContainerID)
-			c.ContainersMetrics[containerID] = collector_metric.NewContainerMetrics(container.Name, pod.Name, pod.Namespace, containerID)
+}
+
+// handleInactiveContainers
+func (c *Collector) handleInactiveContainers(foundContainer map[string]bool) {
+	numOfInactive := len(c.ContainerStats) - len(foundContainer)
+	if numOfInactive > maxInactiveContainers {
+		aliveContainers, err := cgroup_api.GetAliveContainers()
+		if err != nil {
+			klog.V(5).Infoln(err)
+			return
+		}
+		for containerID := range c.ContainerStats {
+			if containerID == utils.SystemProcessName || containerID == utils.KernelProcessName {
+				continue
+			}
+			if _, found := aliveContainers[containerID]; !found {
+				delete(c.ContainerStats, containerID)
+			}
 		}
-		for j := 0; j < len(pod.Status.ContainerStatuses); j++ {
-			container := pod.Status.ContainerStatuses[j]
-			containerID := cgroup.ParseContainerIDFromPodStatus(container.ContainerID)
-			c.ContainersMetrics[containerID] = collector_metric.NewContainerMetrics(container.Name, pod.Name, pod.Namespace, containerID)
+	}
+}
+
+// handleInactiveVirtualMachine
+func (c *Collector) handleInactiveVM(foundVM map[string]bool) {
+	numOfInactive := len(c.VMStats) - len(foundVM)
+	if numOfInactive > maxInactiveVM {
+		for vmID := range c.VMStats {
+			if _, found := foundVM[vmID]; !found {
+				delete(c.VMStats, vmID)
+			}
+		}
+	}
+}
+
+// AggregateProcessEnergyUtilizationMetrics aggregates processes' utilization metrics to containers and virtual machines
+func (c *Collector) AggregateProcessEnergyUtilizationMetrics() {
+	for _, process := range c.ProcessStats {
+		for metricName, stat := range process.EnergyUsage {
+			for id := range stat.Stat {
+				delta := stat.Stat[id].GetDelta() // currently the process metrics are single socket
+
+				// aggregate metrics per container
+				if config.IsExposeContainerStatsEnabled() {
+					if process.ContainerID != "" {
+						c.createContainerStatsIfNotExist(process.ContainerID, process.CGroupID, process.PID, config.EnabledEBPFCgroupID)
+						c.ContainerStats[process.ContainerID].EnergyUsage[metricName].AddDeltaStat(id, delta)
+					}
+				}
+
+				// aggregate metrics per Virtual Machine
+				if config.IsExposeVMStatsEnabled() {
+					if process.VMID != "" {
+						if _, ok := c.VMStats[process.VMID]; !ok {
+							c.VMStats[process.VMID] = stats.NewVMStats(process.PID, process.VMID)
+						}
+						c.VMStats[process.VMID].EnergyUsage[metricName].AddDeltaStat(id, delta)
+					}
+				}
+			}
 		}
-		for j := 0; j < len(pod.Status.EphemeralContainerStatuses); j++ {
-			container := pod.Status.EphemeralContainerStatuses[j]
-			containerID := cgroup.ParseContainerIDFromPodStatus(container.ContainerID)
-			c.ContainersMetrics[containerID] = collector_metric.NewContainerMetrics(container.Name, pod.Name, pod.Namespace, containerID)
+	}
+}
+
+func (c *Collector) printDebugMetrics() {
+	// check the log verbosity level before iterating in all container
+	if klog.V(3).Enabled() {
+		if config.IsExposeContainerStatsEnabled() {
+			for _, v := range c.ContainerStats {
+				klog.V(3).Infoln(v)
+			}
 		}
+		klog.V(3).Infoln(c.NodeStats.String())
 	}
 }
diff --git a/pkg/collector/metric_collector_test.go b/pkg/collector/metric_collector_test.go
index 0496c29f83..1f0bb117aa 100644
--- a/pkg/collector/metric_collector_test.go
+++ b/pkg/collector/metric_collector_test.go
@@ -3,178 +3,66 @@ package collector
 import (
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
 	"github.com/sustainable-computing-io/kepler/pkg/model"
 
 	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
 	"github.com/sustainable-computing-io/kepler/pkg/cgroup"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
-	"github.com/sustainable-computing-io/kepler/pkg/power/platform"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/platform"
 )
 
-// we need to add all metric to a container, otherwise it will not create the right usageMetric with all elements. The usageMetric is used in the Prediction Power Models
-// TODO: do not use a fixed usageMetric array in the power models, a structured data is more disarable.
-func setCollectorMetrics() {
-	// initialize the Available metrics since they are used to create a new containersMetrics instance
-	collector_metric.AvailableBPFHWCounters = []string{
-		config.CPUCycle,
-		config.CPUInstruction,
-		config.CacheMiss,
-	}
-	collector_metric.AvailableBPFSWCounters = []string{
-		config.CPUTime,
-		config.PageCacheHit,
-	}
-	collector_metric.AvailableCGroupMetrics = []string{
-		config.CgroupfsMemory,
-		config.CgroupfsKernelMemory,
-		config.CgroupfsTCPMemory,
-		config.CgroupfsCPU,
-		config.CgroupfsSystemCPU,
-		config.CgroupfsUserCPU,
-		config.CgroupfsReadIO,
-		config.CgroupfsWriteIO,
-		config.BlockDevicesIO,
-	}
-	collector_metric.AvailableKubeletMetrics = []string{
-		config.KubeletCPUUsage,
-		config.KubeletMemoryUsage,
-	}
-	collector_metric.ContainerUintFeaturesNames = []string{}
-	collector_metric.ContainerUintFeaturesNames = append(collector_metric.ContainerUintFeaturesNames, collector_metric.AvailableBPFSWCounters...)
-	collector_metric.ContainerUintFeaturesNames = append(collector_metric.ContainerUintFeaturesNames, collector_metric.AvailableBPFHWCounters...)
-	collector_metric.ContainerUintFeaturesNames = append(collector_metric.ContainerUintFeaturesNames, collector_metric.AvailableCGroupMetrics...)
-	collector_metric.ContainerUintFeaturesNames = append(collector_metric.ContainerUintFeaturesNames, collector_metric.AvailableKubeletMetrics...)
-	// ContainerFeaturesNames is used by the nodeMetrics to extract the resource usage. Only the metrics in ContainerFeaturesNames will be used.
-	collector_metric.ContainerFeaturesNames = collector_metric.ContainerUintFeaturesNames
-	collector_metric.CPUHardwareCounterEnabled = true
-}
-
-// add two containers with all metrics initialized
-func createMockContainersMetrics() map[string]*collector_metric.ContainerMetrics {
-	containersMetrics := map[string]*collector_metric.ContainerMetrics{}
-	containersMetrics["containerA"] = createMockContainerMetrics("containerA", "podA", "test")
-	containersMetrics["containerB"] = createMockContainerMetrics("containerB", "podB", "test")
-
-	return containersMetrics
-}
-
-// see usageMetrics for the list of used metrics. For the sake of visibility we add all metrics, but only few of them will be used.
-func createMockContainerMetrics(containerName, podName, namespace string) *collector_metric.ContainerMetrics {
-	containerMetrics := collector_metric.NewContainerMetrics(containerName, podName, namespace, containerName)
-	// counter - attacher package
-	err := containerMetrics.BPFStats[config.CPUCycle].AddNewDelta(30000)
-	Expect(err).NotTo(HaveOccurred())
-	err = containerMetrics.BPFStats[config.CPUInstruction].AddNewDelta(30000)
-	Expect(err).NotTo(HaveOccurred())
-	err = containerMetrics.BPFStats[config.CacheMiss].AddNewDelta(30000)
-	Expect(err).NotTo(HaveOccurred())
-	// bpf - cpu time
-	err = containerMetrics.BPFStats[config.CPUTime].AddNewDelta(30000) // config.CPUTime
-	Expect(err).NotTo(HaveOccurred())
-	// cgroup - cgroup package
-	// we need to add two aggregated values to the stats so that it can calculate a current value (i.e. agg diff)
-	// cgroup memory is expressed in bytes, to make it meaninful we set 1MB
-	// since kepler collects metrics for every 3s, the metrics will be normalized by 3 to estimate power, because of that to make the test easier we create delta  as multiple of 3
-	containerMetrics.CgroupStatMap[config.CgroupfsMemory].SetAggrStat(containerName, 1000000)
-	containerMetrics.CgroupStatMap[config.CgroupfsMemory].SetAggrStat(containerName, 4000000) // delta is 30MB
-	// cgroup kernel memory is expressed in bytes, to make it meaninful we set 100KB
-	containerMetrics.CgroupStatMap[config.CgroupfsKernelMemory].SetAggrStat(containerName, 100000)
-	containerMetrics.CgroupStatMap[config.CgroupfsKernelMemory].SetAggrStat(containerName, 400000) // delta is 30KB
-	containerMetrics.CgroupStatMap[config.CgroupfsTCPMemory].SetAggrStat(containerName, 100000)
-	containerMetrics.CgroupStatMap[config.CgroupfsTCPMemory].SetAggrStat(containerName, 400000)
-	// cgroup cpu time is expressed in microseconds, to make it meaninful we set it to 10ms
-	containerMetrics.CgroupStatMap[config.CgroupfsCPU].SetAggrStat(containerName, 10000)
-	containerMetrics.CgroupStatMap[config.CgroupfsCPU].SetAggrStat(containerName, 40000)
-	// cgroup cpu time is expressed in microseconds, to make it meaninful we set it to 1ms
-	containerMetrics.CgroupStatMap[config.CgroupfsSystemCPU].SetAggrStat(containerName, 1000)
-	containerMetrics.CgroupStatMap[config.CgroupfsSystemCPU].SetAggrStat(containerName, 4000)
-	containerMetrics.CgroupStatMap[config.CgroupfsUserCPU].SetAggrStat(containerName, 1000)
-	containerMetrics.CgroupStatMap[config.CgroupfsUserCPU].SetAggrStat(containerName, 4000)
-	// cgroup read and write IO are expressed in bytes, to make it meaninful we set 10KB
-	containerMetrics.CgroupStatMap[config.CgroupfsReadIO].SetAggrStat(containerName, 10000)
-	containerMetrics.CgroupStatMap[config.CgroupfsReadIO].SetAggrStat(containerName, 40000)
-	containerMetrics.CgroupStatMap[config.CgroupfsWriteIO].SetAggrStat(containerName, 10000)
-	containerMetrics.CgroupStatMap[config.CgroupfsWriteIO].SetAggrStat(containerName, 40000)
-	containerMetrics.CgroupStatMap[config.BlockDevicesIO].SetAggrStat(containerName, 1)
-	containerMetrics.CgroupStatMap[config.BlockDevicesIO].SetAggrStat(containerName, 1)
-	return containerMetrics
-}
-
-func createMockNodeMetrics(containersMetrics map[string]*collector_metric.ContainerMetrics) collector_metric.NodeMetrics {
-	nodeMetrics := *collector_metric.NewNodeMetrics()
-	nodeMetrics.AddNodeResUsageFromContainerResUsage(containersMetrics)
-	componentsEnergies := make(map[int]source.NodeComponentsEnergy)
-	machineSocketID := 0
-
-	// the NodeComponentsEnergy is the aggregated energy consumption of the node components
-	// then, the components energy consumption is added to the in the nodeMetrics as Agg data
-	// this means that, to have a Curr value, we must have at least two Agg data (to have Agg diff)
-	// therefore, we need to add two values for NodeComponentsEnergy to have energy values to test
-	componentsEnergies[machineSocketID] = source.NodeComponentsEnergy{
-		Pkg:  10,
-		Core: 10,
-		DRAM: 10,
-	}
-	nodeMetrics.SetNodeComponentsEnergy(componentsEnergies, false, false)
-	componentsEnergies[machineSocketID] = source.NodeComponentsEnergy{
-		Pkg:  18,
-		Core: 15,
-		DRAM: 11,
+func newMockCollector() *Collector {
+	if gpu.IsGPUCollectionSupported() {
+		err := gpu.Init() // create structure instances that will be accessed to create a containerMetric
+		Expect(err).NotTo(HaveOccurred())
 	}
-	nodeMetrics.SetNodeComponentsEnergy(componentsEnergies, false, false)
+	// we need to disable the system real time power metrics for testing since we add mock values or use power model estimator
+	components.SetIsSystemCollectionSupported(false)
+	platform.SetIsSystemCollectionSupported(false)
+	gpu.SetGPUCollectionSupported(false)
 
-	return nodeMetrics
-}
+	cgroup.AddContainerIDToCache(0, "container1")
+	cgroup.AddContainerIDToCache(1, "container2")
+	stats.SetMockedCollectorMetrics()
 
-func newMockCollector() *Collector {
 	metricCollector := NewCollector()
-	metricCollector.ContainersMetrics = createMockContainersMetrics()
-	metricCollector.ProcessMetrics = map[uint64]*collector_metric.ProcessMetrics{}
-	metricCollector.VMMetrics = map[uint64]*collector_metric.VMMetrics{}
-	metricCollector.NodeMetrics = createMockNodeMetrics(metricCollector.ContainersMetrics)
+	metricCollector.ProcessStats = stats.CreateMockedProcessStats(2)
+	metricCollector.NodeStats = stats.CreateMockedNodeStats()
+	// aggregate processes' resource utilization metrics to containers, virtual machines and nodes
+	metricCollector.AggregateProcessResourceUtilizationMetrics()
 
 	return metricCollector
 }
 
 var _ = Describe("Test Collector Unit", func() {
-	BeforeEach(func() {
-		if gpu.IsGPUCollectionSupported() {
-			err := gpu.Init() // create structure instances that will be accessed to create a containerMetric
-			Expect(err).NotTo(HaveOccurred())
-		}
-		gpu.SetGPUCollectionSupported(true)
-		cgroup.AddContainerIDToCache(0, "containerA")
-		cgroup.AddContainerIDToCache(1, "containerB")
-		setCollectorMetrics()
-		// we need to disable the system real time power metrics for testing since we add mock values or use power model estimator
-		components.SetIsSystemCollectionSupported(false)
-		platform.SetIsSystemCollectionSupported(false)
-	})
 
 	It("Get container power", func() {
 		attacher.HardwareCountersEnabled = false
 		metricCollector := newMockCollector()
 		// The default estimator model is the ratio
-		model.CreatePowerEstimatorModels(collector_metric.ContainerFeaturesNames, collector_metric.NodeMetadataFeatureNames, collector_metric.NodeMetadataFeatureValues)
+		model.CreatePowerEstimatorModels(stats.ProcessFeaturesNames, stats.NodeMetadataFeatureNames, stats.NodeMetadataFeatureValues)
 		// update container and node metrics
-		metricCollector.updateGPUMetrics()
-		metricCollector.updateNodeResourceUsage()
-		metricCollector.updateNodeEnergyMetrics()
-		metricCollector.updateContainerEnergy()
-		Expect(metricCollector.ContainersMetrics["containerA"].DynEnergyInPkg.Delta).ShouldNot(BeNil())
+		metricCollector.UpdateProcessEnergyUtilizationMetrics()
+		metricCollector.AggregateProcessEnergyUtilizationMetrics()
+		dynEnergyInPkg := metricCollector.ContainerStats["container1"].EnergyUsage[config.DynEnergyInPkg].SumAllDeltaValues()
+		// The node components dynamic power were set to 35000mJ, since the kepler interval is 3s, the power is 11667mJ
+		// The test created 2 processes with 30000 CPU Instructions
+		// So the node total CPU Instructions is 60000
+		// The process power will be (30000/60000)*11667 = 5834
+		// Then, the process energy will be 5834*3 = 17502 mJ
+		Expect(dynEnergyInPkg).Should(Equal(uint64(17502)))
 	})
 
 	It("HandleInactiveContainers without error", func() {
 		metricCollector := newMockCollector()
 		foundContainer := make(map[string]bool)
-		foundContainer["containerA"] = true
-		foundContainer["containerB"] = true
+		foundContainer["container1"] = true
+		foundContainer["container2"] = true
 		metricCollector.handleInactiveContainers(foundContainer)
-		Expect(len(metricCollector.ContainersMetrics)).Should(Equal(2))
+		Expect(len(metricCollector.ContainerStats)).Should(Equal(2))
 	})
 
 })
diff --git a/pkg/collector/node_energy_collector.go b/pkg/collector/node_energy_collector.go
deleted file mode 100644
index 9ff7f14c60..0000000000
--- a/pkg/collector/node_energy_collector.go
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
-Copyright 2021.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package collector
-
-import (
-	"sync"
-
-	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/model"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components"
-	"github.com/sustainable-computing-io/kepler/pkg/power/platform"
-
-	"k8s.io/klog/v2"
-)
-
-const (
-	idlePower = true
-	absPower  = false
-	gauge     = true
-	counter   = false
-)
-
-// updateNodeResourceUsage updates node resource usage with the total container resource usage
-// The container metrics are for the kubernetes containers and system/OS processes
-// TODO: verify if the cgroup metrics are also accounting for the OS, not only containers
-func (c *Collector) updateNodeResourceUsage() {
-	c.NodeMetrics.AddNodeResUsageFromContainerResUsage(c.ContainersMetrics)
-}
-
-// updateMeasuredNodeEnergy updates the node platform power consumption, i.e, the node total power consumption
-func (c *Collector) updatePlatformEnergy() {
-	if platform.IsSystemCollectionSupported() {
-		nodePlatformEnergy, _ := platform.GetAbsEnergyFromPlatform()
-		c.NodeMetrics.SetNodePlatformEnergy(nodePlatformEnergy, gauge, absPower)
-	} else if model.IsNodePlatformPowerModelEnabled() {
-		model.UpdateNodePlatformEnergy(&c.NodeMetrics)
-	}
-}
-
-// updateMeasuredNodeEnergy updates each node component power consumption, i.e., the CPU core, uncore, package/socket and DRAM
-func (c *Collector) updateNodeComponentsEnergy(wg *sync.WaitGroup) {
-	defer wg.Done()
-	if components.IsSystemCollectionSupported() {
-		nodeComponentsEnergy := components.GetAbsEnergyFromNodeComponents()
-		// the RAPL metrics return counter metrics not gauge
-		c.NodeMetrics.SetNodeComponentsEnergy(nodeComponentsEnergy, counter, absPower)
-	} else if model.IsNodeComponentPowerModelEnabled() {
-		model.UpdateNodeComponentEnergy(&c.NodeMetrics)
-	} else {
-		klog.V(5).Info("No nodeComponentsEnergy found, node components energy metrics is not exposed ")
-	}
-}
-
-// updateNodeGPUEnergy updates each GPU power consumption. Right now we don't support other types of accelerators
-func (c *Collector) updateNodeGPUEnergy(wg *sync.WaitGroup) {
-	defer wg.Done()
-	if config.EnabledGPU {
-		gpuEnergy := gpu.GetAbsEnergyFromGPU()
-		c.NodeMetrics.SetNodeGPUEnergy(gpuEnergy, absPower)
-	}
-}
-
-// updateNodeAvgCPUFrequency updates the average CPU frequency in each core
-func (c *Collector) updateNodeAvgCPUFrequency(wg *sync.WaitGroup) {
-	defer wg.Done()
-	// update the cpu frequency using hardware counters when available because reading files can be very expensive
-	if attacher.HardwareCountersEnabled {
-		cpuFreq, err := attacher.CollectCPUFreq()
-		if err == nil {
-			c.NodeMetrics.CPUFrequency = cpuFreq
-		}
-	}
-}
-
-// updateNodeIdleEnergy calculates the node idle energy consumption based on the minimum power consumption when real-time system power metrics are accessible.
-// When the node power model estimator is utilized, the idle power is updated with the estimated power considering minimal resource utilization.
-func (c *Collector) updateNodeIdleEnergy() {
-	isComponentsSystemCollectionSupported := components.IsSystemCollectionSupported()
-	// the idle energy is only updated if we find the node using less resources than previously observed
-	// TODO: Use regression to estimate the idle power when real-time system power metrics are available, instead of relying on the minimum power consumption.
-	c.NodeMetrics.UpdateIdleEnergyWithMinValue(isComponentsSystemCollectionSupported)
-	if !isComponentsSystemCollectionSupported {
-		// if power collection on components is not supported, try using estimator to update idle energy
-		if model.IsNodeComponentPowerModelEnabled() {
-			model.UpdateNodeComponentIdleEnergy(&c.NodeMetrics)
-		}
-		if model.IsNodePlatformPowerModelEnabled() {
-			model.UpdateNodePlatformIdleEnergy(&c.NodeMetrics)
-		}
-	}
-}
-
-// updateNodeEnergyMetrics updates the node energy consumption of each component
-func (c *Collector) updateNodeEnergyMetrics() {
-	var wgNode sync.WaitGroup
-	wgNode.Add(3)
-	go c.updateNodeComponentsEnergy(&wgNode)
-	go c.updateNodeAvgCPUFrequency(&wgNode)
-	go c.updateNodeGPUEnergy(&wgNode)
-	wgNode.Wait()
-	// update platform power later to avoid race condition when using estimation power model
-	c.updatePlatformEnergy()
-
-	// after updating the total energy we calculate the idle, dynamic and other components energy
-	c.updateNodeIdleEnergy()
-	c.NodeMetrics.UpdateDynEnergy()
-	c.NodeMetrics.SetNodeOtherComponentsEnergy()
-}
diff --git a/pkg/collector/prometheus_collector.go b/pkg/collector/prometheus_collector.go
deleted file mode 100644
index 9cf6a9dafe..0000000000
--- a/pkg/collector/prometheus_collector.go
+++ /dev/null
@@ -1,820 +0,0 @@
-/*
-Copyright 2021.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-//nolint:dupl // process metrics should be here not in another package
-package collector
-
-import (
-	"fmt"
-	"sync"
-
-	"github.com/prometheus/client_golang/prometheus"
-
-	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/power/platform"
-)
-
-const (
-	namespace        = "kepler"
-	miliJouleToJoule = 1000
-)
-
-type NodeDesc struct {
-	// Node metadata
-	nodeInfo *prometheus.Desc
-
-	// Energy (counter)
-	nodeCoreJoulesTotal            *prometheus.Desc
-	nodeUncoreJoulesTotal          *prometheus.Desc
-	nodeDramJoulesTotal            *prometheus.Desc
-	nodePackageJoulesTotal         *prometheus.Desc
-	nodePlatformJoulesTotal        *prometheus.Desc
-	nodeOtherComponentsJoulesTotal *prometheus.Desc
-	nodeGPUJoulesTotal             *prometheus.Desc
-
-	// Additional metrics (gauge)
-	// TODO: review if we really need to expose this metric.
-	NodeCPUFrequency *prometheus.Desc
-
-	// QAT metrics
-	NodeQATUtilization *prometheus.Desc
-}
-
-type ContainerDesc struct {
-	// Energy (counter)
-	containerCoreJoulesTotal            *prometheus.Desc
-	containerUncoreJoulesTotal          *prometheus.Desc
-	containerDramJoulesTotal            *prometheus.Desc
-	containerPackageJoulesTotal         *prometheus.Desc
-	containerOtherComponentsJoulesTotal *prometheus.Desc
-	containerGPUJoulesTotal             *prometheus.Desc
-	containerJoulesTotal                *prometheus.Desc
-
-	// Hardware Counters (counter)
-	containerCPUCyclesTotal *prometheus.Desc
-	containerCPUInstrTotal  *prometheus.Desc
-	containerCacheMissTotal *prometheus.Desc
-
-	// cGroups (counter)
-	containerCgroupCPUUsageUsTotal       *prometheus.Desc
-	containerCgroupMemoryUsageBytesTotal *prometheus.Desc
-	containerCgroupSystemCPUUsageUsTotal *prometheus.Desc
-	containerCgroupUserCPUUsageUsTotal   *prometheus.Desc
-
-	// General kubelet (counter)
-	containerKubeletCPUUsageTotal    *prometheus.Desc
-	containerKubeletMemoryBytesTotal *prometheus.Desc
-
-	// Additional metrics (gauge)
-	containerCPUTime      *prometheus.Desc
-	containerPageCacheHit *prometheus.Desc
-
-	// IRQ metrics
-	containerNetTxIRQTotal *prometheus.Desc
-	containerNetRxIRQTotal *prometheus.Desc
-	containerBlockIRQTotal *prometheus.Desc
-}
-
-// metric used by the model server to train the model
-type PodDesc struct {
-	// Hardware Counters (counter)
-	// The clever dashboard use the pod_cpu_instructions but should be updated later to container_cpu_instructions
-	podCPUInstrTotal *prometheus.Desc
-}
-
-// PrometheusCollector holds the list of prometheus metrics for both node and pod context
-type PrometheusCollector struct {
-	nodeDesc      *NodeDesc
-	containerDesc *ContainerDesc
-	podDesc       *PodDesc
-	processDesc   *processDesc
-	vmDesc        *vmDesc
-
-	// NodeMetrics holds all node energy and resource usage metrics
-	NodeMetrics *collector_metric.NodeMetrics
-
-	// ContainersMetrics holds all container energy and resource usage metrics
-	ContainersMetrics *map[string]*collector_metric.ContainerMetrics
-
-	// ProcessMetrics hold all process energy and resource usage metrics
-	ProcessMetrics *map[uint64]*collector_metric.ProcessMetrics
-
-	// VMMetrics hold all Virtual Machine energy and resource usage metrics
-	VMMetrics *map[uint64]*collector_metric.VMMetrics
-
-	// SamplePeriodSec the collector metric collection interval
-	SamplePeriodSec float64
-
-	// Lock to syncronize the collector update with prometheus exporter
-	Mx sync.Mutex
-
-	// Record whether we have cGroupsMetrics
-	HavecGroupsMetric bool
-}
-
-// NewPrometheusExporter create and initialize all the PrometheusCollector structures
-func NewPrometheusExporter() *PrometheusCollector {
-	exporter := PrometheusCollector{
-		// prometheus metric descriptions
-		nodeDesc:    &NodeDesc{},
-		podDesc:     &PodDesc{},
-		processDesc: &processDesc{},
-		vmDesc:      &vmDesc{},
-	}
-	exporter.newNodeMetrics()
-	exporter.newContainerMetrics()
-	exporter.newPodMetrics()
-	exporter.newprocessMetrics()
-	exporter.newVMMetrics()
-	return &exporter
-}
-
-// Describe implements the prometheus.Collector interface
-func (p *PrometheusCollector) Describe(ch chan<- *prometheus.Desc) {
-	// Node metadata
-	ch <- p.nodeDesc.nodeInfo
-
-	// Node Energy (counter)
-	ch <- p.nodeDesc.nodeCoreJoulesTotal
-	ch <- p.nodeDesc.nodeUncoreJoulesTotal
-	ch <- p.nodeDesc.nodeDramJoulesTotal
-	ch <- p.nodeDesc.nodePackageJoulesTotal
-	ch <- p.nodeDesc.nodePlatformJoulesTotal
-	ch <- p.nodeDesc.nodeOtherComponentsJoulesTotal
-
-	if config.EnabledGPU {
-		ch <- p.nodeDesc.nodeGPUJoulesTotal
-	}
-
-	// Additional Node metrics from QAT
-	if config.EnabledQAT {
-		ch <- p.nodeDesc.NodeQATUtilization
-	}
-
-	// Additional Node metrics (gauge)
-	ch <- p.nodeDesc.NodeCPUFrequency
-
-	// Container Energy (counter)
-	ch <- p.containerDesc.containerCoreJoulesTotal
-	ch <- p.containerDesc.containerUncoreJoulesTotal
-	ch <- p.containerDesc.containerDramJoulesTotal
-	ch <- p.containerDesc.containerPackageJoulesTotal
-	ch <- p.containerDesc.containerOtherComponentsJoulesTotal
-	if config.EnabledGPU {
-		ch <- p.containerDesc.containerGPUJoulesTotal
-	}
-	ch <- p.containerDesc.containerJoulesTotal
-
-	// container Hardware Counters (counter)
-	if config.ExposeHardwareCounterMetrics && collector_metric.CPUHardwareCounterEnabled {
-		ch <- p.containerDesc.containerCPUCyclesTotal
-		ch <- p.containerDesc.containerCPUInstrTotal
-		ch <- p.containerDesc.containerCacheMissTotal
-	}
-
-	// container cGroups Counters (counter)
-	if config.IsCgroupMetricsEnabled() {
-		if len(collector_metric.AvailableCGroupMetrics) != 0 {
-			ch <- p.containerDesc.containerCgroupCPUUsageUsTotal
-			ch <- p.containerDesc.containerCgroupMemoryUsageBytesTotal
-			ch <- p.containerDesc.containerCgroupSystemCPUUsageUsTotal
-			ch <- p.containerDesc.containerCgroupUserCPUUsageUsTotal
-			p.HavecGroupsMetric = true
-		} else {
-			p.HavecGroupsMetric = false
-		}
-	}
-
-	// Old Node metric
-	ch <- p.containerDesc.containerCPUTime
-	ch <- p.containerDesc.containerPageCacheHit
-
-	// IRQ counter
-	if config.IsIRQCounterMetricsEnabled() {
-		ch <- p.containerDesc.containerNetTxIRQTotal
-		ch <- p.containerDesc.containerNetRxIRQTotal
-		ch <- p.containerDesc.containerBlockIRQTotal
-	}
-	p.describeProcess(ch)
-	p.describeVM(ch)
-}
-
-func (p *PrometheusCollector) newNodeMetrics() {
-	nodeInfo := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "node", "info"),
-		"Labeled node information",
-		[]string{"cpu_architecture"}, nil,
-	)
-	// Energy (counter)
-	// TODO: separate the energy consumption per CPU, including the label cpu
-	nodeCoreJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "node", addSuffix(collector_metric.CORE, config.AggregatedEnergySuffix)),
-		"Aggregated RAPL value in core in joules",
-		[]string{"package", "instance", "source", "mode"}, nil,
-	)
-	nodeUncoreJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "node", addSuffix(collector_metric.UNCORE, config.AggregatedEnergySuffix)),
-		"Aggregated RAPL value in uncore in joules",
-		[]string{"package", "instance", "source", "mode"}, nil,
-	)
-	nodeDramJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "node", addSuffix(collector_metric.DRAM, config.AggregatedEnergySuffix)),
-		"Aggregated RAPL value in dram in joules",
-		[]string{"package", "instance", "source", "mode"}, nil,
-	)
-	nodePackageJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "node", addSuffix(collector_metric.PKG, config.AggregatedEnergySuffix)),
-		"Aggregated RAPL value in package (socket) in joules",
-		[]string{"package", "instance", "source", "mode"}, nil,
-	)
-	nodePlatformJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "node", addSuffix(collector_metric.PLATFORM, config.AggregatedEnergySuffix)),
-		"Aggregated RAPL value in platform (entire node) in joules",
-		[]string{"instance", "source", "mode"}, nil,
-	)
-	nodeOtherComponentsJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "node", addSuffix(collector_metric.OTHER, config.AggregatedEnergySuffix)),
-		"Aggregated RAPL value in other components (platform - package - dram) in joules",
-		[]string{"instance", "mode"}, nil,
-	)
-	nodeGPUJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "node", addSuffix(collector_metric.GPU, config.AggregatedEnergySuffix)),
-		"Current GPU value in joules",
-		[]string{"index", "instance", "source", "mode"}, nil,
-	)
-
-	// Additional metrics from QAT
-	NodeQATUtilization := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "node", "accelerator_intel_qat"),
-		"Current Intel QAT Utilization",
-		[]string{"qatDevID", "instance", "source", "type"}, nil,
-	)
-
-	// Additional metrics (gauge)
-	NodeCPUFrequency := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "node", "cpu_scaling_frequency_hertz"),
-		"Current average cpu frequency in hertz",
-		[]string{"cpu", "instance"}, nil,
-	)
-
-	p.nodeDesc = &NodeDesc{
-		nodeInfo:                       nodeInfo,
-		nodeCoreJoulesTotal:            nodeCoreJoulesTotal,
-		nodeUncoreJoulesTotal:          nodeUncoreJoulesTotal,
-		nodeDramJoulesTotal:            nodeDramJoulesTotal,
-		nodePackageJoulesTotal:         nodePackageJoulesTotal,
-		nodePlatformJoulesTotal:        nodePlatformJoulesTotal,
-		nodeOtherComponentsJoulesTotal: nodeOtherComponentsJoulesTotal,
-		nodeGPUJoulesTotal:             nodeGPUJoulesTotal,
-		NodeCPUFrequency:               NodeCPUFrequency,
-		NodeQATUtilization:             NodeQATUtilization,
-	}
-}
-
-func (p *PrometheusCollector) newContainerMetrics() {
-	// Energy (counter)
-	containerCoreJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(collector_metric.CORE, config.AggregatedEnergySuffix)),
-		"Aggregated RAPL value in core in joules",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace", "mode"}, nil,
-	)
-	containerUncoreJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(collector_metric.UNCORE, config.AggregatedEnergySuffix)),
-		"Aggregated RAPL value in uncore in joules",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace", "mode"}, nil,
-	)
-	containerDramJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(collector_metric.DRAM, config.AggregatedEnergySuffix)),
-		"Aggregated RAPL value in dram in joules",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace", "mode"}, nil,
-	)
-	containerPackageJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(collector_metric.PKG, config.AggregatedEnergySuffix)),
-		"Aggregated RAPL value in package (socket) in joules",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace", "mode"}, nil,
-	)
-	containerOtherComponentsJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(collector_metric.OTHER, config.AggregatedEnergySuffix)),
-		"Aggregated value in other host components (platform - package - dram) in joules",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace", "mode"}, nil,
-	)
-	containerGPUJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(collector_metric.GPU, config.AggregatedEnergySuffix)),
-		"Aggregated GPU value in joules",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace", "mode"}, nil,
-	)
-	containerJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", config.AggregatedEnergySuffix),
-		"Aggregated RAPL Package + Uncore + DRAM + GPU + other host components (platform - package - dram) in joules",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace", "mode"}, nil,
-	)
-
-	// Hardware Counters (counter)
-	containerCPUCyclesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.CPUCycle, config.AggregatedUsageSuffix)),
-		"Aggregated CPU cycle value",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-	containerCPUInstrTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.CPUInstruction, config.AggregatedUsageSuffix)),
-		"Aggregated CPU instruction value",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-	containerCacheMissTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.CacheMiss, config.AggregatedUsageSuffix)),
-		"Aggregated cache miss value",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-
-	// cGroups Counters (counter)
-	containerCgroupCPUUsageUsTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.CgroupfsCPU, config.AggregatedUsageSuffix)),
-		"Aggregated cpu usage obtained from cGroups",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-
-	containerCgroupMemoryUsageBytesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.CgroupfsMemory, config.AggregatedUsageSuffix)),
-		"Aggregated memory bytes obtained from cGroups",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-
-	containerCgroupSystemCPUUsageUsTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.CgroupfsSystemCPU, config.AggregatedUsageSuffix)),
-		"Aggregated system cpu usage obtained from cGroups",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-
-	containerCgroupUserCPUUsageUsTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.CgroupfsUserCPU, config.AggregatedUsageSuffix)),
-		"Aggregated user cpu usage obtained from cGroups",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-
-	// Kubelet Counters (counter)
-	containerKubeletCPUUsageTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.KubeletCPUUsage, config.AggregatedUsageSuffix)),
-		"Aggregated cpu usage obtained from kubelet",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-
-	containerKubeletMemoryBytesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.KubeletMemoryUsage, config.AggregatedUsageSuffix)),
-		"Aggregated memory bytes obtained from kubelet",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-
-	// Additional metrics (counter)
-	containerCPUTime := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.CPUTime, config.AggregatedUsageSuffix)),
-		"Aggregated CPU time obtained from BPF",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-	containerPageCacheHit := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.PageCacheHit, config.AggregatedUsageSuffix)),
-		"Aggregated Page Cache Hit obtained from BPF",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-
-	// network irq metrics
-	containerNetTxIRQTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.IRQNetTXLabel, config.AggregatedUsageSuffix)),
-		"Aggregated network tx irq value obtained from BPF",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-	containerNetRxIRQTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.IRQNetRXLabel, config.AggregatedUsageSuffix)),
-		"Aggregated network rx irq value obtained from BPF",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-	containerBlockIRQTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "container", addSuffix(config.IRQBlockLabel, config.AggregatedUsageSuffix)),
-		"Aggregated block irq value obtained from BPF",
-		[]string{"container_id", "pod_name", "container_name", "container_namespace"}, nil,
-	)
-
-	p.containerDesc = &ContainerDesc{
-		containerCoreJoulesTotal:             containerCoreJoulesTotal,
-		containerUncoreJoulesTotal:           containerUncoreJoulesTotal,
-		containerDramJoulesTotal:             containerDramJoulesTotal,
-		containerPackageJoulesTotal:          containerPackageJoulesTotal,
-		containerOtherComponentsJoulesTotal:  containerOtherComponentsJoulesTotal,
-		containerGPUJoulesTotal:              containerGPUJoulesTotal,
-		containerJoulesTotal:                 containerJoulesTotal,
-		containerCPUCyclesTotal:              containerCPUCyclesTotal,
-		containerCPUInstrTotal:               containerCPUInstrTotal,
-		containerCacheMissTotal:              containerCacheMissTotal,
-		containerCgroupCPUUsageUsTotal:       containerCgroupCPUUsageUsTotal,
-		containerCgroupMemoryUsageBytesTotal: containerCgroupMemoryUsageBytesTotal,
-		containerCgroupSystemCPUUsageUsTotal: containerCgroupSystemCPUUsageUsTotal,
-		containerCgroupUserCPUUsageUsTotal:   containerCgroupUserCPUUsageUsTotal,
-		containerKubeletMemoryBytesTotal:     containerKubeletMemoryBytesTotal,
-		containerKubeletCPUUsageTotal:        containerKubeletCPUUsageTotal,
-		containerCPUTime:                     containerCPUTime,
-		containerPageCacheHit:                containerPageCacheHit,
-		containerNetTxIRQTotal:               containerNetTxIRQTotal,
-		containerNetRxIRQTotal:               containerNetRxIRQTotal,
-		containerBlockIRQTotal:               containerBlockIRQTotal,
-	}
-}
-
-func (p *PrometheusCollector) newPodMetrics() {
-	podCPUInstrTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "pod", "cpu_instructions"),
-		"Aggregated CPU instruction value (deprecated)",
-		[]string{"pod_name", "container_name", "container_namespace"}, nil,
-	)
-
-	p.podDesc = &PodDesc{
-		podCPUInstrTotal: podCPUInstrTotal,
-	}
-}
-
-// Collect implements the prometheus.Collector interface
-func (p *PrometheusCollector) Collect(ch chan<- prometheus.Metric) {
-	p.Mx.Lock()
-	defer p.Mx.Unlock()
-	wg := sync.WaitGroup{}
-	p.updateNodeMetrics(&wg, ch)
-	p.updatePodMetrics(&wg, ch)
-	p.updateProcessMetrics(&wg, ch)
-	p.updateVMMetrics(&wg, ch)
-	wg.Wait()
-}
-
-// updateNodeMetrics send node metrics to prometheus
-func (p *PrometheusCollector) updateNodeMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric) {
-	// we start with the metrics that might have a longer loop, e.g. range the cpus
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		// TODO: remove this metric if we don't need, reporting this can be an expensive process
-		for cpuID, freq := range p.NodeMetrics.CPUFrequency {
-			ch <- prometheus.MustNewConstMetric(
-				p.nodeDesc.NodeCPUFrequency,
-				prometheus.GaugeValue,
-				float64(freq),
-				fmt.Sprintf("%d", cpuID), collector_metric.NodeName,
-			)
-		}
-
-		ch <- prometheus.MustNewConstMetric(
-			p.nodeDesc.nodeInfo,
-			prometheus.CounterValue,
-			1,
-			collector_metric.NodeCPUArchitecture,
-		)
-		// Node metrics in joules (counter)
-		for pkgID := range p.NodeMetrics.AbsEnergyInCore.Stat {
-			dynPower := (float64(p.NodeMetrics.GetAggrDynEnergyPerID(collector_metric.PKG, pkgID)) / miliJouleToJoule)
-			ch <- prometheus.MustNewConstMetric(
-				p.nodeDesc.nodePackageJoulesTotal,
-				prometheus.CounterValue,
-				dynPower,
-				pkgID, collector_metric.NodeName, "rapl", "dynamic",
-			)
-			dynPower = (float64(p.NodeMetrics.GetAggrDynEnergyPerID(collector_metric.CORE, pkgID)) / miliJouleToJoule)
-			ch <- prometheus.MustNewConstMetric(
-				p.nodeDesc.nodeCoreJoulesTotal,
-				prometheus.CounterValue,
-				dynPower,
-				pkgID, collector_metric.NodeName, "rapl", "dynamic",
-			)
-			dynPower = (float64(p.NodeMetrics.GetAggrDynEnergyPerID(collector_metric.UNCORE, pkgID)) / miliJouleToJoule)
-			ch <- prometheus.MustNewConstMetric(
-				p.nodeDesc.nodeUncoreJoulesTotal,
-				prometheus.CounterValue,
-				dynPower,
-				pkgID, collector_metric.NodeName, "rapl", "dynamic",
-			)
-			dynPower = (float64(p.NodeMetrics.GetAggrDynEnergyPerID(collector_metric.DRAM, pkgID)) / miliJouleToJoule)
-			ch <- prometheus.MustNewConstMetric(
-				p.nodeDesc.nodeDramJoulesTotal,
-				prometheus.CounterValue,
-				dynPower,
-				pkgID, collector_metric.NodeName, "rapl", "dynamic",
-			)
-
-			if config.IsIdlePowerEnabled() {
-				idlePower := (float64(p.NodeMetrics.GetAggrIdleEnergyPerID(collector_metric.PKG, pkgID)) / miliJouleToJoule)
-				ch <- prometheus.MustNewConstMetric(
-					p.nodeDesc.nodePackageJoulesTotal,
-					prometheus.CounterValue,
-					idlePower,
-					pkgID, collector_metric.NodeName, "rapl", "idle",
-				)
-
-				idlePower = (float64(p.NodeMetrics.GetAggrIdleEnergyPerID(collector_metric.CORE, pkgID)) / miliJouleToJoule)
-				ch <- prometheus.MustNewConstMetric(
-					p.nodeDesc.nodeCoreJoulesTotal,
-					prometheus.CounterValue,
-					idlePower,
-					pkgID, collector_metric.NodeName, "rapl", "idle",
-				)
-
-				idlePower = (float64(p.NodeMetrics.GetAggrIdleEnergyPerID(collector_metric.UNCORE, pkgID)) / miliJouleToJoule)
-				ch <- prometheus.MustNewConstMetric(
-					p.nodeDesc.nodeUncoreJoulesTotal,
-					prometheus.CounterValue,
-					idlePower,
-					pkgID, collector_metric.NodeName, "rapl", "idle",
-				)
-
-				idlePower = (float64(p.NodeMetrics.GetAggrIdleEnergyPerID(collector_metric.DRAM, pkgID)) / miliJouleToJoule)
-				ch <- prometheus.MustNewConstMetric(
-					p.nodeDesc.nodeDramJoulesTotal,
-					prometheus.CounterValue,
-					idlePower,
-					pkgID, collector_metric.NodeName, "rapl", "idle",
-				)
-			}
-		}
-
-		dynPower := (float64(p.NodeMetrics.GetSumAggrDynEnergyFromAllSources(collector_metric.OTHER)) / miliJouleToJoule)
-		ch <- prometheus.MustNewConstMetric(
-			p.nodeDesc.nodeOtherComponentsJoulesTotal,
-			prometheus.CounterValue,
-			dynPower,
-			collector_metric.NodeName, "dynamic",
-		)
-		powerSource := platform.GetPowerSource()
-		dynPower = (float64(p.NodeMetrics.GetSumAggrDynEnergyFromAllSources(collector_metric.PLATFORM)) / miliJouleToJoule)
-		ch <- prometheus.MustNewConstMetric(
-			p.nodeDesc.nodePlatformJoulesTotal,
-			prometheus.CounterValue,
-			dynPower,
-			collector_metric.NodeName, powerSource, "dynamic",
-		)
-
-		if config.IsIdlePowerEnabled() {
-			idlePower := (float64(p.NodeMetrics.GetSumAggrIdleEnergyFromAllSources(collector_metric.OTHER)) / miliJouleToJoule)
-			ch <- prometheus.MustNewConstMetric(
-				p.nodeDesc.nodeOtherComponentsJoulesTotal,
-				prometheus.CounterValue,
-				idlePower,
-				collector_metric.NodeName, "idle",
-			)
-			idlePower = (float64(p.NodeMetrics.GetSumAggrIdleEnergyFromAllSources(collector_metric.PLATFORM)) / miliJouleToJoule)
-			ch <- prometheus.MustNewConstMetric(
-				p.nodeDesc.nodePlatformJoulesTotal,
-				prometheus.CounterValue,
-				idlePower,
-				collector_metric.NodeName, powerSource, "idle",
-			)
-		}
-
-		if config.EnabledGPU {
-			for gpuID := range p.NodeMetrics.AbsEnergyInGPU.Stat {
-				dynPower = (float64(p.NodeMetrics.GetAggrDynEnergyPerID(collector_metric.GPU, gpuID)) / miliJouleToJoule)
-				ch <- prometheus.MustNewConstMetric(
-					p.nodeDesc.nodeGPUJoulesTotal,
-					prometheus.CounterValue,
-					dynPower,
-					gpuID, collector_metric.NodeName, "nvidia", "dynamic",
-				)
-				// We do not verify if IsIdlePowerEnabled is enabled for GPUs because pre-trained power models does not estimate GPU power.
-				idlePower := (float64(p.NodeMetrics.GetAggrIdleEnergyPerID(collector_metric.GPU, gpuID)) / miliJouleToJoule)
-				ch <- prometheus.MustNewConstMetric(
-					p.nodeDesc.nodeGPUJoulesTotal,
-					prometheus.CounterValue,
-					idlePower,
-					gpuID, collector_metric.NodeName, "nvidia", "idle",
-				)
-			}
-		}
-
-		if config.EnabledQAT {
-			for device, util := range p.NodeMetrics.QATUtilization {
-				ch <- prometheus.MustNewConstMetric(
-					p.nodeDesc.NodeQATUtilization,
-					prometheus.CounterValue,
-					float64(util.Latency),
-					device, collector_metric.NodeName, "intel-qat", "latency",
-				)
-			}
-		}
-	}()
-}
-
-// updatePodMetrics send pod metrics to prometheus
-func (p *PrometheusCollector) updatePodMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric) {
-	for _, container := range *p.ContainersMetrics {
-		wg.Add(1)
-		go func(container *collector_metric.ContainerMetrics) {
-			defer wg.Done()
-			if container.BPFStats[config.CPUTime] != nil {
-				ch <- prometheus.MustNewConstMetric(
-					p.containerDesc.containerCPUTime,
-					prometheus.CounterValue,
-					float64(container.BPFStats[config.CPUTime].Aggr),
-					container.ContainerID, container.PodName, container.ContainerName, container.Namespace,
-				)
-			}
-			if container.BPFStats[config.PageCacheHit] != nil {
-				ch <- prometheus.MustNewConstMetric(
-					p.containerDesc.containerPageCacheHit,
-					prometheus.CounterValue,
-					float64(container.BPFStats[config.PageCacheHit].Aggr),
-					container.ContainerID, container.PodName, container.ContainerName, container.Namespace,
-				)
-			}
-			ch <- prometheus.MustNewConstMetric(
-				p.containerDesc.containerCoreJoulesTotal,
-				prometheus.CounterValue,
-				float64(container.DynEnergyInCore.Aggr)/miliJouleToJoule,
-				container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.containerDesc.containerUncoreJoulesTotal,
-				prometheus.CounterValue,
-				float64(container.DynEnergyInUncore.Aggr)/miliJouleToJoule,
-				container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.containerDesc.containerDramJoulesTotal,
-				prometheus.CounterValue,
-				float64(container.DynEnergyInDRAM.Aggr)/miliJouleToJoule,
-				container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.containerDesc.containerPackageJoulesTotal,
-				prometheus.CounterValue,
-				float64(container.DynEnergyInPkg.Aggr)/miliJouleToJoule,
-				container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.containerDesc.containerOtherComponentsJoulesTotal,
-				prometheus.CounterValue,
-				float64(container.DynEnergyInOther.Aggr)/miliJouleToJoule,
-				container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "dynamic",
-			)
-			if config.IsIdlePowerEnabled() {
-				ch <- prometheus.MustNewConstMetric(
-					p.containerDesc.containerCoreJoulesTotal,
-					prometheus.CounterValue,
-					float64(container.IdleEnergyInCore.Aggr)/miliJouleToJoule,
-					container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "idle",
-				)
-				ch <- prometheus.MustNewConstMetric(
-					p.containerDesc.containerUncoreJoulesTotal,
-					prometheus.CounterValue,
-					float64(container.IdleEnergyInUncore.Aggr)/miliJouleToJoule,
-					container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "idle",
-				)
-				ch <- prometheus.MustNewConstMetric(
-					p.containerDesc.containerDramJoulesTotal,
-					prometheus.CounterValue,
-					float64(container.IdleEnergyInDRAM.Aggr)/miliJouleToJoule,
-					container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "idle",
-				)
-				ch <- prometheus.MustNewConstMetric(
-					p.containerDesc.containerPackageJoulesTotal,
-					prometheus.CounterValue,
-					float64(container.IdleEnergyInPkg.Aggr)/miliJouleToJoule,
-					container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "idle",
-				)
-				ch <- prometheus.MustNewConstMetric(
-					p.containerDesc.containerOtherComponentsJoulesTotal,
-					prometheus.CounterValue,
-					float64(container.IdleEnergyInOther.Aggr)/miliJouleToJoule,
-					container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "idle",
-				)
-			}
-			if config.EnabledGPU {
-				if container.DynEnergyInGPU.Aggr > 0 {
-					ch <- prometheus.MustNewConstMetric(
-						p.containerDesc.containerGPUJoulesTotal,
-						prometheus.CounterValue,
-						float64(container.DynEnergyInGPU.Aggr)/miliJouleToJoule,
-						container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "dynamic",
-					)
-				}
-				if container.IdleEnergyInGPU.Aggr > 0 {
-					// We do not verify if IsIdlePowerEnabled is enabled for GPUs because pre-trained power models does not estimate GPU power.
-					ch <- prometheus.MustNewConstMetric(
-						p.containerDesc.containerGPUJoulesTotal,
-						prometheus.CounterValue,
-						float64(container.IdleEnergyInGPU.Aggr)/miliJouleToJoule,
-						container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "idle",
-					)
-				}
-			}
-			ch <- prometheus.MustNewConstMetric(
-				p.containerDesc.containerJoulesTotal,
-				prometheus.CounterValue,
-				(float64(container.DynEnergyInPkg.Aggr)/miliJouleToJoule +
-					float64(container.DynEnergyInUncore.Aggr)/miliJouleToJoule +
-					float64(container.DynEnergyInDRAM.Aggr)/miliJouleToJoule +
-					float64(container.DynEnergyInGPU.Aggr)/miliJouleToJoule +
-					float64(container.DynEnergyInOther.Aggr)/miliJouleToJoule),
-				container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "dynamic",
-			)
-			if config.IsIdlePowerEnabled() {
-				ch <- prometheus.MustNewConstMetric(
-					p.containerDesc.containerJoulesTotal,
-					prometheus.CounterValue,
-					(float64(container.IdleEnergyInPkg.Aggr)/miliJouleToJoule +
-						float64(container.IdleEnergyInUncore.Aggr)/miliJouleToJoule +
-						float64(container.IdleEnergyInDRAM.Aggr)/miliJouleToJoule +
-						float64(container.IdleEnergyInGPU.Aggr)/miliJouleToJoule +
-						float64(container.IdleEnergyInOther.Aggr)/miliJouleToJoule),
-					container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "idle",
-				)
-			}
-			if config.ExposeHardwareCounterMetrics && collector_metric.CPUHardwareCounterEnabled {
-				if container.BPFStats[attacher.CPUCycleLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.containerDesc.containerCPUCyclesTotal,
-						prometheus.CounterValue,
-						float64(container.BPFStats[attacher.CPUCycleLabel].Aggr),
-						container.ContainerID, container.PodName, container.ContainerName, container.Namespace,
-					)
-				}
-				if container.BPFStats[attacher.CPUInstructionLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.containerDesc.containerCPUInstrTotal,
-						prometheus.CounterValue,
-						float64(container.BPFStats[attacher.CPUInstructionLabel].Aggr),
-						container.ContainerID, container.PodName, container.ContainerName, container.Namespace,
-					)
-				}
-				if container.BPFStats[attacher.CacheMissLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.containerDesc.containerCacheMissTotal,
-						prometheus.CounterValue,
-						float64(container.BPFStats[attacher.CacheMissLabel].Aggr),
-						container.ContainerID, container.PodName, container.ContainerName, container.Namespace,
-					)
-				}
-			}
-			if config.ExposeIRQCounterMetrics {
-				if container.BPFStats[config.IRQNetTXLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.containerDesc.containerNetTxIRQTotal,
-						prometheus.CounterValue,
-						float64(container.BPFStats[config.IRQNetTXLabel].Aggr),
-						container.ContainerID, container.PodName, container.ContainerName, container.Namespace,
-					)
-				}
-				if container.BPFStats[config.IRQNetRXLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.containerDesc.containerNetRxIRQTotal,
-						prometheus.CounterValue,
-						float64(container.BPFStats[config.IRQNetRXLabel].Aggr),
-						container.ContainerID, container.PodName, container.ContainerName, container.Namespace,
-					)
-				}
-				if container.BPFStats[config.IRQBlockLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.containerDesc.containerBlockIRQTotal,
-						prometheus.CounterValue,
-						float64(container.BPFStats[config.IRQBlockLabel].Aggr),
-						container.ContainerID, container.PodName, container.ContainerName, container.Namespace,
-					)
-				}
-			}
-
-			if config.ExposeCgroupMetrics && p.HavecGroupsMetric {
-				ch <- prometheus.MustNewConstMetric(
-					p.containerDesc.containerCgroupCPUUsageUsTotal,
-					prometheus.CounterValue,
-					float64(container.CgroupStatMap[config.CgroupfsCPU].SumAllAggrValues()),
-					container.ContainerID, container.PodName, container.ContainerName, container.Namespace,
-				)
-				ch <- prometheus.MustNewConstMetric(
-					p.containerDesc.containerCgroupMemoryUsageBytesTotal,
-					prometheus.CounterValue,
-					float64(container.CgroupStatMap[config.CgroupfsMemory].SumAllAggrValues()),
-					container.ContainerID, container.PodName, container.ContainerName, container.Namespace,
-				)
-				ch <- prometheus.MustNewConstMetric(
-					p.containerDesc.containerCgroupSystemCPUUsageUsTotal,
-					prometheus.CounterValue,
-					float64(container.CgroupStatMap[config.CgroupfsSystemCPU].SumAllAggrValues()),
-					container.ContainerID, container.PodName, container.ContainerName, container.Namespace,
-				)
-				ch <- prometheus.MustNewConstMetric(
-					p.containerDesc.containerCgroupUserCPUUsageUsTotal,
-					prometheus.CounterValue,
-					float64(container.CgroupStatMap[config.CgroupfsUserCPU].SumAllAggrValues()),
-					container.ContainerID, container.PodName, container.ContainerName, container.Namespace,
-				)
-			}
-		}(container)
-	}
-}
diff --git a/pkg/collector/prometheus_collector_test.go b/pkg/collector/prometheus_collector_test.go
deleted file mode 100644
index 73a67d323b..0000000000
--- a/pkg/collector/prometheus_collector_test.go
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
-Copyright 2021.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package collector
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
-	"github.com/sustainable-computing-io/kepler/pkg/collector/metric/types"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/model"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
-	"github.com/sustainable-computing-io/kepler/pkg/power/platform"
-)
-
-const (
-	nodeEnergyMetric             = "kepler_node_platform_joules_total"
-	nodePackageEnergyMetric      = "kepler_node_package_joules_total"
-	containerCPUCoreEnergyMetric = "kepler_container_package_joules_total"
-
-	SampleCurr = 100
-	SampleAggr = 1000
-)
-
-func convertPromToValue(body []byte, metric string) (float64, error) {
-	regStr := fmt.Sprintf(`%s{[^{}]*}.*`, metric)
-	r := regexp.MustCompile(regStr)
-	match := r.FindString(string(body))
-	splits := strings.Split(match, " ")
-	fmt.Fprintf(GinkgoWriter, "splits=%v regStr=%v\n", splits, regStr)
-	return strconv.ParseFloat(splits[1], 64)
-}
-
-func newMockPrometheusExporter() *PrometheusCollector {
-	if gpu.IsGPUCollectionSupported() {
-		err := gpu.Init() // create structure instances that will be accessed to create a containerMetric
-		Expect(err).NotTo(HaveOccurred())
-	}
-	exporter := NewPrometheusExporter()
-	exporter.NodeMetrics = collector_metric.NewNodeMetrics()
-	exporter.ContainersMetrics = &map[string]*collector_metric.ContainerMetrics{}
-	exporter.ProcessMetrics = &map[uint64]*collector_metric.ProcessMetrics{}
-	exporter.VMMetrics = &map[uint64]*collector_metric.VMMetrics{}
-	exporter.SamplePeriodSec = 3.0
-	collector_metric.ContainerFeaturesNames = []string{config.CoreUsageMetric}
-	collector_metric.NodeMetadataFeatureNames = []string{"cpu_architecture"}
-	collector_metric.NodeMetadataFeatureValues = []string{"Sandy Bridge"}
-	return exporter
-}
-
-var _ = Describe("Test Prometheus Collector Unit", func() {
-	It("Init and Run", func() {
-		exporter := newMockPrometheusExporter()
-		// we need to disable the system real time power metrics for testing since we add mock values or use power model estimator
-		components.SetIsSystemCollectionSupported(false)
-		platform.SetIsSystemCollectionSupported(false)
-
-		// add container mock values
-		(*exporter.ContainersMetrics)["containerA"] = collector_metric.NewContainerMetrics("containerA", "podA", "test", "containerA")
-		(*exporter.ContainersMetrics)["containerA"].BPFStats[config.CoreUsageMetric] = &types.UInt64Stat{}
-		err := (*exporter.ContainersMetrics)["containerA"].BPFStats[config.CoreUsageMetric].AddNewDelta(30000)
-		Expect(err).NotTo(HaveOccurred())
-		(*exporter.ContainersMetrics)["containerB"] = collector_metric.NewContainerMetrics("containerB", "podB", "test", "containerB")
-		(*exporter.ContainersMetrics)["containerB"].BPFStats[config.CoreUsageMetric] = &types.UInt64Stat{}
-		err = (*exporter.ContainersMetrics)["containerB"].BPFStats[config.CoreUsageMetric].AddNewDelta(30000)
-		Expect(err).NotTo(HaveOccurred())
-		exporter.NodeMetrics.AddNodeResUsageFromContainerResUsage(*exporter.ContainersMetrics)
-
-		// add node mock values
-		// initialize the node energy with aggregated energy, which will be used to calculate delta energy
-		nodePlatformEnergy := map[string]float64{}
-		// initialize the node energy with aggregated energy, which will be used to calculate delta energy
-		nodePlatformEnergy["sensor0"] = 5000 // mJ
-		exporter.NodeMetrics.SetNodePlatformEnergy(nodePlatformEnergy, true, false)
-		exporter.NodeMetrics.UpdateIdleEnergyWithMinValue(true)
-		// the second node energy will represent the idle and dynamic power. The idle power is only calculated after there at at least two delta values
-		nodePlatformEnergy["sensor0"] = 35000
-		exporter.NodeMetrics.SetNodePlatformEnergy(nodePlatformEnergy, true, false)
-		exporter.NodeMetrics.UpdateDynEnergy()
-
-		// initialize the node energy with aggregated energy, which will be used to calculate delta energy
-		// note that NodeComponentsEnergy contains aggregated energy over time
-		componentsEnergies := make(map[int]source.NodeComponentsEnergy)
-		componentsEnergies[0] = source.NodeComponentsEnergy{
-			Pkg:    5000, // mJ
-			Core:   5000,
-			DRAM:   5000,
-			Uncore: 5000,
-		}
-		exporter.NodeMetrics.SetNodeComponentsEnergy(componentsEnergies, false, false)
-		componentsEnergies[0] = source.NodeComponentsEnergy{
-			Pkg:    10000, // mJ
-			Core:   10000,
-			DRAM:   10000,
-			Uncore: 10000,
-		}
-		// the second node energy will force to calculate a delta. The delta is calculates after added at least two aggregated metric
-		exporter.NodeMetrics.SetNodeComponentsEnergy(componentsEnergies, false, false)
-		exporter.NodeMetrics.UpdateIdleEnergyWithMinValue(true)
-		// the third node energy will represent the idle and dynamic power. The idle power is only calculated after there at at least two delta values
-		componentsEnergies[0] = source.NodeComponentsEnergy{
-			Pkg:    45000, // 35000mJ delta, which is 5000mJ idle, 30000mJ dynamic power
-			Core:   45000,
-			DRAM:   45000,
-			Uncore: 45000,
-		}
-		exporter.NodeMetrics.SetNodeComponentsEnergy(componentsEnergies, false, false)
-		exporter.NodeMetrics.UpdateDynEnergy()
-
-		model.CreatePowerEstimatorModels(collector_metric.ContainerFeaturesNames, collector_metric.NodeMetadataFeatureNames, collector_metric.NodeMetadataFeatureValues)
-		model.UpdateContainerEnergy((*exporter.ContainersMetrics), exporter.NodeMetrics)
-
-		// get metrics from prometheus
-		err = prometheus.Register(exporter)
-		Expect(err).NotTo(HaveOccurred())
-
-		// check if prometheus is replying
-		req, _ := http.NewRequest("GET", "", http.NoBody)
-		res := httptest.NewRecorder()
-		handler := promhttp.Handler()
-		handler.ServeHTTP(res, req)
-		body, _ := io.ReadAll(res.Body)
-		Expect(len(body)).Should(BeNumerically(">", 0))
-		fmt.Fprintf(GinkgoWriter, "Result:\n %s\n", body)
-
-		// check pkg energy
-		val, err := convertPromToValue(body, nodePackageEnergyMetric)
-		Expect(err).NotTo(HaveOccurred())
-		Expect(val).Should(BeEquivalentTo(30)) // J
-
-		// check sample node energy
-		val, err = convertPromToValue(body, nodeEnergyMetric)
-		Expect(err).NotTo(HaveOccurred())
-		Expect(val).To(Equal(float64(60))) // J
-
-		// check sample pod
-		val, err = convertPromToValue(body, containerCPUCoreEnergyMetric)
-		Expect(err).NotTo(HaveOccurred())
-		// The pkg dynamic energy is 30J, the container cpu usage is 50%, so the dynamic energy is 15J
-		Expect(val).To(Equal(float64(15))) // J
-	})
-})
diff --git a/pkg/collector/prometheus_process_collector.go b/pkg/collector/prometheus_process_collector.go
deleted file mode 100644
index 7a79dbe88d..0000000000
--- a/pkg/collector/prometheus_process_collector.go
+++ /dev/null
@@ -1,348 +0,0 @@
-/*
-Copyright 2023.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-//nolint:dupl // should be refactor with vm collector
-package collector
-
-import (
-	"strconv"
-	"sync"
-	"unicode/utf8"
-
-	"github.com/prometheus/client_golang/prometheus"
-
-	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-)
-
-type processDesc struct {
-	// Energy (counter)
-	processCoreJoulesTotal            *prometheus.Desc
-	processUncoreJoulesTotal          *prometheus.Desc
-	processDramJoulesTotal            *prometheus.Desc
-	processPackageJoulesTotal         *prometheus.Desc
-	processOtherComponentsJoulesTotal *prometheus.Desc
-	processGPUJoulesTotal             *prometheus.Desc
-	processJoulesTotal                *prometheus.Desc
-
-	// Hardware Counters (counter)
-	processCPUCyclesTotal *prometheus.Desc
-	processCPUInstrTotal  *prometheus.Desc
-	processCacheMissTotal *prometheus.Desc
-
-	// Additional metrics (gauge)
-	processCPUTime *prometheus.Desc
-
-	// IRQ metrics
-	processNetTxIRQTotal *prometheus.Desc
-	processNetRxIRQTotal *prometheus.Desc
-	processBlockIRQTotal *prometheus.Desc
-}
-
-// describeProcess is called by Describe to implement the prometheus.Collector interface
-func (p *PrometheusCollector) describeProcess(ch chan<- *prometheus.Desc) {
-	// process Energy (counter)
-	ch <- p.processDesc.processCoreJoulesTotal
-	ch <- p.processDesc.processUncoreJoulesTotal
-	ch <- p.processDesc.processDramJoulesTotal
-	ch <- p.processDesc.processPackageJoulesTotal
-	ch <- p.processDesc.processOtherComponentsJoulesTotal
-	if config.EnabledGPU {
-		ch <- p.processDesc.processGPUJoulesTotal
-	}
-	ch <- p.processDesc.processJoulesTotal
-
-	// process Hardware Counters (counter)
-	if collector_metric.CPUHardwareCounterEnabled {
-		ch <- p.processDesc.processCPUCyclesTotal
-		ch <- p.processDesc.processCPUInstrTotal
-		ch <- p.processDesc.processCacheMissTotal
-	}
-
-	if config.ExposeIRQCounterMetrics {
-		ch <- p.processDesc.processNetTxIRQTotal
-		ch <- p.processDesc.processNetRxIRQTotal
-		ch <- p.processDesc.processBlockIRQTotal
-	}
-}
-
-func (p *PrometheusCollector) newprocessMetrics() {
-	// Energy (counter)
-	processCoreJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "core_joules_total"),
-		"Aggregated RAPL value in core in joules",
-		[]string{"pid", "command", "mode"}, nil,
-	)
-	processUncoreJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "uncore_joules_total"),
-		"Aggregated RAPL value in uncore in joules",
-		[]string{"pid", "command", "mode"}, nil,
-	)
-	processDramJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "dram_joules_total"),
-		"Aggregated RAPL value in dram in joules",
-		[]string{"pid", "command", "mode"}, nil,
-	)
-	processPackageJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "package_joules_total"),
-		"Aggregated RAPL value in package (socket) in joules",
-		[]string{"pid", "command", "mode"}, nil,
-	)
-	processOtherComponentsJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "other_host_components_joules_total"),
-		"Aggregated value in other host components (platform - package - dram) in joules",
-		[]string{"pid", "command", "mode"}, nil,
-	)
-	processGPUJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "gpu_joules_total"),
-		"Aggregated GPU value in joules",
-		[]string{"pid", "command", "mode"}, nil,
-	)
-	processJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "joules_total"),
-		"Aggregated RAPL Package + Uncore + DRAM + GPU + other host components (platform - package - dram) in joules",
-		[]string{"pid", "command", "mode"}, nil,
-	)
-
-	// Hardware Counters (counter)
-	processCPUCyclesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "cpu_cycles_total"),
-		"Aggregated CPU cycle value",
-		[]string{"pid", "command"}, nil,
-	)
-	processCPUInstrTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "cpu_instructions_total"),
-		"Aggregated CPU instruction value",
-		[]string{"pid", "command"}, nil,
-	)
-	processCacheMissTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "cache_miss_total"),
-		"Aggregated cache miss value",
-		[]string{"pid", "command"}, nil,
-	)
-	// Additional metrics (gauge)
-	processCPUTime := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "cpu_cpu_time_us"),
-		"Aggregated CPU time",
-		[]string{"pid", "command"}, nil)
-
-	// network irq metrics
-	processNetTxIRQTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "bpf_net_tx_irq_total"),
-		"Aggregated network tx irq value obtained from BPF",
-		[]string{"pid", "command"}, nil,
-	)
-	processNetRxIRQTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "bpf_net_rx_irq_total"),
-		"Aggregated network rx irq value obtained from BPF",
-		[]string{"pid", "command"}, nil,
-	)
-	processBlockIRQTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "process", "bpf_block_irq_total"),
-		"Aggregated block irq value obtained from BPF",
-		[]string{"pid", "command"}, nil,
-	)
-
-	p.processDesc = &processDesc{
-		processCoreJoulesTotal:            processCoreJoulesTotal,
-		processUncoreJoulesTotal:          processUncoreJoulesTotal,
-		processDramJoulesTotal:            processDramJoulesTotal,
-		processPackageJoulesTotal:         processPackageJoulesTotal,
-		processOtherComponentsJoulesTotal: processOtherComponentsJoulesTotal,
-		processGPUJoulesTotal:             processGPUJoulesTotal,
-		processJoulesTotal:                processJoulesTotal,
-		processCPUCyclesTotal:             processCPUCyclesTotal,
-		processCPUInstrTotal:              processCPUInstrTotal,
-		processCacheMissTotal:             processCacheMissTotal,
-		processCPUTime:                    processCPUTime,
-		processNetTxIRQTotal:              processNetTxIRQTotal,
-		processNetRxIRQTotal:              processNetRxIRQTotal,
-		processBlockIRQTotal:              processBlockIRQTotal,
-	}
-}
-
-// updateProcessMetrics send process metrics to prometheus
-func (p *PrometheusCollector) updateProcessMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric) {
-	const commandLenLimit = 10
-	for pid, process := range *p.ProcessMetrics {
-		wg.Add(1)
-		go func(pid uint64, process *collector_metric.ProcessMetrics) {
-			defer wg.Done()
-			processCommand := process.Command
-			if len(processCommand) > commandLenLimit {
-				processCommand = process.Command[:commandLenLimit]
-			}
-			if !utf8.ValidString(processCommand) {
-				processCommand = ""
-			}
-			pidStr := strconv.FormatUint(pid, 10)
-			if process.BPFStats[config.CPUTime] != nil {
-				ch <- prometheus.MustNewConstMetric(
-					p.processDesc.processCPUTime,
-					prometheus.CounterValue,
-					float64(process.BPFStats[config.CPUTime].Aggr),
-					pidStr, processCommand,
-				)
-			}
-			ch <- prometheus.MustNewConstMetric(
-				p.processDesc.processCoreJoulesTotal,
-				prometheus.CounterValue,
-				float64(process.DynEnergyInCore.Aggr)/miliJouleToJoule,
-				pidStr, processCommand, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.processDesc.processCoreJoulesTotal,
-				prometheus.CounterValue,
-				float64(process.IdleEnergyInCore.Aggr)/miliJouleToJoule,
-				pidStr, processCommand, "idle",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.processDesc.processUncoreJoulesTotal,
-				prometheus.CounterValue,
-				float64(process.DynEnergyInUncore.Aggr)/miliJouleToJoule,
-				pidStr, processCommand, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.processDesc.processUncoreJoulesTotal,
-				prometheus.CounterValue,
-				float64(process.IdleEnergyInUncore.Aggr)/miliJouleToJoule,
-				pidStr, processCommand, "idle",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.processDesc.processDramJoulesTotal,
-				prometheus.CounterValue,
-				float64(process.DynEnergyInDRAM.Aggr)/miliJouleToJoule,
-				pidStr, processCommand, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.processDesc.processDramJoulesTotal,
-				prometheus.CounterValue,
-				float64(process.IdleEnergyInDRAM.Aggr)/miliJouleToJoule,
-				pidStr, processCommand, "idle",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.processDesc.processPackageJoulesTotal,
-				prometheus.CounterValue,
-				float64(process.DynEnergyInPkg.Aggr)/miliJouleToJoule,
-				pidStr, processCommand, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.processDesc.processPackageJoulesTotal,
-				prometheus.CounterValue,
-				float64(process.IdleEnergyInPkg.Aggr)/miliJouleToJoule,
-				pidStr, processCommand, "idle",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.processDesc.processOtherComponentsJoulesTotal,
-				prometheus.CounterValue,
-				float64(process.DynEnergyInOther.Aggr)/miliJouleToJoule,
-				pidStr, processCommand, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.processDesc.processOtherComponentsJoulesTotal,
-				prometheus.CounterValue,
-				float64(process.IdleEnergyInOther.Aggr)/miliJouleToJoule,
-				pidStr, processCommand, "idle",
-			)
-			if config.EnabledGPU {
-				ch <- prometheus.MustNewConstMetric(
-					p.processDesc.processGPUJoulesTotal,
-					prometheus.CounterValue,
-					float64(process.DynEnergyInGPU.Aggr)/miliJouleToJoule,
-					pidStr, processCommand, "dynamic",
-				)
-				ch <- prometheus.MustNewConstMetric(
-					p.processDesc.processGPUJoulesTotal,
-					prometheus.CounterValue,
-					float64(process.IdleEnergyInGPU.Aggr)/miliJouleToJoule,
-					pidStr, processCommand, "idle",
-				)
-			}
-			ch <- prometheus.MustNewConstMetric(
-				p.processDesc.processJoulesTotal,
-				prometheus.CounterValue,
-				(float64(process.DynEnergyInPkg.Aggr)/miliJouleToJoule +
-					float64(process.DynEnergyInUncore.Aggr)/miliJouleToJoule +
-					float64(process.DynEnergyInDRAM.Aggr)/miliJouleToJoule +
-					float64(process.DynEnergyInGPU.Aggr)/miliJouleToJoule +
-					float64(process.DynEnergyInOther.Aggr)/miliJouleToJoule),
-				pidStr, processCommand, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.processDesc.processJoulesTotal,
-				prometheus.CounterValue,
-				(float64(process.IdleEnergyInPkg.Aggr)/miliJouleToJoule +
-					float64(process.IdleEnergyInUncore.Aggr)/miliJouleToJoule +
-					float64(process.IdleEnergyInDRAM.Aggr)/miliJouleToJoule +
-					float64(process.IdleEnergyInGPU.Aggr)/miliJouleToJoule +
-					float64(process.IdleEnergyInOther.Aggr)/miliJouleToJoule),
-				pidStr, processCommand, "idle",
-			)
-			if collector_metric.CPUHardwareCounterEnabled {
-				if process.BPFStats[attacher.CPUCycleLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.processDesc.processCPUCyclesTotal,
-						prometheus.CounterValue,
-						float64(process.BPFStats[attacher.CPUCycleLabel].Aggr),
-						pidStr, processCommand,
-					)
-				}
-				if process.BPFStats[attacher.CPUInstructionLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.processDesc.processCPUInstrTotal,
-						prometheus.CounterValue,
-						float64(process.BPFStats[attacher.CPUInstructionLabel].Aggr),
-						pidStr, processCommand,
-					)
-				}
-				if process.BPFStats[attacher.CacheMissLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.processDesc.processCacheMissTotal,
-						prometheus.CounterValue,
-						float64(process.BPFStats[attacher.CacheMissLabel].Aggr),
-						pidStr, processCommand,
-					)
-				}
-			}
-			if config.ExposeIRQCounterMetrics {
-				if process.BPFStats[config.IRQNetTXLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.processDesc.processNetTxIRQTotal,
-						prometheus.CounterValue,
-						float64(process.BPFStats[config.IRQNetTXLabel].Aggr),
-						pidStr, processCommand,
-					)
-				}
-				if process.BPFStats[config.IRQNetRXLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.processDesc.processNetRxIRQTotal,
-						prometheus.CounterValue,
-						float64(process.BPFStats[config.IRQNetRXLabel].Aggr),
-						pidStr, processCommand,
-					)
-				}
-				if process.BPFStats[config.IRQBlockLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.processDesc.processBlockIRQTotal,
-						prometheus.CounterValue,
-						float64(process.BPFStats[config.IRQBlockLabel].Aggr),
-						pidStr, processCommand,
-					)
-				}
-			}
-		}(pid, process)
-	}
-}
diff --git a/pkg/collector/prometheus_vm_collector.go b/pkg/collector/prometheus_vm_collector.go
deleted file mode 100644
index f278c2bece..0000000000
--- a/pkg/collector/prometheus_vm_collector.go
+++ /dev/null
@@ -1,345 +0,0 @@
-/*
-Copyright 2023.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-//nolint:dupl // should be refactor with process collector
-package collector
-
-import (
-	"strconv"
-	"sync"
-
-	"github.com/prometheus/client_golang/prometheus"
-
-	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-)
-
-type vmDesc struct {
-	// Energy (counter)
-	vmCoreJoulesTotal            *prometheus.Desc
-	vmUncoreJoulesTotal          *prometheus.Desc
-	vmDramJoulesTotal            *prometheus.Desc
-	vmPackageJoulesTotal         *prometheus.Desc
-	vmOtherComponentsJoulesTotal *prometheus.Desc
-	vmGPUJoulesTotal             *prometheus.Desc
-	vmJoulesTotal                *prometheus.Desc
-
-	// Hardware Counters (counter)
-	vmCPUCyclesTotal *prometheus.Desc
-	vmCPUInstrTotal  *prometheus.Desc
-	vmCacheMissTotal *prometheus.Desc
-
-	// Additional metrics (gauge)
-	vmCPUTime *prometheus.Desc
-
-	// IRQ metrics
-	vmNetTxIRQTotal *prometheus.Desc
-	vmNetRxIRQTotal *prometheus.Desc
-	vmBlockIRQTotal *prometheus.Desc
-}
-
-// describevm is called by Describe to implement the prometheus.Collector interface
-func (p *PrometheusCollector) describeVM(ch chan<- *prometheus.Desc) {
-	// vm Energy (counter)
-	ch <- p.vmDesc.vmCoreJoulesTotal
-	ch <- p.vmDesc.vmUncoreJoulesTotal
-	ch <- p.vmDesc.vmDramJoulesTotal
-	ch <- p.vmDesc.vmPackageJoulesTotal
-	ch <- p.vmDesc.vmOtherComponentsJoulesTotal
-	if config.EnabledGPU {
-		ch <- p.vmDesc.vmGPUJoulesTotal
-	}
-	ch <- p.vmDesc.vmJoulesTotal
-
-	// vm Hardware Counters (counter)
-	if collector_metric.CPUHardwareCounterEnabled {
-		ch <- p.vmDesc.vmCPUCyclesTotal
-		ch <- p.vmDesc.vmCPUInstrTotal
-		ch <- p.vmDesc.vmCacheMissTotal
-	}
-
-	if config.ExposeIRQCounterMetrics {
-		ch <- p.vmDesc.vmNetTxIRQTotal
-		ch <- p.vmDesc.vmNetRxIRQTotal
-		ch <- p.vmDesc.vmBlockIRQTotal
-	}
-}
-
-func (p *PrometheusCollector) newVMMetrics() {
-	// Energy (counter)
-	vmCoreJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "core_joules_total"),
-		"Aggregated RAPL value in core in joules",
-		[]string{"pid", "name", "mode"}, nil,
-	)
-	vmUncoreJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "uncore_joules_total"),
-		"Aggregated RAPL value in uncore in joules",
-		[]string{"pid", "name", "mode"}, nil,
-	)
-	vmDramJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "dram_joules_total"),
-		"Aggregated RAPL value in dram in joules",
-		[]string{"pid", "name", "mode"}, nil,
-	)
-	vmPackageJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "package_joules_total"),
-		"Aggregated RAPL value in package (socket) in joules",
-		[]string{"pid", "name", "mode"}, nil,
-	)
-	vmOtherComponentsJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "other_host_components_joules_total"),
-		"Aggregated value in other host components (platform - package - dram) in joules",
-		[]string{"pid", "name", "mode"}, nil,
-	)
-	vmGPUJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "gpu_joules_total"),
-		"Aggregated GPU value in joules",
-		[]string{"pid", "name", "mode"}, nil,
-	)
-	vmJoulesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "joules_total"),
-		"Aggregated RAPL Package + Uncore + DRAM + GPU + other host components (platform - package - dram) in joules",
-		[]string{"pid", "name", "mode"}, nil,
-	)
-
-	// Hardware Counters (counter)
-	vmCPUCyclesTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "cpu_cycles_total"),
-		"Aggregated CPU cycle value",
-		[]string{"pid", "name"}, nil,
-	)
-	vmCPUInstrTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "cpu_instructions_total"),
-		"Aggregated CPU instruction value",
-		[]string{"pid", "name"}, nil,
-	)
-	vmCacheMissTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "cache_miss_total"),
-		"Aggregated cache miss value",
-		[]string{"pid", "name"}, nil,
-	)
-	// Additional metrics (gauge)
-	vmCPUTime := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "cpu_cpu_time_us"),
-		"Aggregated CPU time",
-		[]string{"pid", "name"}, nil)
-
-	// network irq metrics
-	vmNetTxIRQTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "bpf_net_tx_irq_total"),
-		"Aggregated network tx irq value obtained from BPF",
-		[]string{"pid", "name"}, nil,
-	)
-	vmNetRxIRQTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "bpf_net_rx_irq_total"),
-		"Aggregated network rx irq value obtained from BPF",
-		[]string{"pid", "name"}, nil,
-	)
-	vmBlockIRQTotal := prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "vm", "bpf_block_irq_total"),
-		"Aggregated block irq value obtained from BPF",
-		[]string{"pid", "name"}, nil,
-	)
-
-	p.vmDesc = &vmDesc{
-		vmCoreJoulesTotal:            vmCoreJoulesTotal,
-		vmUncoreJoulesTotal:          vmUncoreJoulesTotal,
-		vmDramJoulesTotal:            vmDramJoulesTotal,
-		vmPackageJoulesTotal:         vmPackageJoulesTotal,
-		vmOtherComponentsJoulesTotal: vmOtherComponentsJoulesTotal,
-		vmGPUJoulesTotal:             vmGPUJoulesTotal,
-		vmJoulesTotal:                vmJoulesTotal,
-		vmCPUCyclesTotal:             vmCPUCyclesTotal,
-		vmCPUInstrTotal:              vmCPUInstrTotal,
-		vmCacheMissTotal:             vmCacheMissTotal,
-		vmCPUTime:                    vmCPUTime,
-		vmNetTxIRQTotal:              vmNetTxIRQTotal,
-		vmNetRxIRQTotal:              vmNetRxIRQTotal,
-		vmBlockIRQTotal:              vmBlockIRQTotal,
-	}
-}
-
-// updatevmMetrics send vm metrics to prometheus
-func (p *PrometheusCollector) updateVMMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric) {
-	// "Instance Name" in openstack are 17 characters strings
-	const nameLenLimit = 17
-	for pid, vm := range *p.VMMetrics {
-		wg.Add(1)
-		go func(pid uint64, vm *collector_metric.VMMetrics) {
-			defer wg.Done()
-			vmName := vm.Name
-			if len(vmName) > nameLenLimit {
-				vmName = vm.Name[:nameLenLimit]
-			}
-			pidStr := strconv.FormatUint(pid, 10)
-			if vm.BPFStats[config.CPUTime] != nil {
-				ch <- prometheus.MustNewConstMetric(
-					p.vmDesc.vmCPUTime,
-					prometheus.CounterValue,
-					float64(vm.BPFStats[config.CPUTime].Aggr),
-					pidStr, vmName,
-				)
-			}
-			ch <- prometheus.MustNewConstMetric(
-				p.vmDesc.vmCoreJoulesTotal,
-				prometheus.CounterValue,
-				float64(vm.DynEnergyInCore.Aggr)/miliJouleToJoule,
-				pidStr, vmName, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.vmDesc.vmCoreJoulesTotal,
-				prometheus.CounterValue,
-				float64(vm.IdleEnergyInCore.Aggr)/miliJouleToJoule,
-				pidStr, vmName, "idle",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.vmDesc.vmUncoreJoulesTotal,
-				prometheus.CounterValue,
-				float64(vm.DynEnergyInUncore.Aggr)/miliJouleToJoule,
-				pidStr, vmName, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.vmDesc.vmUncoreJoulesTotal,
-				prometheus.CounterValue,
-				float64(vm.IdleEnergyInUncore.Aggr)/miliJouleToJoule,
-				pidStr, vmName, "idle",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.vmDesc.vmDramJoulesTotal,
-				prometheus.CounterValue,
-				float64(vm.DynEnergyInDRAM.Aggr)/miliJouleToJoule,
-				pidStr, vmName, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.vmDesc.vmDramJoulesTotal,
-				prometheus.CounterValue,
-				float64(vm.IdleEnergyInDRAM.Aggr)/miliJouleToJoule,
-				pidStr, vmName, "idle",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.vmDesc.vmPackageJoulesTotal,
-				prometheus.CounterValue,
-				float64(vm.DynEnergyInPkg.Aggr)/miliJouleToJoule,
-				pidStr, vmName, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.vmDesc.vmPackageJoulesTotal,
-				prometheus.CounterValue,
-				float64(vm.IdleEnergyInPkg.Aggr)/miliJouleToJoule,
-				pidStr, vmName, "idle",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.vmDesc.vmOtherComponentsJoulesTotal,
-				prometheus.CounterValue,
-				float64(vm.DynEnergyInOther.Aggr)/miliJouleToJoule,
-				pidStr, vmName, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.vmDesc.vmOtherComponentsJoulesTotal,
-				prometheus.CounterValue,
-				float64(vm.IdleEnergyInOther.Aggr)/miliJouleToJoule,
-				pidStr, vmName, "idle",
-			)
-			if config.EnabledGPU {
-				ch <- prometheus.MustNewConstMetric(
-					p.vmDesc.vmGPUJoulesTotal,
-					prometheus.CounterValue,
-					float64(vm.DynEnergyInGPU.Aggr)/miliJouleToJoule,
-					pidStr, vmName, "dynamic",
-				)
-				ch <- prometheus.MustNewConstMetric(
-					p.vmDesc.vmGPUJoulesTotal,
-					prometheus.CounterValue,
-					float64(vm.IdleEnergyInGPU.Aggr)/miliJouleToJoule,
-					pidStr, vmName, "idle",
-				)
-			}
-			ch <- prometheus.MustNewConstMetric(
-				p.vmDesc.vmJoulesTotal,
-				prometheus.CounterValue,
-				(float64(vm.DynEnergyInPkg.Aggr)/miliJouleToJoule +
-					float64(vm.DynEnergyInUncore.Aggr)/miliJouleToJoule +
-					float64(vm.DynEnergyInDRAM.Aggr)/miliJouleToJoule +
-					float64(vm.DynEnergyInGPU.Aggr)/miliJouleToJoule +
-					float64(vm.DynEnergyInOther.Aggr)/miliJouleToJoule),
-				pidStr, vmName, "dynamic",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				p.vmDesc.vmJoulesTotal,
-				prometheus.CounterValue,
-				(float64(vm.IdleEnergyInPkg.Aggr)/miliJouleToJoule +
-					float64(vm.IdleEnergyInUncore.Aggr)/miliJouleToJoule +
-					float64(vm.IdleEnergyInDRAM.Aggr)/miliJouleToJoule +
-					float64(vm.IdleEnergyInGPU.Aggr)/miliJouleToJoule +
-					float64(vm.IdleEnergyInOther.Aggr)/miliJouleToJoule),
-				pidStr, vmName, "idle",
-			)
-			if collector_metric.CPUHardwareCounterEnabled {
-				if vm.BPFStats[attacher.CPUCycleLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.vmDesc.vmCPUCyclesTotal,
-						prometheus.CounterValue,
-						float64(vm.BPFStats[attacher.CPUCycleLabel].Aggr),
-						pidStr, vmName,
-					)
-				}
-				if vm.BPFStats[attacher.CPUInstructionLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.vmDesc.vmCPUInstrTotal,
-						prometheus.CounterValue,
-						float64(vm.BPFStats[attacher.CPUInstructionLabel].Aggr),
-						pidStr, vmName,
-					)
-				}
-				if vm.BPFStats[attacher.CacheMissLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.vmDesc.vmCacheMissTotal,
-						prometheus.CounterValue,
-						float64(vm.BPFStats[attacher.CacheMissLabel].Aggr),
-						pidStr, vmName,
-					)
-				}
-			}
-			if config.ExposeIRQCounterMetrics {
-				if vm.BPFStats[config.IRQNetTXLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.vmDesc.vmNetTxIRQTotal,
-						prometheus.CounterValue,
-						float64(vm.BPFStats[config.IRQNetTXLabel].Aggr),
-						pidStr, vmName,
-					)
-				}
-				if vm.BPFStats[config.IRQNetRXLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.vmDesc.vmNetRxIRQTotal,
-						prometheus.CounterValue,
-						float64(vm.BPFStats[config.IRQNetRXLabel].Aggr),
-						pidStr, vmName,
-					)
-				}
-				if vm.BPFStats[config.IRQBlockLabel] != nil {
-					ch <- prometheus.MustNewConstMetric(
-						p.vmDesc.vmBlockIRQTotal,
-						prometheus.CounterValue,
-						float64(vm.BPFStats[config.IRQBlockLabel].Aggr),
-						pidStr, vmName,
-					)
-				}
-			}
-		}(pid, vm)
-	}
-}
diff --git a/pkg/collector/node_accelerator_qat_collector.go b/pkg/collector/resourceutilization/accelerator/node_accelerator_qat_collector.go
similarity index 60%
rename from pkg/collector/node_accelerator_qat_collector.go
rename to pkg/collector/resourceutilization/accelerator/node_accelerator_qat_collector.go
index b8da97a32e..c1fb0962c6 100644
--- a/pkg/collector/node_accelerator_qat_collector.go
+++ b/pkg/collector/resourceutilization/accelerator/node_accelerator_qat_collector.go
@@ -14,23 +14,27 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package collector
+package accelerator
 
 import (
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/qat"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/qat"
 	"k8s.io/klog/v2"
 )
 
-// updateQATMetrics update QAT metrics from telemetry data
-func (c *Collector) updateQATMetrics() {
+// UpdateNodeQATMetrics update QAT metrics from telemetry data
+func UpdateNodeQATMetrics(nodeStats *stats.NodeStats) {
 	// get available QAT devices
 	devices := qat.GetQATs()
 	if len(devices) != 0 {
-		utils, err := qat.GetQATUtilization(devices)
+		deviceUtil, err := qat.GetQATUtilization(devices)
 		if err != nil {
 			klog.V(5).Infoln(err)
 		}
-		c.NodeMetrics.QATUtilization = utils
+		for devID, sample := range deviceUtil {
+			nodeStats.ResourceUsage[config.QATUtilization].SetDeltaStat(devID, sample.SampleCnt)
+		}
 	} else {
 		klog.V(5).Infoln("Unable to find an available QAT. Please check the status of QAT again")
 	}
diff --git a/pkg/collector/resourceutilization/accelerator/process_gpu_collector.go b/pkg/collector/resourceutilization/accelerator/process_gpu_collector.go
new file mode 100644
index 0000000000..3a933a4da3
--- /dev/null
+++ b/pkg/collector/resourceutilization/accelerator/process_gpu_collector.go
@@ -0,0 +1,97 @@
+/*
+Copyright 2021.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package accelerator
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/sustainable-computing-io/kepler/pkg/cgroup"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/libvirt"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu"
+	gpu_source "github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu/source"
+	"k8s.io/klog/v2"
+
+	"github.com/sustainable-computing-io/kepler/pkg/utils"
+)
+
+const (
+	procPath string = "/proc/%d/cgroup"
+)
+
+var (
+	// lastUtilizationTimestamp represents the CPU timestamp in microseconds at which utilization samples were last read
+	lastUtilizationTimestamp time.Time = time.Now()
+)
+
+// updateProcessBPFMetrics reads the BPF tables with process/pid/cgroupid metrics (CPU time, available HW counters)
+func UpdateNodeGPUUtilizationMetrics(processStats map[uint64]*stats.ProcessStats) {
+	var err error
+	var processesUtilization map[uint32]gpu_source.ProcessUtilizationSample
+	// calculate the gpu's processes energy consumption for each gpu
+	for _, device := range gpu.GetGpus() {
+		if processesUtilization, err = gpu.GetProcessResourceUtilizationPerDevice(device, time.Since(lastUtilizationTimestamp)); err != nil {
+			klog.Infoln(err)
+			continue
+		}
+
+		for pid, processUtilization := range processesUtilization {
+			uintPid := uint64(pid)
+			// if the process was not indentified by the bpf metrics, create a new metric object
+			if _, exist := processStats[uintPid]; !exist {
+				command := getProcessCommand(uintPid)
+				containerID := utils.SystemProcessName
+
+				// if the pid is within a container, it will have an container ID
+				if config.IsExposeContainerStatsEnabled() {
+					if containerID, err = cgroup.GetContainerIDFromPID(uintPid); err != nil {
+						klog.V(6).Infof("failed to resolve container for Pid %v (command=%s): %v, set containerID=%s", pid, command, err, containerID)
+					}
+				}
+
+				// if the pid is within a VM, it will have an VM ID
+				vmID := utils.EmptyString
+				if config.IsExposeVMStatsEnabled() {
+					if config.IsExposeVMStatsEnabled() {
+						vmID, err = libvirt.GetVMID(uintPid)
+						if err != nil {
+							klog.V(6).Infof("failed to resolve VM ID for PID %v (command=%s): %v", pid, command, err)
+						}
+					}
+				}
+				processStats[uintPid] = stats.NewProcessStats(uintPid, uint64(0), containerID, vmID, command)
+			}
+			processStats[uintPid].ResourceUsage[config.GPUSMUtilization].AddDeltaStat(utils.GenericSocketID, uint64(processUtilization.SmUtil))
+			processStats[uintPid].ResourceUsage[config.GPUMemUtilization].AddDeltaStat(utils.GenericSocketID, uint64(processUtilization.MemUtil))
+		}
+	}
+
+	lastUtilizationTimestamp = time.Now()
+}
+
+func getProcessCommand(pid uint64) string {
+	fileName := fmt.Sprintf(procPath, pid)
+	// Read the file
+	comm, err := os.ReadFile(fileName)
+	if err != nil {
+		return ""
+	}
+	return string(comm)
+}
diff --git a/pkg/collector/resourceutilization/bpf/process_bpf_collector.go b/pkg/collector/resourceutilization/bpf/process_bpf_collector.go
new file mode 100644
index 0000000000..330384ea20
--- /dev/null
+++ b/pkg/collector/resourceutilization/bpf/process_bpf_collector.go
@@ -0,0 +1,124 @@
+/*
+Copyright 2021.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package bpf
+
+import "C"
+import (
+	"unsafe"
+
+	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
+	"github.com/sustainable-computing-io/kepler/pkg/cgroup"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/libvirt"
+	"github.com/sustainable-computing-io/kepler/pkg/utils"
+
+	"k8s.io/klog/v2"
+)
+
+type ProcessBPFMetrics = attacher.ProcessBPFMetrics
+
+// update software counter metrics
+func updateSWCounters(key uint64, ct *ProcessBPFMetrics, processStats map[uint64]*stats.ProcessStats) {
+	// update ebpf metrics
+	// first update CPU time and Page Cache Hit
+	processStats[key].ResourceUsage[config.CPUTime].AddDeltaStat(utils.GenericSocketID, ct.ProcessRunTime)
+	processStats[key].ResourceUsage[config.PageCacheHit].AddDeltaStat(utils.GenericSocketID, ct.PageCacheHit/(1000*1000))
+	// update IRQ vector. Soft IRQ events has the events ordered
+	for i, event := range attacher.SoftIRQEvents {
+		processStats[key].ResourceUsage[event].AddDeltaStat(utils.GenericSocketID, uint64(ct.VecNR[i]))
+	}
+}
+
+// update hardware counter metrics
+func updateHWCounters(key uint64, ct *ProcessBPFMetrics, processStats map[uint64]*stats.ProcessStats) {
+	// update HW counters
+	for _, counterKey := range stats.AvailableBPFHWCounters {
+		var val uint64
+		var event string
+		switch counterKey {
+		case config.CPUCycle:
+			val = ct.CPUCycles
+			event = config.CPUCycle
+		case config.CPURefCycle:
+			val = ct.CPUCycles
+			event = config.CPURefCycle
+		case config.CPUInstruction:
+			val = ct.CPUInstr
+			event = config.CPUInstruction
+		case config.CacheMiss:
+			val = ct.CacheMisses
+			event = config.CacheMiss
+		default:
+			klog.Errorf("counter %s is not supported\n", counterKey)
+		}
+		processStats[key].ResourceUsage[event].AddDeltaStat(utils.GenericSocketID, val)
+	}
+}
+
+// UpdateProcessBPFMetrics reads the BPF tables with process/pid/cgroupid metrics (CPU time, available HW counters)
+func UpdateProcessBPFMetrics(processStats map[uint64]*stats.ProcessStats) {
+	processesData, err := attacher.CollectProcesses()
+	if err != nil {
+		klog.Errorln("could not collect ebpf metrics")
+		return
+	}
+	for _, ct := range processesData {
+		// skip process without resource utilization
+		if ct.ProcessRunTime == 0 && ct.CacheMisses == 0 && ct.PageCacheHit == 0 {
+			continue
+		}
+
+		comm := C.GoString((*C.char)(unsafe.Pointer(&ct.Command)))
+
+		// if the pid is within a container, it will have a container ID
+		containerID, err := cgroup.GetContainerID(ct.CGroupID, ct.PID, config.EnabledEBPFCgroupID)
+		if err != nil {
+			klog.V(6).Infof("failed to resolve container for PID %v (command=%s): %v, set containerID=%s", ct.PID, comm, err, utils.SystemProcessName)
+		}
+
+		// if the pid is within a VM, it will have an VM ID
+		vmID := utils.EmptyString
+		if config.IsExposeVMStatsEnabled() {
+			vmID, err = libvirt.GetVMID(ct.PID)
+			if err != nil {
+				klog.V(6).Infof("failed to resolve VM ID for PID %v (command=%s): %v", ct.PID, comm, err)
+			}
+		}
+
+		mapKey := ct.PID
+		if ct.CGroupID == 1 {
+			// we aggregate all kernel process to minimize overhead
+			// all kernel process has cgroup id as 1 and pid 1 is also a kernel process
+			mapKey = 1
+		}
+
+		var ok bool
+		var pStat *stats.ProcessStats
+		if pStat, ok = processStats[mapKey]; !ok {
+			pStat = stats.NewProcessStats(ct.PID, ct.CGroupID, containerID, vmID, comm)
+			processStats[mapKey] = pStat
+		} else if pStat.Command == "" {
+			pStat.Command = comm
+		}
+		// when the process metrics are updated, reset the idle counter
+		pStat.IdleCounter = 0
+
+		updateSWCounters(mapKey, &ct, processStats)
+		updateHWCounters(mapKey, &ct, processStats)
+	}
+}
diff --git a/pkg/collector/container_hc_collector_test.go b/pkg/collector/resourceutilization/bpf/process_bpf_collector_test.go
similarity index 83%
rename from pkg/collector/container_hc_collector_test.go
rename to pkg/collector/resourceutilization/bpf/process_bpf_collector_test.go
index d07ddfa74c..a98430e9a6 100644
--- a/pkg/collector/container_hc_collector_test.go
+++ b/pkg/collector/resourceutilization/bpf/process_bpf_collector_test.go
@@ -1,4 +1,4 @@
-package collector
+package bpf
 
 import (
 	. "github.com/onsi/ginkgo/v2"
diff --git a/pkg/collector/container_cgroup_collector.go b/pkg/collector/resourceutilization/cgroup/container_cgroup_collector.go
similarity index 59%
rename from pkg/collector/container_cgroup_collector.go
rename to pkg/collector/resourceutilization/cgroup/container_cgroup_collector.go
index 9fdcfdea6c..e9d19b5ddd 100644
--- a/pkg/collector/container_cgroup_collector.go
+++ b/pkg/collector/resourceutilization/cgroup/container_cgroup_collector.go
@@ -14,42 +14,44 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package collector
+package cgroup
 
 import (
 	"strings"
 
 	"github.com/sustainable-computing-io/kepler/pkg/cgroup"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/utils"
 
 	"k8s.io/klog/v2"
 )
 
-// updateCgroupMetrics adds container-level cgroup data
-func (c *Collector) updateCgroupMetrics() {
-	for key := range c.ContainersMetrics {
-		if c.ContainersMetrics[key].CgroupStatHandler == nil {
-			for pid := range c.ContainersMetrics[key].PIDS {
+// UpdateContainerCgroupMetrics adds container-level cgroup data
+func UpdateContainerCgroupMetrics(containerStats map[string]*stats.ContainerStats) {
+	for key := range containerStats {
+		if containerStats[key].CgroupStatHandler == nil {
+			for pid := range containerStats[key].PIDS {
 				if pid == 0 {
 					klog.V(3).Infof("PID 0 does not have cgroup metrics since there is no /proc/0/cgroup")
 					continue
 				}
-				handler, err := cgroup.NewCGroupStatManager(pid)
+				handler, err := cgroup.NewCGroupStatManager(int(pid))
 				if err != nil {
 					klog.V(3).Infof("Error: could not start cgroup stat handler for PID %d: %v", pid, err)
 					continue
 				}
-				c.ContainersMetrics[key].CgroupStatHandler = handler
+				containerStats[key].CgroupStatHandler = handler
 				break
 			}
 		}
 		// we need to test again in case the cgroup handler could not be created, e.g., for system processes
-		if c.ContainersMetrics[key].CgroupStatHandler != nil {
-			if err := c.ContainersMetrics[key].UpdateCgroupMetrics(); err != nil {
+		if containerStats[key].CgroupStatHandler != nil {
+			if err := containerStats[key].UpdateCgroupMetrics(); err != nil {
 				// if the cgroup metrics of a container does not exist, it means that the container was deleted
-				if key != c.systemProcessName && strings.Contains(err.Error(), "cgroup deleted") {
-					delete(c.ContainersMetrics, key)
+				if key != utils.SystemProcessName && strings.Contains(err.Error(), "cgroup deleted") {
+					delete(containerStats, key)
 					klog.V(1).Infof("Container/Pod %s/%s was removed from the map because the cgroup was deleted",
-						c.ContainersMetrics[key].ContainerName, c.ContainersMetrics[key].PodName)
+						containerStats[key].ContainerName, containerStats[key].PodName)
 				}
 			}
 		}
diff --git a/pkg/collector/stats/benchmark_test.go b/pkg/collector/stats/benchmark_test.go
new file mode 100644
index 0000000000..dbee8a30f1
--- /dev/null
+++ b/pkg/collector/stats/benchmark_test.go
@@ -0,0 +1,63 @@
+/*
+Copyright 2023.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+package stats_test
+
+import (
+	"testing"
+
+	"github.com/sustainable-computing-io/kepler/pkg/collector"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/model"
+)
+
+func benchmarkNtesting(b *testing.B, processNumber int) {
+	// enable metrics
+	stats.SetMockedCollectorMetrics()
+	// create node node metrics
+	metricCollector := collector.NewCollector()
+
+	// create processes
+	metricCollector.ProcessStats = stats.CreateMockedProcessStats(processNumber)
+	metricCollector.NodeStats = stats.CreateMockedNodeStats()
+	// aggregate processes' resource utilization metrics to containers, virtual machines and nodes
+	metricCollector.AggregateProcessResourceUtilizationMetrics()
+
+	// The default estimator model is the ratio
+	model.CreatePowerEstimatorModels(stats.ProcessFeaturesNames, stats.NodeMetadataFeatureNames, stats.NodeMetadataFeatureValues)
+
+	// update container and node metrics
+	b.ReportAllocs()
+	b.ResetTimer()
+	metricCollector.UpdateProcessEnergyUtilizationMetrics()
+	metricCollector.AggregateProcessEnergyUtilizationMetrics()
+	b.StopTimer()
+}
+
+func BenchmarkAddNodeResUsageFromContainerResUsageWith1000Container(b *testing.B) {
+	benchmarkNtesting(b, 1000)
+}
+
+func BenchmarkAddNodeResUsageFromContainerResUsageWith2000Container(b *testing.B) {
+	benchmarkNtesting(b, 2000)
+}
+
+func BenchmarkAddNodeResUsageFromContainerResUsageWith4000Container(b *testing.B) {
+	benchmarkNtesting(b, 4000)
+}
+
+func BenchmarkAddNodeResUsageFromContainerResUsageWith8000Container(b *testing.B) {
+	benchmarkNtesting(b, 8000)
+}
diff --git a/pkg/collector/stats/container_stats.go b/pkg/collector/stats/container_stats.go
new file mode 100644
index 0000000000..eae90ea8da
--- /dev/null
+++ b/pkg/collector/stats/container_stats.go
@@ -0,0 +1,93 @@
+/*
+Copyright 2021.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package stats
+
+import (
+	"fmt"
+
+	"github.com/sustainable-computing-io/kepler/pkg/cgroup"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats/types"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"k8s.io/klog/v2"
+)
+
+type ContainerStats struct {
+	Stats
+
+	PIDS          map[uint64]bool
+	ContainerID   string
+	ContainerName string
+	PodName       string
+	Namespace     string
+
+	CgroupStatHandler cgroup.CCgroupStatHandler
+	CgroupStatMap     map[string]*types.UInt64StatCollection
+}
+
+// NewContainerStats creates a new ContainerStats instance
+func NewContainerStats(containerName, podName, podNamespace, containerID string) *ContainerStats {
+	c := &ContainerStats{
+		Stats:         *NewStats(),
+		PIDS:          make(map[uint64]bool),
+		ContainerID:   containerID,
+		PodName:       podName,
+		ContainerName: containerName,
+		Namespace:     podNamespace,
+		CgroupStatMap: make(map[string]*types.UInt64StatCollection),
+	}
+
+	if config.ExposeCgroupMetrics {
+		for _, metricName := range AvailableCGroupMetrics {
+			c.CgroupStatMap[metricName] = types.NewUInt64StatCollection()
+		}
+	}
+
+	return c
+}
+
+// ResetCurr reset all current value to 0
+func (c *ContainerStats) ResetDeltaValues() {
+	c.Stats.ResetDeltaValues()
+	c.PIDS = map[uint64]bool{}
+}
+
+// SetLatestProcess set PID to the latest captured process
+// NOTICE: can lose main container info for multi-container pod
+func (c *ContainerStats) SetLatestProcess(pid uint64) {
+	c.PIDS[pid] = true
+}
+
+func (c *ContainerStats) String() string {
+	return fmt.Sprintf("energy from pod/container: name: %s/%s namespace: %s containerid:%s\n cgroupMetrics: %v\n",
+		c.PodName,
+		c.ContainerName,
+		c.Namespace,
+		c.ContainerID,
+		c.CgroupStatMap,
+	) + c.Stats.String()
+}
+
+func (c *ContainerStats) UpdateCgroupMetrics() error {
+	if c.CgroupStatHandler == nil {
+		return nil
+	}
+	err := c.CgroupStatHandler.SetCGroupStat(c.ContainerID, c.CgroupStatMap)
+	if err != nil {
+		klog.V(3).Infof("Error reading cgroup stats for container %s (%s): %v", c.ContainerName, c.ContainerID, err)
+	}
+	return err
+}
diff --git a/pkg/collector/stats/container_stats_test.go b/pkg/collector/stats/container_stats_test.go
new file mode 100644
index 0000000000..a031b1a0e1
--- /dev/null
+++ b/pkg/collector/stats/container_stats_test.go
@@ -0,0 +1,47 @@
+/*
+Copyright 2021.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package stats
+
+import (
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+)
+
+var _ = Describe("Test Container Metric", func() {
+
+	It("Test ResetDeltaValues", func() {
+		SetMockedCollectorMetrics()
+		c := NewContainerStats("containerA", "podA", "test", "containerIDA")
+		c.ResourceUsage[config.CPUCycle].SetDeltaStat(MockedSocketID, 30000)
+		c.ResourceUsage[config.CPUInstruction].SetDeltaStat(MockedSocketID, 30000)
+		c.ResourceUsage[config.CacheMiss].SetDeltaStat(MockedSocketID, 30000)
+		// add first values to be the idle power
+		c.EnergyUsage[config.AbsEnergyInPkg].SetDeltaStat(MockedSocketID, 10)
+		c.EnergyUsage[config.AbsEnergyInCore].SetDeltaStat(MockedSocketID, 10)
+		c.EnergyUsage[config.AbsEnergyInDRAM].SetDeltaStat(MockedSocketID, 10)
+		// add second values to have dynamic power
+		c.EnergyUsage[config.AbsEnergyInPkg].SetDeltaStat(MockedSocketID, 18)
+		c.EnergyUsage[config.AbsEnergyInCore].SetDeltaStat(MockedSocketID, 15)
+		c.EnergyUsage[config.AbsEnergyInDRAM].SetDeltaStat(MockedSocketID, 11)
+
+		c.ResetDeltaValues()
+
+		delta := c.ResourceUsage[config.CacheMiss].SumAllDeltaValues()
+		Expect(delta).To(Equal(uint64(0)))
+	})
+})
diff --git a/pkg/collector/stats/node_stats.go b/pkg/collector/stats/node_stats.go
new file mode 100644
index 0000000000..9727f57412
--- /dev/null
+++ b/pkg/collector/stats/node_stats.go
@@ -0,0 +1,141 @@
+/*
+Copyright 2021.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package stats
+
+import (
+	"fmt"
+
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu"
+	"github.com/sustainable-computing-io/kepler/pkg/utils"
+)
+
+var (
+	NodeName            = GetNodeName()
+	NodeCPUArchitecture = getCPUArch()
+	NodeCPUPackageMap   = getCPUPackageMap()
+
+	// NodeMetricNames holds the name of the system metadata information.
+	NodeMetadataFeatureNames []string = []string{"cpu_architecture"}
+	// SystemMetadata holds the metadata regarding the system information
+	NodeMetadataFeatureValues []string = []string{NodeCPUArchitecture}
+)
+
+type NodeStats struct {
+	Stats
+
+	// IdleResUtilization is used to determine idle pmap[string]eriods
+	IdleResUtilization map[string]uint64
+}
+
+func NewNodeStats() *NodeStats {
+	return &NodeStats{
+		Stats:              *NewStats(),
+		IdleResUtilization: map[string]uint64{},
+	}
+}
+
+// ResetDeltaValues reset all delta values to 0
+func (ne *NodeStats) ResetDeltaValues() {
+	ne.Stats.ResetDeltaValues()
+}
+
+func (ne *NodeStats) UpdateIdleEnergyWithMinValue(isComponentsSystemCollectionSupported bool) {
+	// gpu metric
+	if config.EnabledGPU && gpu.IsGPUCollectionSupported() {
+		ne.CalcIdleEnergy(config.AbsEnergyInGPU, config.IdleEnergyInGPU, config.GPUSMUtilization)
+	}
+
+	if isComponentsSystemCollectionSupported {
+		ne.CalcIdleEnergy(config.AbsEnergyInCore, config.IdleEnergyInCore, config.CPUTime)
+		ne.CalcIdleEnergy(config.AbsEnergyInDRAM, config.IdleEnergyInDRAM, config.CPUTime) // TODO: we should use another resource for DRAM
+		ne.CalcIdleEnergy(config.AbsEnergyInUnCore, config.IdleEnergyInUnCore, config.CPUTime)
+		ne.CalcIdleEnergy(config.AbsEnergyInPkg, config.IdleEnergyInPkg, config.CPUTime)
+		ne.CalcIdleEnergy(config.AbsEnergyInPlatform, config.IdleEnergyInPlatform, config.CPUTime)
+	}
+}
+
+func (ne *NodeStats) CalcIdleEnergy(absM, idleM, resouceUtil string) {
+	newTotalResUtilization := ne.ResourceUsage[resouceUtil].SumAllDeltaValues()
+	currIdleTotalResUtilization := ne.IdleResUtilization[resouceUtil]
+
+	for socketID := range ne.EnergyUsage[absM].Stat {
+		newIdleDelta := ne.EnergyUsage[absM].Stat[socketID].Delta
+		if newIdleDelta == 0 {
+			// during the first power collection iterations, the delta values could be 0, so we skip until there are delta values
+			continue
+		}
+
+		// add any value if there is no idle power yet
+		if _, exist := ne.EnergyUsage[idleM].Stat[socketID]; !exist {
+			ne.EnergyUsage[idleM].SetDeltaStat(socketID, newIdleDelta)
+			// store the curret CPU utilization to find a new idle power later
+			ne.IdleResUtilization[resouceUtil] = newTotalResUtilization
+		} else {
+			currIdleDelta := ne.EnergyUsage[idleM].Stat[socketID].Delta
+			// verify if there is a new minimal energy consumption for the given resource
+			// TODO: fix verifying the aggregated resource utilization from all sockets, the update the energy per socket can lead to inconsitency
+			if (newTotalResUtilization <= currIdleTotalResUtilization) || (currIdleDelta == 0) {
+				if (currIdleDelta == 0) || (currIdleDelta >= newIdleDelta) {
+					ne.EnergyUsage[idleM].SetDeltaStat(socketID, newIdleDelta)
+					ne.IdleResUtilization[resouceUtil] = newTotalResUtilization
+					continue
+				}
+			}
+			if currIdleDelta == 0 {
+				continue
+			}
+			// as the dynamic and absolute power, the idle power is also a counter to be exported to prometheus
+			// therefore, we accumulate the minimal found idle if no new one was found
+			ne.EnergyUsage[idleM].SetDeltaStat(socketID, currIdleDelta)
+		}
+	}
+}
+
+// SetNodeOtherComponentsEnergy adds the lastest energy consumption collected from the other node's components than CPU and DRAM
+// Other components energy is a special case where the energy is calculated and not measured
+func (ne *NodeStats) SetNodeOtherComponentsEnergy() {
+	// calculate dynamic energy in other components
+	dynCPUComponentsEnergy := ne.EnergyUsage[config.DynEnergyInPkg].SumAllDeltaValues() +
+		ne.EnergyUsage[config.DynEnergyInDRAM].SumAllDeltaValues() +
+		ne.EnergyUsage[config.DynEnergyInGPU].SumAllDeltaValues()
+
+	dynPlatformEnergy := ne.EnergyUsage[config.DynEnergyInPlatform].SumAllDeltaValues()
+
+	if dynPlatformEnergy >= dynCPUComponentsEnergy {
+		otherComponentEnergy := dynPlatformEnergy - dynCPUComponentsEnergy
+		ne.EnergyUsage[config.DynEnergyInOther].SetDeltaStat(utils.GenericSocketID, otherComponentEnergy)
+	}
+
+	// calculate idle energy in other components
+	idleCPUComponentsEnergy := ne.EnergyUsage[config.IdleEnergyInPkg].SumAllDeltaValues() +
+		ne.EnergyUsage[config.IdleEnergyInDRAM].SumAllDeltaValues() +
+		ne.EnergyUsage[config.IdleEnergyInGPU].SumAllDeltaValues()
+
+	idlePlatformEnergy := ne.EnergyUsage[config.IdleEnergyInPlatform].SumAllDeltaValues()
+
+	if idlePlatformEnergy >= idleCPUComponentsEnergy {
+		otherComponentEnergy := idlePlatformEnergy - idleCPUComponentsEnergy
+		ne.EnergyUsage[config.IdleEnergyInOther].SetDeltaStat(utils.GenericSocketID, otherComponentEnergy)
+	}
+}
+
+func (ne *NodeStats) String() string {
+	return fmt.Sprintf("node energy (mJ): \n"+
+		"%v\n", ne.Stats.String(),
+	)
+}
diff --git a/pkg/collector/stats/node_stats_test.go b/pkg/collector/stats/node_stats_test.go
new file mode 100644
index 0000000000..c680470f86
--- /dev/null
+++ b/pkg/collector/stats/node_stats_test.go
@@ -0,0 +1,81 @@
+/*
+Copyright 2021.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package stats
+
+import (
+	"fmt"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+)
+
+var _ = Describe("Test Node Metric", func() {
+	var (
+		processMetrics map[uint64]*ProcessStats
+		nodeMetrics    NodeStats
+	)
+
+	BeforeEach(func() {
+		SetMockedCollectorMetrics()
+		processMetrics = CreateMockedProcessStats(2)
+		nodeMetrics = CreateMockedNodeStats()
+		for _, pMetric := range processMetrics {
+			val := pMetric.ResourceUsage[config.CPUCycle].Stat[MockedSocketID].GetDelta()
+			nodeMetrics.ResourceUsage[config.CPUCycle].AddDeltaStat(MockedSocketID, val)
+
+			val = pMetric.ResourceUsage[config.CPUInstruction].Stat[MockedSocketID].GetDelta()
+			nodeMetrics.ResourceUsage[config.CPUInstruction].AddDeltaStat(MockedSocketID, val)
+
+			val = pMetric.ResourceUsage[config.CacheMiss].Stat[MockedSocketID].GetDelta()
+			nodeMetrics.ResourceUsage[config.CacheMiss].AddDeltaStat(MockedSocketID, val)
+
+			val = pMetric.ResourceUsage[config.CPUTime].Stat[MockedSocketID].GetDelta()
+			nodeMetrics.ResourceUsage[config.CPUTime].AddDeltaStat(MockedSocketID, val)
+		}
+	})
+
+	It("Test nodeMetrics ResourceUsage", func() {
+		v, ok := nodeMetrics.ResourceUsage[config.CPUCycle]
+		Expect(ok).To(Equal(true))
+		Expect(v.Stat[MockedSocketID].GetDelta()).To(Equal(uint64(60000)))
+	})
+
+	It("test SetNodeGPUEnergy", func() {
+		gpuPower := uint64(1)
+		nodeMetrics.EnergyUsage[config.AbsEnergyInGPU].AddDeltaStat(MockedSocketID, gpuPower)
+		fmt.Fprintln(GinkgoWriter, "nodeMetrics", nodeMetrics.EnergyUsage[config.AbsEnergyInGPU])
+		val := nodeMetrics.EnergyUsage[config.AbsEnergyInGPU].SumAllDeltaValues()
+		Expect(val).To(Equal(gpuPower))
+	})
+
+	It("test ResetDeltaValues", func() {
+		nodeMetrics.ResetDeltaValues()
+		val := nodeMetrics.EnergyUsage[config.AbsEnergyInCore].SumAllDeltaValues()
+		Expect(val).To(Equal(uint64(0)))
+	})
+
+	It("test UpdateIdleEnergyWithMinValue", func() {
+		nodeMetrics.UpdateIdleEnergyWithMinValue(true)
+		Expect(nodeMetrics.EnergyUsage[config.IdleEnergyInPkg].SumAllDeltaValues()).ShouldNot(BeNil())
+	})
+
+	It("test String", func() {
+		str := nodeMetrics.String()
+		Expect("node energy (mJ):").To(Equal(str[0:len("node energy (mJ):")]))
+	})
+})
diff --git a/pkg/collector/stats/process_stats.go b/pkg/collector/stats/process_stats.go
new file mode 100644
index 0000000000..f3ed335050
--- /dev/null
+++ b/pkg/collector/stats/process_stats.go
@@ -0,0 +1,64 @@
+/*
+Copyright 2023.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package stats
+
+import (
+	"fmt"
+)
+
+var (
+	// ProcessMetricNames holds the list of names of the container metric
+	ProcessMetricNames []string
+	// ProcessFeaturesNames holds all the feature name of the container stats. This is specific for the machine-learning based models.
+	ProcessFeaturesNames []string
+)
+
+type ProcessStats struct {
+	Stats
+	PID         uint64
+	CGroupID    uint64
+	ContainerID string
+	VMID        string
+	Command     string
+	IdleCounter int
+}
+
+// NewProcessStats creates a new ProcessStats instance
+func NewProcessStats(pid, cGroupID uint64, containerID, vmID, command string) *ProcessStats {
+	p := &ProcessStats{
+		PID:         pid,
+		CGroupID:    cGroupID,
+		ContainerID: containerID,
+		VMID:        vmID,
+		Command:     command,
+		Stats:       *NewStats(),
+	}
+	return p
+}
+
+// ResetDeltaValues reset all delta values to 0
+func (p *ProcessStats) ResetDeltaValues() {
+	p.Stats.ResetDeltaValues()
+	// if the metrics are not updated, this counter will increment, otherwise it will be set to 0
+	p.IdleCounter += 1
+}
+
+func (p *ProcessStats) String() string {
+	return fmt.Sprintf("energy from process pid: %d, containerID: %s, comm: %s\n"+
+		"%v\n", p.PID, p.ContainerID, p.Command, p.Stats.String(),
+	)
+}
diff --git a/pkg/collector/stats/process_stats_test.go b/pkg/collector/stats/process_stats_test.go
new file mode 100644
index 0000000000..c40820fd10
--- /dev/null
+++ b/pkg/collector/stats/process_stats_test.go
@@ -0,0 +1,18 @@
+package stats
+
+import (
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+)
+
+var _ = Describe("ProcessMetric", func() {
+
+	It("Test ResetDeltaValues", func() {
+		SetMockedCollectorMetrics()
+		metrics := CreateMockedProcessStats(1)
+		p := metrics[uint64(1)]
+		p.ResetDeltaValues()
+		Expect(p.ResourceUsage[config.CPUTime].SumAllDeltaValues()).To(Equal(uint64(0)))
+	})
+})
diff --git a/pkg/collector/stats/stats.go b/pkg/collector/stats/stats.go
new file mode 100644
index 0000000000..076e0d14e1
--- /dev/null
+++ b/pkg/collector/stats/stats.go
@@ -0,0 +1,256 @@
+/*
+Copyright 2023.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package stats
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats/types"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu"
+	"k8s.io/klog/v2"
+)
+
+var (
+	// AvailableBPFSWCounters holds a list of eBPF counters that might be collected
+	AvailableBPFSWCounters []string
+	// AvailableBPFHWCounters holds a list of hardware counters that might be collected
+	AvailableBPFHWCounters []string
+	// AvailableCGroupMetrics holds a list of cgroup metrics exposed by the cgroup that might be collected
+	AvailableCGroupMetrics []string
+	// AvailableAbsEnergyMetrics holds a list of absolute energy metrics
+	AvailableAbsEnergyMetrics []string
+	// AvailableDynEnergyMetrics holds a list of dynamic energy metrics
+	AvailableDynEnergyMetrics []string
+	// AvailableIdleEnergyMetrics holds a list of idle energy metrics
+	AvailableIdleEnergyMetrics []string
+	// CPUHardwareCounterEnabled defined if hardware counters should be accounted and exported
+	CPUHardwareCounterEnabled = false
+)
+
+type Stats struct {
+	ResourceUsage map[string]*types.UInt64StatCollection
+	EnergyUsage   map[string]*types.UInt64StatCollection
+}
+
+// NewStats creates a new Stats instance
+func NewStats() *Stats {
+	m := &Stats{
+		ResourceUsage: make(map[string]*types.UInt64StatCollection),
+		EnergyUsage:   make(map[string]*types.UInt64StatCollection),
+	}
+
+	// initialize the energy metrics in the map
+	energyMetrics := []string{}
+	energyMetrics = append(energyMetrics, AvailableDynEnergyMetrics...)
+	energyMetrics = append(energyMetrics, AvailableAbsEnergyMetrics...)
+	energyMetrics = append(energyMetrics, AvailableIdleEnergyMetrics...)
+	for _, metricName := range energyMetrics {
+		m.EnergyUsage[metricName] = types.NewUInt64StatCollection()
+	}
+
+	// initialize the resource utilization metrics in the map
+	resMetrics := []string{}
+	resMetrics = append(resMetrics, AvailableBPFHWCounters...)
+	resMetrics = append(resMetrics, AvailableBPFSWCounters...)
+	// CGroup metrics are deprecated, it will be removed in the future
+	resMetrics = append(resMetrics, AvailableCGroupMetrics...)
+	for _, metricName := range resMetrics {
+		m.ResourceUsage[metricName] = types.NewUInt64StatCollection()
+	}
+
+	if gpu.IsGPUCollectionSupported() {
+		m.ResourceUsage[config.GPUSMUtilization] = types.NewUInt64StatCollection()
+		m.ResourceUsage[config.GPUMemUtilization] = types.NewUInt64StatCollection()
+	}
+
+	if config.IsExposeQATMetricsEnabled() {
+		m.ResourceUsage[config.QATUtilization] = types.NewUInt64StatCollection()
+	}
+
+	if config.IsExposeCPUFrequencyMetricsEnabled() && attacher.HardwareCountersEnabled {
+		m.ResourceUsage[config.CPUFrequency] = types.NewUInt64StatCollection()
+	}
+
+	return m
+}
+
+// ResetDeltaValues reset all current value to 0
+func (m *Stats) ResetDeltaValues() {
+	for _, stat := range m.ResourceUsage {
+		stat.ResetDeltaValues()
+	}
+	for metric, stat := range m.EnergyUsage {
+		if strings.Contains(metric, "idle") {
+			continue // do not reset the idle power metrics
+		}
+		stat.ResetDeltaValues()
+	}
+}
+
+func (m *Stats) String() string {
+	return fmt.Sprintf(
+		"\tDyn ePkg (mJ): %s (eCore: %s eDram: %s eUncore: %s) eGPU (mJ): %s eOther (mJ): %s platform (mJ): %s \n"+
+			"\tIdle ePkg (mJ): %s (eCore: %s eDram: %s eUncore: %s) eGPU (mJ): %s eOther (mJ): %s platform (mJ): %s \n"+
+			"\tResUsage: %v\n",
+		m.EnergyUsage[config.DynEnergyInPkg],
+		m.EnergyUsage[config.DynEnergyInCore],
+		m.EnergyUsage[config.DynEnergyInDRAM],
+		m.EnergyUsage[config.DynEnergyInUnCore],
+		m.EnergyUsage[config.DynEnergyInGPU],
+		m.EnergyUsage[config.DynEnergyInOther],
+		m.EnergyUsage[config.DynEnergyInPlatform],
+		m.EnergyUsage[config.IdleEnergyInPkg],
+		m.EnergyUsage[config.IdleEnergyInCore],
+		m.EnergyUsage[config.IdleEnergyInDRAM],
+		m.EnergyUsage[config.IdleEnergyInUnCore],
+		m.EnergyUsage[config.IdleEnergyInGPU],
+		m.EnergyUsage[config.IdleEnergyInOther],
+		m.EnergyUsage[config.IdleEnergyInPlatform],
+		m.ResourceUsage)
+}
+
+// UpdateDynEnergy calculates the dynamic energy
+func (m *Stats) UpdateDynEnergy() {
+	for pkgID := range m.EnergyUsage[config.AbsEnergyInPkg].Stat {
+		m.CalcDynEnergy(config.AbsEnergyInPkg, config.IdleEnergyInPkg, config.DynEnergyInPkg, pkgID)
+		m.CalcDynEnergy(config.AbsEnergyInCore, config.IdleEnergyInCore, config.DynEnergyInCore, pkgID)
+		m.CalcDynEnergy(config.AbsEnergyInUnCore, config.IdleEnergyInUnCore, config.DynEnergyInUnCore, pkgID)
+		m.CalcDynEnergy(config.AbsEnergyInDRAM, config.IdleEnergyInDRAM, config.DynEnergyInDRAM, pkgID)
+	}
+	for sensorID := range m.EnergyUsage[config.AbsEnergyInPlatform].Stat {
+		m.CalcDynEnergy(config.AbsEnergyInPlatform, config.IdleEnergyInPlatform, config.DynEnergyInPlatform, sensorID)
+	}
+	// gpu metric
+	if config.EnabledGPU && gpu.IsGPUCollectionSupported() {
+		for gpuID := range m.EnergyUsage[config.DynEnergyInGPU].Stat {
+			m.CalcDynEnergy(config.AbsEnergyInGPU, config.IdleEnergyInGPU, config.DynEnergyInGPU, gpuID)
+		}
+	}
+}
+
+// CalcDynEnergy calculate the difference between the absolute and idle energy/power
+func (m *Stats) CalcDynEnergy(absM, idleM, dynM, id string) {
+	if _, exits := m.EnergyUsage[absM].Stat[id]; !exits {
+		return
+	}
+	totalPower := m.EnergyUsage[absM].Stat[id].Delta
+	klog.V(6).Infof("Absolute Energy stat: %v (%s)", m.EnergyUsage[absM].Stat, id)
+	idlePower := uint64(0)
+	if idleStat, found := m.EnergyUsage[idleM].Stat[id]; found {
+		idlePower = idleStat.Delta
+	}
+	dynPower := calcDynEnergy(totalPower, idlePower)
+	m.EnergyUsage[dynM].SetDeltaStat(id, dynPower)
+}
+
+func calcDynEnergy(totalE, idleE uint64) uint64 {
+	if (totalE == 0) || (idleE == 0) || (totalE < idleE) {
+		return 0
+	}
+	return totalE - idleE
+}
+
+func normalize(val float64, shouldNormalize bool) float64 {
+	if shouldNormalize {
+		return val / float64(config.SamplePeriodSec)
+	}
+	return val
+}
+
+// ToEstimatorValues return values regarding metricNames.
+// The metrics can be related to resource utilization or power consumption.
+// Since Kepler collects metrics at intervals of SamplePeriodSec, which is greater than 1 second, and the power models are trained to estimate power in 1 second interval,
+// it is necessary to normalize the resource utilization by the SamplePeriodSec. Note that this is important because the power curve can be different for higher or lower resource usage within 1 second interval.
+func (m *Stats) ToEstimatorValues(featuresName []string, shouldNormalize bool) []float64 {
+	featureValues := []float64{}
+	for _, feature := range featuresName {
+		// verify all metrics that are part of the node resource usage metrics
+		if value, exists := m.ResourceUsage[feature]; exists {
+			featureValues = append(featureValues, normalize(float64(value.SumAllDeltaValues()), shouldNormalize))
+			continue
+		}
+		// some features are not related to resource utilization, such as power metrics
+		switch feature {
+		case config.GeneralUsageMetric: // is an empty string for UNCORE and OTHER resource usage
+			featureValues = append(featureValues, 0)
+
+		case config.DynEnergyInPkg: // for dynamic PKG power consumption
+			value := normalize(float64(m.EnergyUsage[config.DynEnergyInPkg].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		case config.DynEnergyInCore: // for dynamic CORE power consumption
+			value := normalize(float64(m.EnergyUsage[config.DynEnergyInCore].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		case config.DynEnergyInDRAM: // for dynamic PKG power consumption
+			value := normalize(float64(m.EnergyUsage[config.DynEnergyInDRAM].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		case config.DynEnergyInUnCore: // for dynamic UNCORE power consumption
+			value := normalize(float64(m.EnergyUsage[config.DynEnergyInUnCore].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		case config.DynEnergyInOther: // for dynamic OTHER power consumption
+			value := normalize(float64(m.EnergyUsage[config.DynEnergyInOther].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		case config.DynEnergyInPlatform: // for dynamic PLATFORM power consumption
+			value := normalize(float64(m.EnergyUsage[config.DynEnergyInPlatform].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		case config.DynEnergyInGPU: // for dynamic GPU power consumption
+			value := normalize(float64(m.EnergyUsage[config.DynEnergyInGPU].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		case config.IdleEnergyInPkg: // for idle PKG power consumption
+			value := normalize(float64(m.EnergyUsage[config.IdleEnergyInPkg].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		case config.IdleEnergyInCore: // for idle CORE power consumption
+			value := normalize(float64(m.EnergyUsage[config.IdleEnergyInCore].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		case config.IdleEnergyInDRAM: // for idle PKG power consumption
+			value := normalize(float64(m.EnergyUsage[config.IdleEnergyInDRAM].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		case config.IdleEnergyInUnCore: // for idle UNCORE power consumption
+			value := normalize(float64(m.EnergyUsage[config.IdleEnergyInUnCore].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		case config.IdleEnergyInOther: // for idle OTHER power consumption
+			value := normalize(float64(m.EnergyUsage[config.IdleEnergyInOther].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		case config.IdleEnergyInPlatform: // for idle PLATFORM power consumption
+			value := normalize(float64(m.EnergyUsage[config.IdleEnergyInPlatform].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		case config.IdleEnergyInGPU: // for idle GPU power consumption
+			value := normalize(float64(m.EnergyUsage[config.IdleEnergyInGPU].SumAllDeltaValues()), shouldNormalize)
+			featureValues = append(featureValues, value)
+
+		default:
+			klog.V(5).Infof("Unknown node feature: %s, adding 0 value", feature)
+			featureValues = append(featureValues, 0)
+		}
+	}
+	return featureValues
+}
diff --git a/pkg/collector/metric/stats_test.go b/pkg/collector/stats/stats_test.go
similarity index 81%
rename from pkg/collector/metric/stats_test.go
rename to pkg/collector/stats/stats_test.go
index 6654c99c51..f4e3da385e 100644
--- a/pkg/collector/metric/stats_test.go
+++ b/pkg/collector/stats/stats_test.go
@@ -1,4 +1,4 @@
-package metric
+package stats
 
 import (
 	"runtime"
@@ -21,11 +21,11 @@ var _ = Describe("Stats", func() {
 				config.BytesWriteIO,
 				config.BlockDevicesIO,
 			}
-			Expect(len(ContainerFeaturesNames) >= len(exp)).To(BeTrue())
+			Expect(len(ProcessFeaturesNames) >= len(exp)).To(BeTrue())
 		}
 		if runtime.GOOS == "darwin" {
 			exp := []string{config.BlockDevicesIO}
-			Expect(len(ContainerFeaturesNames) >= len(exp)).To(BeTrue())
+			Expect(len(ProcessFeaturesNames) >= len(exp)).To(BeTrue())
 		}
 	})
 })
diff --git a/pkg/collector/metric/suite_test.go b/pkg/collector/stats/suite_test.go
similarity index 98%
rename from pkg/collector/metric/suite_test.go
rename to pkg/collector/stats/suite_test.go
index e76d7a6440..ad069dde18 100644
--- a/pkg/collector/metric/suite_test.go
+++ b/pkg/collector/stats/suite_test.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package metric
+package stats
 
 import (
 	"testing"
diff --git a/pkg/collector/stats/test_utils.go b/pkg/collector/stats/test_utils.go
new file mode 100644
index 0000000000..b8395c6731
--- /dev/null
+++ b/pkg/collector/stats/test_utils.go
@@ -0,0 +1,130 @@
+/*
+Copyright 2023.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package stats
+
+import (
+	"strconv"
+
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu"
+	"k8s.io/klog/v2"
+)
+
+const (
+	MockedSocketID = "socket0"
+)
+
+// SetMockedCollectorMetrics adds all metric to a process, otherwise it will not create the right usageMetric with all elements. The usageMetric is used in the Prediction Power Models
+// TODO: do not use a fixed usageMetric array in the power models, a structured data is more disarable.
+func SetMockedCollectorMetrics() {
+	if gpu.IsGPUCollectionSupported() {
+		err := gpu.Init() // create structure instances that will be accessed to create a processMetric
+		klog.Fatalln(err)
+	}
+	// initialize the Available metrics since they are used to create a new processMetrics instance
+	AvailableBPFHWCounters = []string{
+		config.CPUCycle,
+		config.CPUInstruction,
+		config.CacheMiss,
+	}
+	AvailableBPFSWCounters = []string{
+		config.CPUTime,
+		config.PageCacheHit,
+	}
+	AvailableCGroupMetrics = []string{
+		config.CgroupfsMemory,
+		config.CgroupfsKernelMemory,
+		config.CgroupfsTCPMemory,
+		config.CgroupfsCPU,
+		config.CgroupfsSystemCPU,
+		config.CgroupfsUserCPU,
+		config.CgroupfsReadIO,
+		config.CgroupfsWriteIO,
+		config.BlockDevicesIO,
+	}
+	// ProcessFeaturesNames is used by the nodeMetrics to extract the resource usage. Only the metrics in ProcessFeaturesNames will be used.
+	ProcessFeaturesNames = []string{}
+	ProcessFeaturesNames = append(ProcessFeaturesNames, AvailableBPFSWCounters...)
+	ProcessFeaturesNames = append(ProcessFeaturesNames, AvailableBPFHWCounters...)
+	ProcessFeaturesNames = append(ProcessFeaturesNames, AvailableCGroupMetrics...)
+
+	AvailableAbsEnergyMetrics = []string{
+		config.AbsEnergyInCore, config.AbsEnergyInDRAM, config.AbsEnergyInUnCore, config.AbsEnergyInPkg,
+		config.AbsEnergyInGPU, config.AbsEnergyInOther, config.AbsEnergyInPlatform,
+	}
+	AvailableDynEnergyMetrics = []string{
+		config.DynEnergyInCore, config.DynEnergyInDRAM, config.DynEnergyInUnCore, config.DynEnergyInPkg,
+		config.DynEnergyInGPU, config.DynEnergyInOther, config.DynEnergyInPlatform,
+	}
+	AvailableIdleEnergyMetrics = []string{
+		config.IdleEnergyInCore, config.IdleEnergyInDRAM, config.IdleEnergyInUnCore, config.IdleEnergyInPkg,
+		config.IdleEnergyInGPU, config.IdleEnergyInOther, config.IdleEnergyInPlatform,
+	}
+
+	NodeMetadataFeatureNames = []string{"cpu_architecture"}
+	NodeMetadataFeatureValues = []string{"Sandy Bridge"}
+}
+
+// CreateMockedProcessStats adds two containers with all metrics initialized
+func CreateMockedProcessStats(numContainers int) map[uint64]*ProcessStats {
+	processMetrics := map[uint64]*ProcessStats{}
+	for i := 1; i <= numContainers; i++ {
+		processMetrics[uint64(i)] = createMockedProcessMetric(i)
+	}
+	return processMetrics
+}
+
+// createMockedProcessMetric creates a new process metric with data
+func createMockedProcessMetric(idx int) *ProcessStats {
+	containerID := "container" + strconv.Itoa(idx)
+	vmID := "vm" + strconv.Itoa(idx)
+	command := "command" + strconv.Itoa(idx)
+	uintPid := uint64(idx)
+	processMetrics := NewProcessStats(uintPid, uintPid, containerID, vmID, command)
+	// counter - attacher package
+	processMetrics.ResourceUsage[config.CPUCycle].SetDeltaStat(MockedSocketID, 30000)
+	processMetrics.ResourceUsage[config.CPUInstruction].SetDeltaStat(MockedSocketID, 30000)
+	processMetrics.ResourceUsage[config.CacheMiss].SetDeltaStat(MockedSocketID, 30000)
+	// bpf - cpu time
+	processMetrics.ResourceUsage[config.CPUTime].SetDeltaStat(MockedSocketID, 30000) // config.CPUTime
+	return processMetrics
+}
+
+// CreateMockedNodeStats creates a node metric with power consumption and add the process resource utilization
+func CreateMockedNodeStats() NodeStats {
+	nodeMetrics := NewNodeStats()
+	// add power metrics
+	// add first values to be the idle power
+	nodeMetrics.EnergyUsage[config.AbsEnergyInPkg].SetDeltaStat(MockedSocketID, 5000) // mili joules
+	nodeMetrics.EnergyUsage[config.AbsEnergyInCore].SetDeltaStat(MockedSocketID, 5000)
+	nodeMetrics.EnergyUsage[config.AbsEnergyInDRAM].SetDeltaStat(MockedSocketID, 5000)
+	nodeMetrics.EnergyUsage[config.AbsEnergyInPlatform].SetDeltaStat(MockedSocketID, 5000)
+	// add second values to have dynamic power
+	nodeMetrics.EnergyUsage[config.AbsEnergyInPkg].SetDeltaStat(MockedSocketID, 10000)
+	nodeMetrics.EnergyUsage[config.AbsEnergyInCore].SetDeltaStat(MockedSocketID, 10000)
+	nodeMetrics.EnergyUsage[config.AbsEnergyInDRAM].SetDeltaStat(MockedSocketID, 10000)
+	nodeMetrics.EnergyUsage[config.AbsEnergyInPlatform].SetDeltaStat(MockedSocketID, 10000)
+	nodeMetrics.UpdateIdleEnergyWithMinValue(true)
+	// add second values to have dynamic power
+	nodeMetrics.EnergyUsage[config.AbsEnergyInPkg].SetDeltaStat(MockedSocketID, 45000)
+	nodeMetrics.EnergyUsage[config.AbsEnergyInCore].SetDeltaStat(MockedSocketID, 45000)
+	nodeMetrics.EnergyUsage[config.AbsEnergyInDRAM].SetDeltaStat(MockedSocketID, 45000)
+	nodeMetrics.EnergyUsage[config.AbsEnergyInPlatform].SetDeltaStat(MockedSocketID, 45000)
+	nodeMetrics.UpdateDynEnergy()
+
+	return *nodeMetrics
+}
diff --git a/pkg/collector/metric/types/benchmark_test.go b/pkg/collector/stats/types/benchmark_test.go
similarity index 98%
rename from pkg/collector/metric/types/benchmark_test.go
rename to pkg/collector/stats/types/benchmark_test.go
index fc8faef2f1..97e1501dfa 100644
--- a/pkg/collector/metric/types/benchmark_test.go
+++ b/pkg/collector/stats/types/benchmark_test.go
@@ -20,7 +20,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/sustainable-computing-io/kepler/pkg/collector/metric/types"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats/types"
 )
 
 var seededRand *rand.Rand = rand.New(
diff --git a/pkg/collector/metric/types/types.go b/pkg/collector/stats/types/types.go
similarity index 93%
rename from pkg/collector/metric/types/types.go
rename to pkg/collector/stats/types/types.go
index c7b9a257b8..4ed10ab809 100644
--- a/pkg/collector/metric/types/types.go
+++ b/pkg/collector/stats/types/types.go
@@ -72,6 +72,20 @@ func (s *UInt64Stat) SetNewAggr(newAggr uint64) error {
 	return nil
 }
 
+func (s *UInt64Stat) GetDelta() uint64 {
+	return s.Delta
+}
+
+func (s *UInt64Stat) GetAggr() uint64 {
+	return s.Aggr
+}
+
+func NewUInt64StatCollection() *UInt64StatCollection {
+	return &UInt64StatCollection{
+		Stat: make(map[string]*UInt64Stat),
+	}
+}
+
 // UInt64StatCollection keeps a collection of UInt64Stat
 type UInt64StatCollection struct {
 	Stat map[string]*UInt64Stat
diff --git a/pkg/collector/metric/types/types_suite_test.go b/pkg/collector/stats/types/types_suite_test.go
similarity index 100%
rename from pkg/collector/metric/types/types_suite_test.go
rename to pkg/collector/stats/types/types_suite_test.go
diff --git a/pkg/collector/metric/types/types_test.go b/pkg/collector/stats/types/types_test.go
similarity index 98%
rename from pkg/collector/metric/types/types_test.go
rename to pkg/collector/stats/types/types_test.go
index fd5e2f58c7..e27b3c3b09 100644
--- a/pkg/collector/metric/types/types_test.go
+++ b/pkg/collector/stats/types/types_test.go
@@ -17,7 +17,7 @@ package types_test
 import (
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	"github.com/sustainable-computing-io/kepler/pkg/collector/metric/types"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats/types"
 )
 
 var _ = Describe("Types", func() {
diff --git a/pkg/collector/metric/utils.go b/pkg/collector/stats/utils.go
similarity index 79%
rename from pkg/collector/metric/utils.go
rename to pkg/collector/stats/utils.go
index d73b442a70..42cd41180e 100644
--- a/pkg/collector/metric/utils.go
+++ b/pkg/collector/stats/utils.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package metric
+package stats
 
 import (
 	"fmt"
@@ -25,12 +25,14 @@ import (
 	"strconv"
 	"strings"
 
+	"k8s.io/klog/v2"
+
+	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu"
 
 	cpuidv2 "github.com/klauspost/cpuid/v2"
 	"gopkg.in/yaml.v3"
-	"k8s.io/klog/v2"
 )
 
 const (
@@ -51,36 +53,62 @@ type CPUS struct {
 	cpusInfo []CPUModelData
 }
 
-func getcontainerUintFeatureNames() []string {
+func InitAvailableParamAndMetrics() {
+	AvailableBPFHWCounters = attacher.GetEnabledBPFHWCounters()
+	AvailableBPFSWCounters = attacher.GetEnabledBPFSWCounters()
+	AvailableCGroupMetrics = []string{
+		config.CgroupfsMemory, config.CgroupfsKernelMemory, config.CgroupfsTCPMemory,
+		config.CgroupfsCPU, config.CgroupfsSystemCPU, config.CgroupfsUserCPU,
+		config.CgroupfsReadIO, config.CgroupfsWriteIO, config.BlockDevicesIO,
+	}
+	CPUHardwareCounterEnabled = isCounterStatEnabled(attacher.CPUInstructionLabel)
+	AvailableAbsEnergyMetrics = []string{
+		config.AbsEnergyInCore, config.AbsEnergyInDRAM, config.AbsEnergyInUnCore, config.AbsEnergyInPkg,
+		config.AbsEnergyInGPU, config.AbsEnergyInOther, config.AbsEnergyInPlatform,
+	}
+	AvailableDynEnergyMetrics = []string{
+		config.DynEnergyInCore, config.DynEnergyInDRAM, config.DynEnergyInUnCore, config.DynEnergyInPkg,
+		config.DynEnergyInGPU, config.DynEnergyInOther, config.DynEnergyInPlatform,
+	}
+	AvailableIdleEnergyMetrics = []string{
+		config.IdleEnergyInCore, config.IdleEnergyInDRAM, config.IdleEnergyInUnCore, config.IdleEnergyInPkg,
+		config.IdleEnergyInGPU, config.IdleEnergyInOther, config.IdleEnergyInPlatform,
+	}
+
+	// defined in utils to init metrics
+	setEnabledProcessMetrics()
+}
+
+func getProcessFeatureNames() []string {
 	var metrics []string
-	// bpf metrics
+	// bpf software counter metrics
 	metrics = append(metrics, AvailableBPFSWCounters...)
-	// counter metric
-	metrics = append(metrics, AvailableBPFHWCounters...)
-	// cgroup metric
-	metrics = append(metrics, AvailableCGroupMetrics...)
-	// cgroup kubelet metric
-	metrics = append(metrics, AvailableKubeletMetrics...)
+	klog.V(3).Infof("Available ebpf software counters: %v", AvailableBPFSWCounters)
+
+	// bpf hardware counter metrics
+	if config.IsHCMetricsEnabled() {
+		metrics = append(metrics, AvailableBPFHWCounters...)
+		klog.V(3).Infof("Available ebpf hardware counters: %v", AvailableBPFHWCounters)
+	}
+
 	// gpu metric
 	if config.EnabledGPU && gpu.IsGPUCollectionSupported() {
-		metrics = append(metrics, []string{config.GPUSMUtilization, config.GPUMemUtilization}...)
+		gpuMetrics := []string{config.GPUSMUtilization, config.GPUMemUtilization}
+		metrics = append(metrics, gpuMetrics...)
+		klog.V(3).Infof("Available GPU metrics: %v", gpuMetrics)
 	}
 
-	klog.V(3).Infof("Available ebpf metrics: %v", AvailableBPFSWCounters)
-	klog.V(3).Infof("Available counter metrics: %v", AvailableBPFHWCounters)
-	klog.V(3).Infof("Available cgroup metrics from cgroup: %v", AvailableCGroupMetrics)
-	klog.V(3).Infof("Available cgroup metrics from kubelet: %v", AvailableKubeletMetrics)
-
+	// cgroup metric are deprecated and will be removed later
+	if config.ExposeCgroupMetrics {
+		metrics = append(metrics, AvailableCGroupMetrics...)
+		klog.V(3).Infof("Available cgroup metrics from cgroup: %v", AvailableCGroupMetrics)
+	}
 	return metrics
 }
 
-func setEnabledMetrics() {
-	ContainerFeaturesNames = []string{}
-
-	ContainerUintFeaturesNames = getcontainerUintFeatureNames()
-	ContainerFeaturesNames = append(ContainerFeaturesNames, ContainerFloatFeatureNames...)
-	ContainerFeaturesNames = append(ContainerFeaturesNames, ContainerUintFeaturesNames...)
-	ContainerFeaturesNames = append(ContainerFeaturesNames, blockDeviceLabel)
+func setEnabledProcessMetrics() {
+	ProcessMetricNames = []string{}
+	ProcessFeaturesNames = getProcessFeatureNames()
 }
 
 func isCounterStatEnabled(label string) bool {
diff --git a/pkg/collector/metric/utils_test.go b/pkg/collector/stats/utils_test.go
similarity index 55%
rename from pkg/collector/metric/utils_test.go
rename to pkg/collector/stats/utils_test.go
index 1d3102b624..0e5ba2110d 100644
--- a/pkg/collector/metric/utils_test.go
+++ b/pkg/collector/stats/utils_test.go
@@ -1,4 +1,4 @@
-package metric
+package stats
 
 import (
 	. "github.com/onsi/ginkgo/v2"
@@ -8,14 +8,11 @@ import (
 )
 
 func clearPlatformDependentAvailability() {
+	AvailableBPFSWCounters = []string{config.CPUTime}
 	AvailableBPFHWCounters = []string{}
 	AvailableCGroupMetrics = []string{}
-	AvailableKubeletMetrics = []string{}
 
-	ContainerUintFeaturesNames = getcontainerUintFeatureNames()
-	ContainerFeaturesNames = []string{}
-	ContainerFeaturesNames = append(ContainerFeaturesNames, ContainerUintFeaturesNames...)
-	ContainerFeaturesNames = append(ContainerFeaturesNames, blockDeviceLabel)
+	ProcessFeaturesNames = getProcessFeatureNames()
 }
 
 var _ = Describe("Test Metric Unit", func() {
@@ -31,15 +28,11 @@ var _ = Describe("Test Metric Unit", func() {
 		Expect(exp).To(BeFalse())
 	})
 
-	It("Test setEnabledMetrics", func() {
+	It("Test setEnabledProcessMetrics", func() {
 		config.ExposeHardwareCounterMetrics = false
 		clearPlatformDependentAvailability()
-		setEnabledMetrics()
-		exp := []string{config.BlockDevicesIO}
-		if len(ContainerFeaturesNames) > len(exp) {
-			Expect(exp).To(Equal(ContainerFeaturesNames[len(ContainerFeaturesNames)-len(exp):]))
-		} else {
-			Expect(exp).To(Equal(ContainerFeaturesNames))
-		}
+		setEnabledProcessMetrics()
+		exp := []string{config.CPUTime}
+		Expect(exp).To(Equal(ProcessFeaturesNames))
 	})
 })
diff --git a/pkg/collector/stats/vm_stats.go b/pkg/collector/stats/vm_stats.go
new file mode 100644
index 0000000000..e274edc621
--- /dev/null
+++ b/pkg/collector/stats/vm_stats.go
@@ -0,0 +1,49 @@
+/*
+Copyright 2023.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package stats
+
+var (
+	// VMMetricNames holds the list of names of the vm metric
+	VMMetricNames []string
+	// VMFloatFeatureNames holds the feature name of the vm float stats. This is specific for the machine-learning based models.
+	VMFloatFeatureNames []string = []string{}
+	// VMUintFeaturesNames holds the feature name of the vm utint stats. This is specific for the machine-learning based models.
+	VMUintFeaturesNames []string
+	// VMFeaturesNames holds all the feature name of the vm stats. This is specific for the machine-learning based models.
+	VMFeaturesNames []string
+)
+
+type VMStats struct {
+	Stats
+	PID  uint64
+	VMID string
+}
+
+// NewVMStats creates a new VMStats instance
+func NewVMStats(pid uint64, vmID string) *VMStats {
+	vm := &VMStats{
+		PID:   pid,
+		VMID:  vmID,
+		Stats: *NewStats(),
+	}
+	return vm
+}
+
+// ResetCurr reset all current value to 0
+func (vm *VMStats) ResetDeltaValues() {
+	vm.Stats.ResetDeltaValues()
+}
diff --git a/pkg/collector/stats/vm_stats_test.go b/pkg/collector/stats/vm_stats_test.go
new file mode 100644
index 0000000000..67e7482496
--- /dev/null
+++ b/pkg/collector/stats/vm_stats_test.go
@@ -0,0 +1,18 @@
+package stats
+
+import (
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+)
+
+var _ = Describe("VMMetric", func() {
+
+	It("Test ResetDeltaValues", func() {
+		SetMockedCollectorMetrics()
+		vm := NewVMStats(0, "name")
+		vm.ResourceUsage[config.CPUTime].AddDeltaStat("socket0", 30000)
+		vm.ResetDeltaValues()
+		Expect(vm.ResourceUsage[config.CPUTime].SumAllDeltaValues()).To(Equal(uint64(0)))
+	})
+})
diff --git a/pkg/collector/utils.go b/pkg/collector/utils.go
index a5dad62847..4c9850ac48 100644
--- a/pkg/collector/utils.go
+++ b/pkg/collector/utils.go
@@ -17,22 +17,16 @@ limitations under the License.
 package collector
 
 import (
-	"fmt"
-
 	"github.com/sustainable-computing-io/kepler/pkg/cgroup"
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/utils"
 
 	"github.com/sustainable-computing-io/kepler/pkg/kubernetes"
 )
 
 // this function is only called with the watcher delayed to sync and update the container info or if the watcher is not enabled
-func (c *Collector) createContainersMetricsIfNotExist(containerID string, cGroupID, pid uint64, withCGroupID bool) {
-	if _, ok := c.ContainersMetrics[containerID]; !ok {
-		// We feel the info with generic values because the watcher will eventually update it.
-		podName := c.systemProcessName
-		containerName := c.systemProcessName
-		namespace := c.systemProcessNamespace
-
+func (c *Collector) createContainerStatsIfNotExist(containerID string, cGroupID, pid uint64, withCGroupID bool) {
+	if _, ok := c.ContainerStats[containerID]; !ok {
 		// In case the pod watcher is not enabled, we need to retrieve the information about the
 		// pod and container from the kubelet API. However, we prefer to use the watcher approach
 		// as accessing the kubelet API might be restricted in certain systems.
@@ -41,30 +35,22 @@ func (c *Collector) createContainersMetricsIfNotExist(containerID string, cGroup
 		// containerID (which occasionally occurs), the container will be wrongly identified for its entire lifetime.
 		if !kubernetes.IsWatcherEnabled {
 			info, _ := cgroup.GetContainerInfo(cGroupID, pid, withCGroupID)
-			c.ContainersMetrics[containerID] = collector_metric.NewContainerMetrics(info.ContainerName, info.PodName, info.Namespace, containerID)
+			c.ContainerStats[containerID] = stats.NewContainerStats(
+				info.ContainerName, info.PodName, info.Namespace, containerID)
 		} else {
-			c.ContainersMetrics[containerID] = collector_metric.NewContainerMetrics(
-				podName, containerName, namespace, containerID)
+			name := utils.SystemProcessName
+			namespace := utils.SystemProcessNamespace
+			if cGroupID == 1 {
+				// some kernel processes have cgroup id equal 1 or 0
+				name = utils.KernelProcessName
+				namespace = utils.KernelProcessNamespace
+			}
+			// We feel the info with generic values because the watcher will eventually update it.
+			c.ContainerStats[containerID] = stats.NewContainerStats(
+				name, name, namespace, containerID)
 		}
-	}
-}
-
-func (c *Collector) createProcessMetricsIfNotExist(pid uint64, command string) {
-	if p, ok := c.ProcessMetrics[pid]; !ok {
-		c.ProcessMetrics[pid] = collector_metric.NewProcessMetrics(pid, command)
-	} else if p.Command == "" {
-		p.Command = command
-	}
-}
-
-func addSuffix(name, suffix string) string {
-	return fmt.Sprintf("%s_%s", name, suffix)
-}
-
-func (c *Collector) createVMMetricsIfNotExist(pid uint64, name string) {
-	if p, ok := c.VMMetrics[pid]; !ok {
-		c.VMMetrics[pid] = collector_metric.NewVMMetrics(pid, name)
-	} else if p.Name == "" {
-		p.Name = name
+	} else {
+		// TODO set only the most resource intensive PID for the container
+		c.ContainerStats[containerID].SetLatestProcess(pid)
 	}
 }
diff --git a/pkg/config/config.go b/pkg/config/config.go
index 8362136172..25fdfedd8a 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -72,11 +72,14 @@ var (
 	EnabledEBPFCgroupID          = getBoolConfig("ENABLE_EBPF_CGROUPID", true)
 	EnabledGPU                   = getBoolConfig("ENABLE_GPU", false)
 	EnabledQAT                   = getBoolConfig("ENABLE_QAT", false)
-	EnableProcessMetrics         = getBoolConfig("ENABLE_PROCESS_METRICS", false)
+	EnableProcessStats           = getBoolConfig("ENABLE_PROCESS_METRICS", false)
+	ExposeContainerStats         = getBoolConfig("EXPOSE_CONTAINER_METRICS", true)
+	ExposeVMStats                = getBoolConfig("EXPOSE_VM_METRICS", true)
 	ExposeHardwareCounterMetrics = getBoolConfig("EXPOSE_HW_COUNTER_METRICS", true)
 	ExposeCgroupMetrics          = getBoolConfig("EXPOSE_CGROUP_METRICS", true)
 	ExposeIRQCounterMetrics      = getBoolConfig("EXPOSE_IRQ_COUNTER_METRICS", true)
 	ExposeIdlePowerMetrics       = getBoolConfig("EXPOSE_ESTIMATED_IDLE_POWER_METRICS", false)
+	ExposeCPUFrequencyMetrics    = getBoolConfig("EXPOSE_CPU_FREQUENCY_METRICS", false)
 
 	MetricPathKey   = "METRIC_PATH"
 	BindAddressKey  = "BIND_ADDRESS"
@@ -145,7 +148,7 @@ func logBoolConfigs() {
 		klog.V(5).Infof("ENABLE_EBPF_CGROUPID: %t", EnabledEBPFCgroupID)
 		klog.V(5).Infof("ENABLE_GPU: %t", EnabledGPU)
 		klog.V(5).Infof("ENABLE_QAT: %t", EnabledQAT)
-		klog.V(5).Infof("ENABLE_PROCESS_METRICS: %t", EnableProcessMetrics)
+		klog.V(5).Infof("ENABLE_PROCESS_METRICS: %t", EnableProcessStats)
 		klog.V(5).Infof("EXPOSE_HW_COUNTER_METRICS: %t", ExposeHardwareCounterMetrics)
 		klog.V(5).Infof("EXPOSE_CGROUP_METRICS: %t", ExposeCgroupMetrics)
 		klog.V(5).Infof("EXPOSE_IRQ_COUNTER_METRICS: %t", ExposeIRQCounterMetrics)
@@ -306,6 +309,31 @@ func IsIdlePowerEnabled() bool {
 	return ExposeIdlePowerMetrics
 }
 
+// IsExposeProcessStatsEnabled returns false if process metrics are disabled to minimize overhead in the Kepler standalone mode.
+func IsExposeProcessStatsEnabled() bool {
+	return EnableProcessStats
+}
+
+// IsExposeContainerStatsEnabled returns false if container metrics are disabled to minimize overhead in the Kepler standalone mode.
+func IsExposeContainerStatsEnabled() bool {
+	return ExposeContainerStats
+}
+
+// IsExposeVMStatsEnabled returns false if VM metrics are disabled to minimize overhead.
+func IsExposeVMStatsEnabled() bool {
+	return ExposeVMStats
+}
+
+// IsExposeCPUFrequencyMetricsEnabled returns false if CPUFrequency metrics are disabled to minimize overhead.
+func IsExposeCPUFrequencyMetricsEnabled() bool {
+	return ExposeCPUFrequencyMetrics
+}
+
+// IsExposeCPUFrequencyMetricsEnabled returns false if CPUFrequency metrics are disabled to minimize overhead.
+func IsExposeQATMetricsEnabled() bool {
+	return EnabledQAT
+}
+
 // SetEnabledGPU enables the exposure of gpu metrics
 func SetEnabledGPU(enabled bool) {
 	// set to true if any config source set it to true
@@ -417,6 +445,9 @@ func GetModelConfigMap() map[string]string {
 	return configMap
 }
 
+func IsHCMetricsEnabled() bool {
+	return ExposeHardwareCounterMetrics
+}
 func IsCgroupMetricsEnabled() bool {
 	return ExposeCgroupMetrics
 }
diff --git a/pkg/config/types.go b/pkg/config/types.go
index dcab39ccdd..681281b799 100644
--- a/pkg/config/types.go
+++ b/pkg/config/types.go
@@ -17,6 +17,15 @@ limitations under the License.
 package config
 
 const (
+	CORE      = "core"
+	DRAM      = "dram"
+	UNCORE    = "uncore"
+	PKG       = "package"
+	GPU       = "gpu"
+	OTHER     = "other"
+	PLATFORM  = "platform"
+	FREQUENCY = "frequency"
+
 	// counter - attacher package
 	CPUCycle       = "cpu_cycles"
 	CPURefCycle    = "cpu_ref_cycles"
@@ -42,22 +51,41 @@ const (
 	BytesReadIO          = "bytes_read"
 	BytesWriteIO         = "bytes_writes"
 	BlockDevicesIO       = "block_devices_used"
-	// kubelet - package
-	KubeletCPUUsage        = "kubelet_cpu_usage"
-	KubeletMemoryUsage     = "kubelet_memory_bytes"
-	KubeletContainerCPU    = "container_cpu_usage_seconds_total"
-	KubeletContainerMemory = "container_memory_working_set_bytes"
-	KubeletNodeCPU         = "node_cpu_usage_seconds_total"
-	KubeletNodeMemory      = "node_memory_working_set_bytes"
 
 	// system
 	CPUFrequency = "avg_cpu_frequency"
 
-	// GPU
+	// NVIDIA GPU
 	GPUSMUtilization  = "gpu_sm_util"
 	GPUMemUtilization = "gpu_mem_util"
 
-	// Metric suffix
-	AggregatedUsageSuffix  = "total"
-	AggregatedEnergySuffix = "joules_total"
+	// Intel QuickAssist Technology (QAT)
+	// TODO: test if different request has different energy consumption.
+	QATUtilization = "qta_sample_cnt"
+
+	// Energy Metrics
+	// Absolute energy and power
+	AbsEnergyInCore     = "abs_energy_in_core"
+	AbsEnergyInDRAM     = "abs_energy_in_dram"
+	AbsEnergyInUnCore   = "abs_energy_in_uncore"
+	AbsEnergyInPkg      = "abs_energy_in_pkg"
+	AbsEnergyInGPU      = "abs_energy_in_gpu"
+	AbsEnergyInOther    = "abs_energy_in_other"
+	AbsEnergyInPlatform = "abs_energy_in_platform"
+	// Dynamic energy and power
+	DynEnergyInCore     = "dyn_energy_in_core"
+	DynEnergyInDRAM     = "dyn_energy_in_dram"
+	DynEnergyInUnCore   = "dyn_energy_in_uncore"
+	DynEnergyInPkg      = "dyn_energy_in_pkg"
+	DynEnergyInGPU      = "dyn_energy_in_gpu"
+	DynEnergyInOther    = "dyn_energy_in_other"
+	DynEnergyInPlatform = "dyn_energy_in_platform"
+	// Idle energy and power
+	IdleEnergyInCore     = "idle_energy_in_core"
+	IdleEnergyInDRAM     = "idle_energy_in_dram"
+	IdleEnergyInUnCore   = "idle_energy_in_uncore"
+	IdleEnergyInPkg      = "idle_energy_in_pkg"
+	IdleEnergyInGPU      = "idle_energy_in_gpu"
+	IdleEnergyInOther    = "idle_energy_in_other"
+	IdleEnergyInPlatform = "idle_energy_in_platform"
 )
diff --git a/pkg/kubelet/kubelet_pod_lister.go b/pkg/kubelet/kubelet_pod_lister.go
index 3e5d443c84..30ff95707e 100644
--- a/pkg/kubelet/kubelet_pod_lister.go
+++ b/pkg/kubelet/kubelet_pod_lister.go
@@ -24,12 +24,7 @@ import (
 	"io"
 	"net/http"
 	"os"
-	"sync"
 
-	dto "github.com/prometheus/client_model/go"
-	"github.com/prometheus/common/expfmt"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/utils"
 	corev1 "k8s.io/api/core/v1"
 )
 
@@ -42,18 +37,7 @@ const (
 )
 
 var (
-	podURL, metricsURL string
-
-	nodeCPUUsageMetricName      = config.KubeletNodeCPU
-	nodeMemUsageMetricName      = config.KubeletNodeMemory
-	containerCPUUsageMetricName = config.KubeletContainerCPU
-	containerMemUsageMetricName = config.KubeletContainerMemory
-
-	podNameTag       = "pod"
-	containerNameTag = "container"
-	namespaceTag     = "namespace"
-	once             sync.Once
-	kubeletMetric    []string
+	podURL string
 )
 
 func init() {
@@ -66,7 +50,6 @@ func init() {
 		port = "10250"
 	}
 	podURL = "https://" + nodeName + ":" + port + "/pods"
-	metricsURL = "https://" + nodeName + ":" + port + "/metrics/resource"
 }
 
 func httpGet(url string) (*http.Response, error) {
@@ -91,7 +74,7 @@ func httpGet(url string) (*http.Response, error) {
 	return resp, err
 }
 
-// ListPods accesses Kubelet's metrics and obtain PodList
+// ListPods obtains PodList
 func (k *KubeletPodLister) ListPods() (*[]corev1.Pod, error) {
 	resp, err := httpGet(podURL)
 	if err != nil {
@@ -112,92 +95,3 @@ func (k *KubeletPodLister) ListPods() (*[]corev1.Pod, error) {
 
 	return pods, nil
 }
-
-// ListMetrics accesses Kubelet's metrics and obtain pods and node metrics
-func (k *KubeletPodLister) ListMetrics() (containerCPU, containerMem map[string]float64, retErr error) {
-	resp, err := httpGet(metricsURL)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to get response: %v", err)
-	}
-	defer resp.Body.Close()
-
-	return parseMetrics(resp.Body)
-}
-
-func parseMetrics(r io.ReadCloser) (containerCPU, containerMem map[string]float64, retErr error) {
-	var parser expfmt.TextParser
-	var nodeCPU, nodeMem float64
-	mf, err := parser.TextToMetricFamilies(r)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to parse: %v", err)
-	}
-	containerCPU = make(map[string]float64)
-	containerMem = make(map[string]float64)
-	totalContainerMem := float64(0)
-	totalContainerCPU := float64(0)
-	for k, family := range mf {
-		for _, v := range family.Metric {
-			value := float64(0)
-			switch family.GetType() {
-			case dto.MetricType_COUNTER:
-				value = v.GetCounter().GetValue()
-			case dto.MetricType_GAUGE:
-				value = v.GetGauge().GetValue()
-			}
-			switch k {
-			case nodeCPUUsageMetricName:
-				nodeCPU = value
-			case nodeMemUsageMetricName:
-				nodeMem = value
-			case containerCPUUsageMetricName:
-				namespace, pod, container := parseLabels(v.GetLabel())
-				containerCPU[namespace+"/"+pod+"/"+container] = value
-				totalContainerCPU += value
-			case containerMemUsageMetricName:
-				namespace, pod, container := parseLabels(v.GetLabel())
-				containerMem[namespace+"/"+pod+"/"+container] = value
-				totalContainerMem += value
-			default:
-				continue
-			}
-		}
-	}
-	systemContainerMem := nodeMem - totalContainerMem
-	systemContainerCPU := nodeCPU - totalContainerCPU
-	systemContainerName := utils.SystemProcessNamespace + "/" + utils.SystemProcessName
-	containerCPU[systemContainerName] = systemContainerCPU
-	containerMem[systemContainerName] = systemContainerMem
-	return containerCPU, containerMem, retErr
-}
-
-// GetAvailableMetrics returns containerCPUUsageMetricName and containerMemUsageMetricName if kubelet is connected
-// and this function just need do a once init when kepler started without analysis kubelet returns
-func (k *KubeletPodLister) GetAvailableMetrics() []string {
-	once.Do(func() {
-		resp, err := httpGet(metricsURL)
-		if err != nil {
-			kubeletMetric = []string{}
-			return
-		}
-		defer resp.Body.Close()
-		if resp.StatusCode == http.StatusOK {
-			kubeletMetric = []string{config.KubeletCPUUsage, config.KubeletMemoryUsage}
-		}
-	})
-	return kubeletMetric
-}
-
-func parseLabels(labels []*dto.LabelPair) (namespace, pod, container string) {
-	for _, v := range labels {
-		if v.GetName() == podNameTag {
-			pod = v.GetValue()
-		}
-		if v.GetName() == namespaceTag {
-			namespace = v.GetValue()
-		}
-		if v.GetName() == containerNameTag {
-			container = v.GetValue()
-		}
-	}
-	return
-}
diff --git a/pkg/kubelet/pod_lister_test.go b/pkg/kubelet/pod_lister_test.go
index 0c793123e0..9e47f7d855 100644
--- a/pkg/kubelet/pod_lister_test.go
+++ b/pkg/kubelet/pod_lister_test.go
@@ -121,21 +121,6 @@ func TestListMetrics(t *testing.T) {
 			f, err := os.Open(p)
 			g.Expect(err).NotTo(HaveOccurred())
 			defer f.Close()
-
-			cCPU, cMem, err := parseMetrics(f)
-			g.Expect(err).NotTo(HaveOccurred())
-
-			// 3 includes system container
-			g.Expect(3).To(Equal(len(cCPU)))
-			g.Expect(3).To(Equal(len(cMem)))
-
-			c1 := "kepler/kepler-exporter-rksvt/kepler-exporter"
-			g.Expect(22.985283).To(Equal(cCPU[c1]))
-			g.Expect(1.09776896e+08).To(Equal(cMem[c1]))
-
-			c2 := "default/busybox/busybox"
-			g.Expect(0.035062).To(Equal(cCPU[c2]))
-			g.Expect(2.46897321e+08).To(Equal(cMem[c2]))
 		})
 	}
 }
diff --git a/pkg/kubernetes/watcher.go b/pkg/kubernetes/watcher.go
index d6c1a3bab7..afa7eb5efc 100644
--- a/pkg/kubernetes/watcher.go
+++ b/pkg/kubernetes/watcher.go
@@ -30,7 +30,7 @@ import (
 	"k8s.io/client-go/tools/clientcmd"
 	"k8s.io/klog/v2"
 
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
 )
 
@@ -53,8 +53,8 @@ type ObjListWatcher struct {
 	informer     cache.SharedInformer
 	stopChannel  chan struct{}
 
-	// ContainersMetrics holds all container energy and resource usage metrics
-	ContainersMetrics *map[string]*collector_metric.ContainerMetrics
+	// ContainerStats holds all container energy and resource usage metrics
+	ContainerStats *map[string]*stats.ContainerStats
 }
 
 func newK8sClient() *kubernetes.Clientset {
@@ -91,7 +91,7 @@ func NewObjListWatcher() *ObjListWatcher {
 		return w
 	}
 	optionsModifier := func(options *metav1.ListOptions) {
-		options.FieldSelector = fmt.Sprintf("spec.nodeName=%s", collector_metric.NodeName) // to filter events per node
+		options.FieldSelector = fmt.Sprintf("spec.nodeName=%s", stats.NodeName) // to filter events per node
 	}
 	objListWatcher := cache.NewFilteredListWatchFromClient(
 		w.k8sCli.CoreV1().RESTClient(),
@@ -201,13 +201,13 @@ func (w *ObjListWatcher) fillInfo(pod *k8sv1.Pod, containers []k8sv1.ContainerSt
 			err = fmt.Errorf("container %s did not start yet", containers[j].Name)
 			continue
 		}
-		if _, exist = (*w.ContainersMetrics)[containerID]; !exist {
-			(*w.ContainersMetrics)[containerID] = collector_metric.NewContainerMetrics(containers[j].Name, pod.Name, pod.Namespace, containerID)
+		if _, exist = (*w.ContainerStats)[containerID]; !exist {
+			(*w.ContainerStats)[containerID] = stats.NewContainerStats(containers[j].Name, pod.Name, pod.Namespace, containerID)
 		}
 		klog.V(5).Infof("receiving container %s %s %s %s", containers[j].Name, pod.Name, pod.Namespace, containerID)
-		(*w.ContainersMetrics)[containerID].ContainerName = containers[j].Name
-		(*w.ContainersMetrics)[containerID].PodName = pod.Name
-		(*w.ContainersMetrics)[containerID].Namespace = pod.Namespace
+		(*w.ContainerStats)[containerID].ContainerName = containers[j].Name
+		(*w.ContainerStats)[containerID].PodName = pod.Name
+		(*w.ContainerStats)[containerID].Namespace = pod.Namespace
 	}
 	return err
 }
@@ -234,7 +234,7 @@ func (w *ObjListWatcher) handleDeleted(obj interface{}) {
 func (w *ObjListWatcher) deleteInfo(containers []k8sv1.ContainerStatus) {
 	for j := 0; j < len(containers); j++ {
 		containerID := ParseContainerIDFromPodStatus(containers[j].ContainerID)
-		delete(*w.ContainersMetrics, containerID)
+		delete(*w.ContainerStats, containerID)
 	}
 }
 
diff --git a/pkg/libvirt/resolve_vm.go b/pkg/libvirt/resolve_vm.go
index 1823f755ba..c839473ebc 100644
--- a/pkg/libvirt/resolve_vm.go
+++ b/pkg/libvirt/resolve_vm.go
@@ -19,67 +19,83 @@ package libvirt
 import (
 	"fmt"
 	"os"
-	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/sustainable-computing-io/kepler/pkg/utils"
 )
 
 const (
-	libvirtPath string = "/var/run/libvirt/qemu/"
-	procPath    string = "/proc/%s/task"
+	procPath            string = "/proc/%d/cgroup"
+	maxCacheSize        int    = 1000
+	cacheRemoveElements int    = 100
 )
 
-func getThreadIDsForPID(pid, fullPath string) []string {
-	threadIDs := []string{}
+var (
+	cacheExist               = map[uint64]string{}
+	cacheNotExist            = map[uint64]bool{}
+	regexFindContainerIDPath = regexp.MustCompile(`machine-qemu.*\.scope`)
+)
 
-	procDir := fmt.Sprintf(fullPath, pid)
+func GetVMID(pid uint64) (string, error) {
+	fileName := fmt.Sprintf(procPath, pid)
+	return getVMID(pid, fileName)
+}
 
-	files, err := os.ReadDir(procDir)
-	if err != nil {
-		return nil
+func getVMID(pid uint64, fileName string) (string, error) {
+	if _, exist := cacheExist[pid]; exist {
+		return cacheExist[pid], nil
 	}
-
-	for _, file := range files {
-		threadIDs = append(threadIDs, file.Name())
+	if _, exist := cacheNotExist[pid]; exist {
+		return "", fmt.Errorf("pid %d is not in a VM", pid)
 	}
 
-	return threadIDs
-}
-
-func GetCurrentVMPID(path ...string) (map[string]string, error) {
-	pidFiles := make(map[string]string)
-
-	if len(path) == 0 {
-		path = []string{libvirtPath, procPath}
+	// Read the file
+	fileContents, err := os.ReadFile(fileName)
+	if err != nil {
+		addToNotExistCache(pid)
+		return "", err
 	}
 
-	files, err := os.ReadDir(path[0])
-	if err != nil {
-		return nil, err
+	content := regexFindContainerIDPath.FindAllString(string(fileContents), -1)
+	if len(content) == 0 {
+		addToNotExistCache(pid)
+		return utils.EmptyString, fmt.Errorf("pid %d does not have vm ID", pid)
 	}
+	vmID := content[0]
+	vmID = strings.ReplaceAll(vmID, "\\x2d", "-")
+	vmID = strings.ReplaceAll(vmID, ".scope", "")
 
-	for _, file := range files {
-		if file.IsDir() {
-			continue
-		}
+	addVMIDToCache(pid, vmID)
+	return vmID, nil
+}
 
-		if filepath.Ext(file.Name()) == ".pid" {
-			filePath := filepath.Join(path[0], file.Name())
-			content, err := os.ReadFile(filePath)
-			if err != nil {
-				fmt.Printf("Error reading %s: %v\n", filePath, err)
-				continue
+func addVMIDToCache(pid uint64, id string) {
+	if len(cacheExist) >= maxCacheSize {
+		counter := cacheRemoveElements
+		// Remove elemets from the cache
+		for k := range cacheExist {
+			delete(cacheExist, k)
+			if counter == 0 {
+				break
 			}
+			counter--
+		}
+	}
+	cacheExist[pid] = id
+}
 
-			currentPid := string(content)
-			currentName := file.Name()
-
-			tid := getThreadIDsForPID(currentPid, path[1])
-
-			for _, currentTid := range tid {
-				// Get rid of the ".pid" before storing the name
-				pidFiles[currentTid] = currentName[:len(currentName)-4]
+func addToNotExistCache(pid uint64) {
+	if len(cacheNotExist) >= maxCacheSize {
+		counter := cacheRemoveElements
+		// Remove elemets from the cache
+		for k := range cacheNotExist {
+			delete(cacheNotExist, k)
+			if counter == 0 {
+				break
 			}
+			counter--
 		}
 	}
-
-	return pidFiles, nil
+	cacheNotExist[pid] = false
 }
diff --git a/pkg/libvirt/resolve_vm_test.go b/pkg/libvirt/resolve_vm_test.go
index 446bb37121..657edddeff 100644
--- a/pkg/libvirt/resolve_vm_test.go
+++ b/pkg/libvirt/resolve_vm_test.go
@@ -17,69 +17,69 @@ limitations under the License.
 package libvirt
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
-	"reflect"
-	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+const (
+	cGroupFileName = "cgroup"
+	cGroupContent  = "0::/machine.slice/machine-qemu\x2d6\x2dcirros.scope/libvirt/emulator"
 )
 
-func createMockLibvirtDir(directory string) {
-	mockFiles := []struct {
-		name    string
-		content string
-	}{
-		{"vm1.pid", "1234"},
-		{"vm2.pid", "5678"},
-	}
-
-	for _, file := range mockFiles {
-		err := os.WriteFile(filepath.Join(directory, file.name), []byte(file.content), 0644)
-		if err != nil {
-			panic(err)
-		}
-	}
+var _ = Describe("Test LibVirt", func() {
+	var (
+		mockProcDir = ""
+	)
+
+	BeforeEach(func() {
+		mockProcDir = createTempDir()
+	})
+
+	AfterEach(func() {
+		removeTempDir(mockProcDir)
+	})
+
+	It("Test GetCurrentVMPID", func() {
+		pid := uint64(13)
+		fmt.Fprintln(GinkgoWriter, "mockProcDir", mockProcDir)
+		fileName := createMockProcDir(mockProcDir, pid)
+		vmID, err := getVMID(pid, fileName)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(vmID).Should(Equal("machine-qemu-6-cirros"))
+	})
+})
+
+// helper function to create a temporary directory
+func createTempDir() string {
+	tmpDir, err := os.MkdirTemp("", "ginkgo-temp")
+	Expect(err).NotTo(HaveOccurred())
+	return tmpDir
 }
 
-func createMockProcDir(directory string) {
-	mockThreadDirs := []string{
-		"/proc/1234/task/123",
-		"/proc/1234/task/456",
-		"/proc/1234/task/789",
-		"/proc/5678/task/1234",
-		"/proc/5678/task/4567",
-		"/proc/5678/task/7890",
-	}
-	for _, dir := range mockThreadDirs {
-		err := os.MkdirAll(filepath.Join(directory, dir), 0755)
-		if err != nil {
-			panic(err)
-		}
-	}
+// helper function to remove the temporary directory
+func removeTempDir(dir string) {
+	err := os.RemoveAll(dir)
+	Expect(err).NotTo(HaveOccurred())
+}
+
+// helper function to create a temporary process directory
+func createMockProcDir(directory string, pid uint64) string {
+	procDir := fmt.Sprintf("/proc/%d/", pid)
+	fullPathProcDir := filepath.Join(directory, procDir)
+	err := os.MkdirAll(fullPathProcDir, 0755)
+	Expect(err).NotTo(HaveOccurred())
+
+	cgroupFile := filepath.Join(fullPathProcDir, cGroupFileName)
+	createMockProcCGroupDir(cgroupFile)
+	return cgroupFile
 }
 
-func TestGetCurrentVMPID(t *testing.T) {
-	mockLibvirtDir := t.TempDir()
-	createMockLibvirtDir(mockLibvirtDir)
-
-	mockProcDir := t.TempDir()
-	createMockProcDir(mockProcDir)
-
-	mockProcDir = filepath.Join(mockProcDir, procPath)
-	pidFiles, err := GetCurrentVMPID(mockLibvirtDir, mockProcDir)
-	if err != nil {
-		t.Fatalf("Unexpected error: %v", err)
-	}
-
-	expectedResult := map[string]string{
-		"123":  "vm1",
-		"456":  "vm1",
-		"789":  "vm1",
-		"1234": "vm2",
-		"4567": "vm2",
-		"7890": "vm2",
-	}
-
-	if !reflect.DeepEqual(pidFiles, expectedResult) {
-		t.Errorf("Expected: %v, Got: %v", expectedResult, pidFiles)
-	}
+// helper function to write a temporary cgroup info
+func createMockProcCGroupDir(filename string) {
+	err := os.WriteFile(filename, []byte(cGroupContent), 0644)
+	Expect(err).NotTo(HaveOccurred())
 }
diff --git a/pkg/collector/vm_energy_collector.go b/pkg/libvirt/suite_test.go
similarity index 70%
rename from pkg/collector/vm_energy_collector.go
rename to pkg/libvirt/suite_test.go
index 87c754d46f..e6277e944b 100644
--- a/pkg/collector/vm_energy_collector.go
+++ b/pkg/libvirt/suite_test.go
@@ -14,13 +14,16 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package collector
+package libvirt
 
 import (
-	"github.com/sustainable-computing-io/kepler/pkg/model"
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
 )
 
-// updateVMEnergy matches the virtual machine metrics with process metrics
-func (c *Collector) updateVMEnergy() {
-	model.UpdateVMEnergy(c.VMMetrics, c.ProcessMetrics)
+func TestPodLoader(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "LibVirt Suite")
 }
diff --git a/pkg/manager/manager.go b/pkg/manager/manager.go
index 58c76abe59..320d68ffda 100644
--- a/pkg/manager/manager.go
+++ b/pkg/manager/manager.go
@@ -22,6 +22,7 @@ import (
 	"github.com/sustainable-computing-io/kepler/pkg/collector"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
 	"github.com/sustainable-computing-io/kepler/pkg/kubernetes"
+	exporter "github.com/sustainable-computing-io/kepler/pkg/metrics"
 )
 
 var (
@@ -29,36 +30,35 @@ var (
 )
 
 type CollectorManager struct {
-	// MetricCollector is resposible to collect resource and energy consumption metrics and calculate them when needed
-	MetricCollector *collector.Collector
+	// StatsCollector is resposible to collect resource and energy consumption metrics and calculate them when needed
+	StatsCollector *collector.Collector
 
 	// PrometheusCollector implements the external Collector interface provided by the Prometheus client
-	PrometheusCollector *collector.PrometheusCollector
+	PrometheusCollector *exporter.PrometheusExporter
 
-	// Watcher register in the kubernetes apiserver to watch for pod events to add or remove it from the ContainersMetrics map
+	// Watcher register in the kubernetes apiserver to watch for pod events to add or remove it from the ContainerStats map
 	Watcher *kubernetes.ObjListWatcher
 }
 
 func New() *CollectorManager {
 	manager := &CollectorManager{}
-	manager.MetricCollector = collector.NewCollector()
-	manager.PrometheusCollector = collector.NewPrometheusExporter()
+	manager.StatsCollector = collector.NewCollector()
+	manager.PrometheusCollector = exporter.NewPrometheusExporter()
 	// the collector and prometheusExporter share structures and collections
-	manager.PrometheusCollector.NodeMetrics = &manager.MetricCollector.NodeMetrics
-	manager.PrometheusCollector.ContainersMetrics = &manager.MetricCollector.ContainersMetrics
-	manager.PrometheusCollector.ProcessMetrics = &manager.MetricCollector.ProcessMetrics
-	manager.PrometheusCollector.VMMetrics = &manager.MetricCollector.VMMetrics
-	manager.PrometheusCollector.SamplePeriodSec = float64(config.SamplePeriodSec)
+	manager.PrometheusCollector.NewProcessCollector(manager.StatsCollector.ProcessStats)
+	manager.PrometheusCollector.NewContainerCollector(manager.StatsCollector.ContainerStats)
+	manager.PrometheusCollector.NewVMCollector(manager.StatsCollector.VMStats)
+	manager.PrometheusCollector.NewNodeCollector(&manager.StatsCollector.NodeStats)
 	// configure the wather
 	manager.Watcher = kubernetes.NewObjListWatcher()
 	manager.Watcher.Mx = &manager.PrometheusCollector.Mx
-	manager.Watcher.ContainersMetrics = &manager.MetricCollector.ContainersMetrics
+	manager.Watcher.ContainerStats = &manager.StatsCollector.ContainerStats
 	manager.Watcher.Run()
 	return manager
 }
 
 func (m *CollectorManager) Start() error {
-	if err := m.MetricCollector.Initialize(); err != nil {
+	if err := m.StatsCollector.Initialize(); err != nil {
 		return err
 	}
 
@@ -70,7 +70,7 @@ func (m *CollectorManager) Start() error {
 
 			// acquire the lock to wait prometheus finish the metric collection before updating the metrics
 			m.PrometheusCollector.Mx.Lock()
-			m.MetricCollector.Update()
+			m.StatsCollector.Update()
 			m.PrometheusCollector.Mx.Unlock()
 		}
 	}()
diff --git a/pkg/manager/manager_test.go b/pkg/manager/manager_test.go
index a572b7f644..eff338f2ad 100644
--- a/pkg/manager/manager_test.go
+++ b/pkg/manager/manager_test.go
@@ -6,14 +6,12 @@ package manager
 import (
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
 )
 
 var _ = Describe("Manager", func() {
 
 	It("Should work properly", func() {
 		CollectorManager := New()
-		Expect(float64(config.SamplePeriodSec)).To(Equal(CollectorManager.PrometheusCollector.SamplePeriodSec))
 		err := CollectorManager.Start()
 		// for no bcc tag in CI
 		Expect(err).To(HaveOccurred())
diff --git a/pkg/metrics/consts/conts.go b/pkg/metrics/consts/conts.go
new file mode 100644
index 0000000000..846def9f9b
--- /dev/null
+++ b/pkg/metrics/consts/conts.go
@@ -0,0 +1,92 @@
+/*
+Copyright 2023.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package consts
+
+import (
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+)
+
+const (
+	MetricsNamespace       = "kepler"
+	EnergyMetricNameSuffix = "_joules_total"
+	UsageMetricNameSuffix  = "_total"
+	MiliJouleToJoule       = 1000
+)
+
+var (
+	// Energy related metric labels
+	ProcessEnergyLabels   = []string{"pid", "container_id", "vm_id", "command", "mode"}
+	ContainerEnergyLabels = []string{"container_id", "pod_name", "container_name", "container_namespace", "mode"}
+	VMEnergyLabels        = []string{"vm_id", "mode"}
+	NodeEnergyLabels      = []string{"package", "instance", "mode"}
+
+	// Resource utilization related metric labels
+	ProcessResUtilLabels   = []string{"pid", "container_id", "vm_id", "command"}
+	ContainerResUtilLabels = []string{"container_id", "pod_name", "container_name", "container_namespace"}
+	VMResUtilLabels        = []string{"vm_id"}
+	NodeResUtilLabels      = []string{"device", "instance"}
+)
+
+var (
+	EnergyMetricNames = []string{
+		config.PKG,
+		config.CORE,
+		config.UNCORE,
+		config.DRAM,
+		config.OTHER,
+		config.GPU,
+		config.PLATFORM,
+	}
+	DynEnergyMetricNames = []string{
+		config.DynEnergyInPkg,
+		config.DynEnergyInCore,
+		config.DynEnergyInUnCore,
+		config.DynEnergyInDRAM,
+		config.DynEnergyInOther,
+		config.DynEnergyInGPU,
+		config.DynEnergyInPlatform,
+	}
+	IdleEnergyMetricNames = []string{
+		config.IdleEnergyInPkg,
+		config.IdleEnergyInCore,
+		config.IdleEnergyInUnCore,
+		config.IdleEnergyInDRAM,
+		config.IdleEnergyInOther,
+		config.IdleEnergyInGPU,
+		config.IdleEnergyInPlatform,
+	}
+	HCMetricNames = []string{
+		config.CPUCycle,
+		config.CPUInstruction,
+		config.CacheMiss,
+	}
+	SCMetricNames = []string{
+		config.CPUTime,
+		config.PageCacheHit,
+	}
+	IRQMetricNames = []string{
+		config.IRQNetTXLabel,
+		config.IRQNetRXLabel,
+		config.IRQBlockLabel,
+	}
+	CGroupMetricNames = []string{
+		config.CgroupfsCPU,
+		config.CgroupfsMemory,
+		config.CgroupfsSystemCPU,
+		config.CgroupfsUserCPU,
+	}
+)
diff --git a/pkg/metrics/container/metrics.go b/pkg/metrics/container/metrics.go
new file mode 100644
index 0000000000..a44530dcaa
--- /dev/null
+++ b/pkg/metrics/container/metrics.go
@@ -0,0 +1,121 @@
+/*
+Copyright 2023.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package container
+
+import (
+	"sync"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/consts"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/metricfactory"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/utils"
+)
+
+const (
+	context = "container"
+)
+
+// collector implements prometheus.Collector. It collects metrics directly from container maps.
+type collector struct {
+	descriptions map[string]*prometheus.Desc
+	collectors   map[string]metricfactory.PromMetric
+
+	// ContainerStats holds all containers energy and resource usage metrics
+	ContainerStats map[string]*stats.ContainerStats
+
+	// Lock to syncronize the collector update with prometheus exporter
+	Mx *sync.Mutex
+}
+
+func NewContainerCollector(containerMetrics map[string]*stats.ContainerStats, mx *sync.Mutex) prometheus.Collector {
+	c := &collector{
+		ContainerStats: containerMetrics,
+		descriptions:   make(map[string]*prometheus.Desc),
+		collectors:     make(map[string]metricfactory.PromMetric),
+		Mx:             mx,
+	}
+	c.initMetrics()
+	return c
+}
+
+// initMetrics creates prometheus metric description for container
+func (c *collector) initMetrics() {
+	if !config.IsExposeContainerStatsEnabled() {
+		return
+	}
+	for name, desc := range metricfactory.HCMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.SCMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.IRQMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.CGroupMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.EnergyMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+
+	desc := metricfactory.MetricsPromDesc(context, "joules", "_total", "", consts.ContainerEnergyLabels)
+	c.descriptions["total"] = desc
+	c.collectors["total"] = metricfactory.NewPromCounter(desc)
+}
+
+func (c *collector) Describe(ch chan<- *prometheus.Desc) {
+	for _, desc := range c.descriptions {
+		ch <- desc
+	}
+}
+
+func (c *collector) Collect(ch chan<- prometheus.Metric) {
+	c.Mx.Lock()
+	for _, container := range c.ContainerStats {
+		utils.CollectEnergyMetrics(ch, container, c.collectors)
+		utils.CollectResUtilizationMetrics(ch, container, c.collectors)
+
+		// update container total joules
+		c.collectTotalEnergyMetrics(ch, container)
+	}
+	c.Mx.Unlock()
+}
+
+// We currently export a metric kepler_container_total_joules but this metric is the same as kepler_container_platform_joules. We might remote it in the future.
+func (c *collector) collectTotalEnergyMetrics(ch chan<- prometheus.Metric, container *stats.ContainerStats) {
+	energy := container.EnergyUsage[config.DynEnergyInPkg].SumAllAggrValues()
+	energy += container.EnergyUsage[config.DynEnergyInDRAM].SumAllAggrValues()
+	energy += container.EnergyUsage[config.DynEnergyInOther].SumAllAggrValues()
+	energy += container.EnergyUsage[config.DynEnergyInGPU].SumAllAggrValues()
+	labelValues := []string{container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "dynamic"}
+	ch <- c.collectors["total"].MustMetric(float64(energy), labelValues...)
+
+	energy = container.EnergyUsage[config.IdleEnergyInPkg].SumAllAggrValues()
+	energy += container.EnergyUsage[config.IdleEnergyInDRAM].SumAllAggrValues()
+	energy += container.EnergyUsage[config.IdleEnergyInOther].SumAllAggrValues()
+	energy += container.EnergyUsage[config.IdleEnergyInGPU].SumAllAggrValues()
+	labelValues = []string{container.ContainerID, container.PodName, container.ContainerName, container.Namespace, "idle"}
+	ch <- c.collectors["total"].MustMetric(float64(energy), labelValues...)
+}
diff --git a/pkg/metrics/metricfactory/interface.go b/pkg/metrics/metricfactory/interface.go
new file mode 100644
index 0000000000..02e6755667
--- /dev/null
+++ b/pkg/metrics/metricfactory/interface.go
@@ -0,0 +1,58 @@
+/*
+Copyright 2023.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metricfactory
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+type PromMetric interface {
+	Desc() *prometheus.Desc
+	MustMetric(value float64, labelValues ...string) prometheus.Metric
+}
+
+type promCounter struct {
+	desc *prometheus.Desc
+}
+
+func NewPromCounter(desc *prometheus.Desc) PromMetric {
+	return &promCounter{desc: desc}
+}
+
+func (c *promCounter) Desc() *prometheus.Desc {
+	return c.desc
+}
+
+func (c *promCounter) MustMetric(value float64, labelValues ...string) prometheus.Metric {
+	return prometheus.MustNewConstMetric(c.desc, prometheus.CounterValue, value, labelValues...)
+}
+
+type bpfGauge struct {
+	desc *prometheus.Desc
+}
+
+func NewPromGauge(desc *prometheus.Desc) PromMetric {
+	return &bpfGauge{desc: desc}
+}
+
+func (g *bpfGauge) Desc() *prometheus.Desc {
+	return g.desc
+}
+
+func (g *bpfGauge) MustMetric(value float64, labelValues ...string) prometheus.Metric {
+	return prometheus.MustNewConstMetric(g.desc, prometheus.GaugeValue, value, labelValues...)
+}
diff --git a/pkg/metrics/metricfactory/metric_factory.go b/pkg/metrics/metricfactory/metric_factory.go
new file mode 100644
index 0000000000..3d042504d9
--- /dev/null
+++ b/pkg/metrics/metricfactory/metric_factory.go
@@ -0,0 +1,139 @@
+/*
+Copyright 2023.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metricfactory
+
+import (
+	"strings"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/consts"
+	"k8s.io/klog/v2"
+)
+
+func EnergyMetricsPromDesc(context string) (descriptions map[string]*prometheus.Desc) {
+	descriptions = make(map[string]*prometheus.Desc)
+	for _, name := range consts.EnergyMetricNames {
+		source := "intel_rapl"
+		if strings.Contains(name, "gpu") {
+			source = "nvidia"
+		}
+		descriptions[name] = energyMetricsPromDesc(context, name, source)
+	}
+	return descriptions
+}
+
+func energyMetricsPromDesc(context, name, source string) (desc *prometheus.Desc) {
+	var labels []string
+	switch context {
+	case "process":
+		labels = consts.ProcessEnergyLabels
+	case "container":
+		labels = consts.ContainerEnergyLabels
+	case "vm":
+		labels = consts.VMEnergyLabels
+	case "node":
+		labels = consts.NodeEnergyLabels
+	default:
+		klog.Errorf("Unexpected prometheus context: %s", context)
+		return
+	}
+	return MetricsPromDesc(context, name, consts.EnergyMetricNameSuffix, source, labels)
+}
+
+func HCMetricsPromDesc(context string) (descriptions map[string]*prometheus.Desc) {
+	descriptions = make(map[string]*prometheus.Desc)
+	if config.IsHCMetricsEnabled() {
+		for _, name := range consts.HCMetricNames {
+			descriptions[name] = resMetricsPromDesc(context, name, "bpf")
+		}
+	}
+	return descriptions
+}
+
+func SCMetricsPromDesc(context string) (descriptions map[string]*prometheus.Desc) {
+	descriptions = make(map[string]*prometheus.Desc)
+	for _, name := range consts.SCMetricNames {
+		descriptions[name] = resMetricsPromDesc(context, name, "bpf")
+	}
+	return descriptions
+}
+
+func IRQMetricsPromDesc(context string) (descriptions map[string]*prometheus.Desc) {
+	descriptions = make(map[string]*prometheus.Desc)
+	if config.IsIRQCounterMetricsEnabled() {
+		for _, name := range consts.IRQMetricNames {
+			descriptions[name] = resMetricsPromDesc(context, name, "bpf")
+		}
+	}
+	return descriptions
+}
+
+func CGroupMetricsPromDesc(context string) (descriptions map[string]*prometheus.Desc) {
+	descriptions = make(map[string]*prometheus.Desc)
+	if config.IsCgroupMetricsEnabled() {
+		for _, name := range consts.CGroupMetricNames {
+			descriptions[name] = resMetricsPromDesc(context, name, "cgroup")
+		}
+	}
+	return descriptions
+}
+
+func QATMetricsPromDesc(context string) (descriptions map[string]*prometheus.Desc) {
+	descriptions = make(map[string]*prometheus.Desc)
+	if config.IsExposeQATMetricsEnabled() {
+		name := config.QATUtilization
+		descriptions[name] = resMetricsPromDesc(context, name, "intel_qta")
+	}
+	return descriptions
+}
+
+func NodeCPUFrequencyMetricsPromDesc(context string) (descriptions map[string]*prometheus.Desc) {
+	descriptions = make(map[string]*prometheus.Desc)
+	if config.IsExposeCPUFrequencyMetricsEnabled() {
+		name := config.CPUFrequency
+		descriptions[name] = resMetricsPromDesc(context, name, "")
+	}
+	return descriptions
+}
+
+func resMetricsPromDesc(context, name, source string) (desc *prometheus.Desc) {
+	var labels []string
+	switch context {
+	case "process":
+		labels = consts.ProcessResUtilLabels
+	case "container":
+		labels = consts.ContainerResUtilLabels
+	case "vm":
+		labels = consts.VMResUtilLabels
+	case "node":
+		labels = consts.NodeResUtilLabels
+	default:
+		klog.Errorf("Unexpected prometheus context: %s", context)
+		return
+	}
+	return MetricsPromDesc(context, name, consts.UsageMetricNameSuffix, source, labels)
+}
+
+func MetricsPromDesc(context, name, sufix, source string, labels []string) (desc *prometheus.Desc) {
+	return prometheus.NewDesc(
+		prometheus.BuildFQName(consts.MetricsNamespace, context, name+sufix),
+		"Aggregated value in "+name+" value from "+source,
+		labels,
+		prometheus.Labels{"source": source},
+	)
+}
diff --git a/pkg/metrics/node/metrics.go b/pkg/metrics/node/metrics.go
new file mode 100644
index 0000000000..011e212f50
--- /dev/null
+++ b/pkg/metrics/node/metrics.go
@@ -0,0 +1,95 @@
+/*
+Copyright 2023.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package node
+
+import (
+	"sync"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/metricfactory"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/utils"
+)
+
+const (
+	context = "node"
+)
+
+// collector implements prometheus.Collector. It collects metrics directly from BPF maps.
+type collector struct {
+	descriptions map[string]*prometheus.Desc
+	collectors   map[string]metricfactory.PromMetric
+
+	// NodeStats holds all node energy and resource usage metrics
+	NodeStats *stats.NodeStats
+
+	// Lock to syncronize the collector update with prometheus exporter
+	Mx *sync.Mutex
+}
+
+func NewNodeCollector(nodeMetrics *stats.NodeStats, mx *sync.Mutex) prometheus.Collector {
+	c := &collector{
+		NodeStats:    nodeMetrics,
+		descriptions: make(map[string]*prometheus.Desc),
+		collectors:   make(map[string]metricfactory.PromMetric),
+		Mx:           mx,
+	}
+	c.initMetrics()
+	return c
+}
+
+// initMetrics creates prometheus metric description for node
+func (c *collector) initMetrics() {
+	// node exports different resource utilization metrics than process, container and vm
+	for name, desc := range metricfactory.QATMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.NodeCPUFrequencyMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.EnergyMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+
+	// TODO: prometheus metric should be "node_info"
+	desc := metricfactory.MetricsPromDesc(context, "", "info", "os", []string{"cpu_architecture"})
+	c.descriptions["info"] = desc
+	c.collectors["info"] = metricfactory.NewPromCounter(desc)
+}
+
+func (c *collector) Describe(ch chan<- *prometheus.Desc) {
+	for _, desc := range c.descriptions {
+		ch <- desc
+	}
+}
+
+func (c *collector) Collect(ch chan<- prometheus.Metric) {
+	c.Mx.Lock()
+	utils.CollectEnergyMetrics(ch, c.NodeStats, c.collectors)
+	// we export different node resource utilization metrics than process, container and vms
+	// TODO: verify if the resoruce utilization metrics are needed
+	utils.CollectResUtil(ch, c.NodeStats, config.CPUFrequency, c.collectors[config.CPUFrequency])
+	utils.CollectResUtil(ch, c.NodeStats, config.QATUtilization, c.collectors[config.QATUtilization])
+	c.Mx.Unlock()
+
+	// update node info
+	ch <- c.collectors["info"].MustMetric(1, stats.NodeCPUArchitecture)
+}
diff --git a/pkg/metrics/process/metrics.go b/pkg/metrics/process/metrics.go
new file mode 100644
index 0000000000..4f2c63d145
--- /dev/null
+++ b/pkg/metrics/process/metrics.go
@@ -0,0 +1,96 @@
+/*
+Copyright 2023.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package process
+
+import (
+	"sync"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/metricfactory"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/utils"
+)
+
+const (
+	context = "vm"
+)
+
+// collector implements prometheus.Collector. It collects metrics directly from process maps.
+type collector struct {
+	descriptions map[string]*prometheus.Desc
+	collectors   map[string]metricfactory.PromMetric
+
+	// ProcessStats holds all processes energy and resource usage metrics
+	ProcessStats map[uint64]*stats.ProcessStats
+
+	// Lock to syncronize the collector update with prometheus exporter
+	Mx *sync.Mutex
+}
+
+func NewProcessCollector(processMetrics map[uint64]*stats.ProcessStats, mx *sync.Mutex) prometheus.Collector {
+	c := &collector{
+		ProcessStats: processMetrics,
+		descriptions: make(map[string]*prometheus.Desc),
+		collectors:   make(map[string]metricfactory.PromMetric),
+		Mx:           mx,
+	}
+	c.initMetrics()
+	return c
+}
+
+// initMetrics creates prometheus metric description for process
+func (c *collector) initMetrics() {
+	if !config.IsExposeProcessStatsEnabled() {
+		return
+	}
+	for name, desc := range metricfactory.HCMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.SCMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.IRQMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.CGroupMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.EnergyMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+}
+
+func (c *collector) Describe(ch chan<- *prometheus.Desc) {
+	for _, desc := range c.descriptions {
+		ch <- desc
+	}
+}
+
+func (c *collector) Collect(ch chan<- prometheus.Metric) {
+	c.Mx.Lock()
+	for _, process := range c.ProcessStats {
+		utils.CollectEnergyMetrics(ch, process, c.collectors)
+		utils.CollectResUtilizationMetrics(ch, process, c.collectors)
+	}
+	c.Mx.Unlock()
+}
diff --git a/pkg/metrics/prometheus_collector.go b/pkg/metrics/prometheus_collector.go
new file mode 100644
index 0000000000..6afb48c0dd
--- /dev/null
+++ b/pkg/metrics/prometheus_collector.go
@@ -0,0 +1,110 @@
+/*
+Copyright 2021.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metrics
+
+import (
+	"sync"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/common/version"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/container"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/node"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/process"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/virtualmachine"
+	"k8s.io/klog/v2"
+)
+
+var (
+	registryOnce sync.Once
+	registry     *prometheus.Registry
+)
+
+// PrometheusExporter holds the list of prometheus metric collectors
+type PrometheusExporter struct {
+	ProcessStatsCollector   prometheus.Collector
+	ContainerStatsCollector prometheus.Collector
+	VMStatsCollector        prometheus.Collector
+	NodeStatsCollector      prometheus.Collector
+
+	// Lock to syncronize the collector update with prometheus exporter
+	Mx sync.Mutex
+}
+
+// NewPrometheusExporter creates a new prometheus exporter
+func NewPrometheusExporter() *PrometheusExporter {
+	return &PrometheusExporter{}
+}
+
+// NewProcessCollector creates a new prometheus collector for process metrics
+func (e *PrometheusExporter) NewProcessCollector(processMetrics map[uint64]*stats.ProcessStats) {
+	e.ProcessStatsCollector = process.NewProcessCollector(processMetrics, &e.Mx)
+}
+
+// NewContainerCollector creates a new prometheus collector for container metrics
+func (e *PrometheusExporter) NewContainerCollector(containerMetrics map[string]*stats.ContainerStats) {
+	e.ContainerStatsCollector = container.NewContainerCollector(containerMetrics, &e.Mx)
+}
+
+// NewVMCollector creates a new prometheus collector for vm metrics
+func (e *PrometheusExporter) NewVMCollector(vmMetrics map[string]*stats.VMStats) {
+	e.VMStatsCollector = virtualmachine.NewVMCollector(vmMetrics, &e.Mx)
+}
+
+// NewNodeCollector creates a new prometheus collector for node metrics
+func (e *PrometheusExporter) NewNodeCollector(nodeMetrics *stats.NodeStats) {
+	e.NodeStatsCollector = node.NewNodeCollector(nodeMetrics, &e.Mx)
+}
+
+func GetRegistry() *prometheus.Registry {
+	registryOnce.Do(func() {
+		registry = prometheus.NewRegistry()
+	})
+	return registry
+}
+
+func (e *PrometheusExporter) RegisterMetrics() *prometheus.Registry {
+	registry := GetRegistry()
+	registry.MustRegister(version.NewCollector("kepler_exporter"))
+
+	if config.IsExposeProcessStatsEnabled() {
+		registry.MustRegister(e.ProcessStatsCollector)
+		klog.Infoln("Registered Process Prometheus metrics")
+	}
+
+	if config.IsExposeContainerStatsEnabled() {
+		registry.MustRegister(e.ContainerStatsCollector)
+		klog.Infoln("Registered Container Prometheus metrics")
+	}
+
+	if config.IsExposeVMStatsEnabled() {
+		registry.MustRegister(e.VMStatsCollector)
+		klog.Infoln("Registered VM Prometheus metrics")
+	}
+
+	registry.MustRegister(e.NodeStatsCollector)
+	klog.Infoln("Registered Node Prometheus metrics")
+
+	// log prometheus errors
+	_, err := registry.Gather()
+	if err != nil {
+		klog.Errorln(err)
+	}
+
+	return registry
+}
diff --git a/pkg/metrics/prometheus_collector_test.go b/pkg/metrics/prometheus_collector_test.go
new file mode 100644
index 0000000000..bbd65d013a
--- /dev/null
+++ b/pkg/metrics/prometheus_collector_test.go
@@ -0,0 +1,127 @@
+/*
+Copyright 2021.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metrics
+
+import (
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"github.com/sustainable-computing-io/kepler/pkg/collector"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/model"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/platform"
+)
+
+const (
+	nodeEnergyMetric             = "kepler_node_platform_joules_total"
+	nodePackageEnergyMetric      = "kepler_node_package_joules_total"
+	containerCPUCoreEnergyMetric = "kepler_container_package_joules_total"
+
+	SampleCurr = 100
+	SampleAggr = 1000
+)
+
+func convertPromToValue(body []byte, metric string) (float64, error) {
+	regStr := fmt.Sprintf(`%s{[^{}]*}.*`, metric)
+	r := regexp.MustCompile(regStr)
+	match := r.FindString(string(body))
+	splits := strings.Split(match, " ")
+	fmt.Fprintf(GinkgoWriter, "splits=%v regStr=%v\n", splits, regStr)
+	return strconv.ParseFloat(splits[1], 64)
+}
+
+var _ = Describe("Test Prometheus Collector Unit", func() {
+	It("Init and Run", func() {
+		// we need to disable the system real time power metrics for testing since we add mock values or use power model estimator
+		components.SetIsSystemCollectionSupported(false)
+		platform.SetIsSystemCollectionSupported(false)
+		if gpu.IsGPUCollectionSupported() {
+			err := gpu.Init() // create structure instances that will be accessed to create a containerMetric
+			Expect(err).NotTo(HaveOccurred())
+		}
+		stats.SetMockedCollectorMetrics()
+		processStats := stats.CreateMockedProcessStats(2)
+		nodeStats := stats.CreateMockedNodeStats()
+
+		metricCollector := collector.NewCollector()
+		metricCollector.ProcessStats = processStats
+		metricCollector.NodeStats = nodeStats
+		// aggregate processes' resource utilization metrics to containers, virtual machines and nodes
+		metricCollector.AggregateProcessResourceUtilizationMetrics()
+
+		// the collector and prometheusExporter share structures and collections
+		exporter := NewPrometheusExporter()
+		exporter.NewProcessCollector(metricCollector.ProcessStats)
+		exporter.NewContainerCollector(metricCollector.ContainerStats)
+		exporter.NewVMCollector(metricCollector.VMStats)
+		exporter.NewNodeCollector(&metricCollector.NodeStats)
+
+		nodeStats.UpdateDynEnergy()
+
+		model.CreatePowerEstimatorModels(stats.ProcessFeaturesNames,
+			stats.NodeMetadataFeatureNames,
+			stats.NodeMetadataFeatureValues)
+		model.UpdateProcessEnergy(processStats, &nodeStats)
+
+		// get metrics from prometheus
+		err := prometheus.Register(exporter.ProcessStatsCollector)
+		Expect(err).NotTo(HaveOccurred())
+		err = prometheus.Register(exporter.ContainerStatsCollector)
+		Expect(err).NotTo(HaveOccurred())
+		err = prometheus.Register(exporter.VMStatsCollector)
+		Expect(err).NotTo(HaveOccurred())
+		err = prometheus.Register(exporter.NodeStatsCollector)
+		Expect(err).NotTo(HaveOccurred())
+
+		// check if prometheus is replying
+		req, _ := http.NewRequest("GET", "", http.NoBody)
+		res := httptest.NewRecorder()
+		handler := promhttp.Handler()
+		handler.ServeHTTP(res, req)
+		body, _ := io.ReadAll(res.Body)
+		Expect(len(body)).Should(BeNumerically(">", 0))
+		fmt.Fprintf(GinkgoWriter, "Result:\n %s\n", body)
+
+		// check pkg energy
+		val, err := convertPromToValue(body, nodePackageEnergyMetric)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(val).Should(BeEquivalentTo(30)) // J
+
+		// check sample node energy
+		val, err = convertPromToValue(body, nodeEnergyMetric)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(val).To(Equal(float64(60))) // J
+
+		// check sample pod
+		val, err = convertPromToValue(body, containerCPUCoreEnergyMetric)
+		Expect(err).NotTo(HaveOccurred())
+		// The pkg dynamic energy is 30J, the container cpu usage is 50%, so the dynamic energy is 15J
+		Expect(val).To(Equal(float64(15))) // J
+	})
+})
diff --git a/pkg/metrics/utils/utils.go b/pkg/metrics/utils/utils.go
new file mode 100644
index 0000000000..28b9cc2b4b
--- /dev/null
+++ b/pkg/metrics/utils/utils.go
@@ -0,0 +1,149 @@
+/*
+Copyright 2023.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package utils
+
+import (
+	"strconv"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/consts"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/metricfactory"
+	"k8s.io/klog/v2"
+)
+
+func CollectEnergyMetrics(ch chan<- prometheus.Metric, instance interface{}, collectors map[string]metricfactory.PromMetric) {
+	// collect the dynamic energy metrics
+	for i, collectorName := range consts.EnergyMetricNames {
+		if collectorName == config.GPU && !config.EnabledGPU {
+			continue
+		}
+		collectEnergy(ch, instance, consts.DynEnergyMetricNames[i], "dynamic", collectors[collectorName])
+		// idle power is not enabled by default on VMs, since it is the host idle power and was not split among all running VMs
+		if config.IsIdlePowerEnabled() {
+			collectEnergy(ch, instance, consts.IdleEnergyMetricNames[i], "idle", collectors[collectorName])
+		}
+	}
+}
+
+func CollectResUtilizationMetrics(ch chan<- prometheus.Metric, instance interface{}, collectors map[string]metricfactory.PromMetric) {
+	// collect the BPF Software Counters
+	for _, collectorName := range consts.SCMetricNames {
+		CollectResUtil(ch, instance, collectorName, collectors[collectorName])
+	}
+
+	if config.IsIRQCounterMetricsEnabled() {
+		for _, collectorName := range consts.IRQMetricNames {
+			CollectResUtil(ch, instance, collectorName, collectors[collectorName])
+		}
+	}
+
+	// collect the BPF Hardware Counters
+	if config.IsHCMetricsEnabled() {
+		for _, collectorName := range consts.HCMetricNames {
+			CollectResUtil(ch, instance, collectorName, collectors[collectorName])
+		}
+	}
+
+	// collect the deprecated cGroup metrics, this metrics will be removed in the future
+	if config.IsCgroupMetricsEnabled() {
+		for _, collectorName := range consts.CGroupMetricNames {
+			CollectResUtil(ch, instance, collectorName, collectors[collectorName])
+		}
+	}
+}
+
+func collect(ch chan<- prometheus.Metric, collector metricfactory.PromMetric, value float64, labelValues []string) {
+	ch <- collector.MustMetric(value, labelValues...)
+}
+
+func collectEnergy(ch chan<- prometheus.Metric, instance interface{}, metricName, mode string, collector metricfactory.PromMetric) {
+	var value float64
+	var labelValues []string
+	switch v := instance.(type) {
+	case *stats.ContainerStats:
+		container := instance.(*stats.ContainerStats)
+		value = float64(container.EnergyUsage[metricName].SumAllAggrValues()) / consts.MiliJouleToJoule
+		labelValues = []string{container.ContainerID, container.PodName, container.ContainerName, container.Namespace, mode}
+		collect(ch, collector, value, labelValues)
+
+	case *stats.ProcessStats:
+		process := instance.(*stats.ProcessStats)
+		value = float64(process.EnergyUsage[metricName].SumAllAggrValues()) / consts.MiliJouleToJoule
+		labelValues = []string{strconv.FormatUint(process.PID, 10), process.ContainerID, process.VMID, process.Command, mode}
+		collect(ch, collector, value, labelValues)
+
+	case *stats.VMStats:
+		vm := instance.(*stats.VMStats)
+		value = float64(vm.EnergyUsage[metricName].SumAllAggrValues()) / consts.MiliJouleToJoule
+		labelValues = []string{vm.VMID, mode}
+		collect(ch, collector, value, labelValues)
+
+	// only node metrics report metrics per device, process, container and VM reports the aggregation
+	case *stats.NodeStats:
+		node := instance.(*stats.NodeStats)
+		if _, exit := node.EnergyUsage[metricName]; exit {
+			for deviceID, utilization := range node.EnergyUsage[metricName].Stat {
+				value = float64(utilization.Aggr) / consts.MiliJouleToJoule
+				labelValues = []string{deviceID, stats.NodeName, mode}
+				collect(ch, collector, value, labelValues)
+			}
+		}
+
+	default:
+		klog.Errorf("Type %T is not known!\n", v)
+	}
+}
+
+func CollectResUtil(ch chan<- prometheus.Metric, instance interface{}, metricName string, collector metricfactory.PromMetric) {
+	var value float64
+	var labelValues []string
+	switch v := instance.(type) {
+	case *stats.ContainerStats:
+		container := instance.(*stats.ContainerStats)
+		value = float64(container.ResourceUsage[metricName].SumAllAggrValues())
+		labelValues = []string{container.ContainerID, container.PodName, container.ContainerName, container.Namespace}
+		collect(ch, collector, value, labelValues)
+
+	case *stats.ProcessStats:
+		process := instance.(*stats.ProcessStats)
+		value = float64(process.ResourceUsage[metricName].SumAllAggrValues())
+		labelValues = []string{strconv.FormatUint(process.PID, 10), process.ContainerID, process.VMID, process.Command}
+		collect(ch, collector, value, labelValues)
+
+	case *stats.VMStats:
+		vm := instance.(*stats.VMStats)
+		value = float64(vm.ResourceUsage[metricName].SumAllAggrValues())
+		labelValues = []string{vm.VMID}
+		collect(ch, collector, value, labelValues)
+
+	// only node metrics report metrics per device, process, container and VM reports the aggregation
+	case *stats.NodeStats:
+		node := instance.(*stats.NodeStats)
+		if _, exit := node.ResourceUsage[metricName]; exit {
+			for deviceID, utilization := range node.ResourceUsage[metricName].Stat {
+				value = float64(utilization.Aggr)
+				labelValues = []string{deviceID, stats.NodeName}
+				collect(ch, collector, value, labelValues)
+			}
+		}
+
+	default:
+		klog.Errorf("Type %T is not supported.\n", v)
+	}
+}
diff --git a/pkg/metrics/virtualmachine/metrics.go b/pkg/metrics/virtualmachine/metrics.go
new file mode 100644
index 0000000000..79050d9a22
--- /dev/null
+++ b/pkg/metrics/virtualmachine/metrics.go
@@ -0,0 +1,96 @@
+/*
+Copyright 2023.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package virtualmachine
+
+import (
+	"sync"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/metricfactory"
+	"github.com/sustainable-computing-io/kepler/pkg/metrics/utils"
+)
+
+const (
+	context = "vm"
+)
+
+// collector implements prometheus.Collector. It collects metrics directly from vm maps.
+type collector struct {
+	descriptions map[string]*prometheus.Desc
+	collectors   map[string]metricfactory.PromMetric
+
+	// VMStats holds all vms energy and resource usage metrics
+	VMStats map[string]*stats.VMStats
+
+	// Lock to syncronize the collector update with prometheus exporter
+	Mx *sync.Mutex
+}
+
+func NewVMCollector(vmMetrics map[string]*stats.VMStats, mx *sync.Mutex) prometheus.Collector {
+	c := &collector{
+		VMStats:      vmMetrics,
+		descriptions: make(map[string]*prometheus.Desc),
+		collectors:   make(map[string]metricfactory.PromMetric),
+		Mx:           mx,
+	}
+	c.initMetrics()
+	return c
+}
+
+// initMetrics creates prometheus metric description for vm
+func (c *collector) initMetrics() {
+	if !config.IsExposeVMStatsEnabled() {
+		return
+	}
+	for name, desc := range metricfactory.HCMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.SCMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.IRQMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.CGroupMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+	for name, desc := range metricfactory.EnergyMetricsPromDesc(context) {
+		c.descriptions[name] = desc
+		c.collectors[name] = metricfactory.NewPromCounter(desc)
+	}
+}
+
+func (c *collector) Describe(ch chan<- *prometheus.Desc) {
+	for _, desc := range c.descriptions {
+		ch <- desc
+	}
+}
+
+func (c *collector) Collect(ch chan<- prometheus.Metric) {
+	c.Mx.Lock()
+	for _, vm := range c.VMStats {
+		utils.CollectEnergyMetrics(ch, vm, c.collectors)
+		utils.CollectResUtilizationMetrics(ch, vm, c.collectors)
+	}
+	c.Mx.Unlock()
+}
diff --git a/pkg/model/benchmark_test.go b/pkg/model/benchmark_test.go
index eac241e617..ca3cdc9991 100644
--- a/pkg/model/benchmark_test.go
+++ b/pkg/model/benchmark_test.go
@@ -17,100 +17,57 @@ package model_test
 
 import (
 	"os"
-	"strconv"
 	"testing"
 
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
-	"github.com/sustainable-computing-io/kepler/pkg/collector/metric/types"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/collector"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
 	"github.com/sustainable-computing-io/kepler/pkg/model"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
-	"github.com/sustainable-computing-io/kepler/pkg/power/platform"
 )
 
 const (
 	configStrEstimator = "CONTAINER_COMPONENTS_ESTIMATOR=false\n"
 )
 
-func benchmarkNtesting(b *testing.B, containerNumber int) {
-	nodeMetrics := collector_metric.NewNodeMetrics()
-	collector_metric.ContainerFeaturesNames = []string{config.CoreUsageMetric}
-	collector_metric.NodeMetadataFeatureNames = []string{"cpu_architecture"}
-	collector_metric.NodeMetadataFeatureValues = []string{"Sandy Bridge"}
-	// we need to disable the system real time power metrics for testing since we add mock values or use power model estimator
-	components.SetIsSystemCollectionSupported(false)
-	platform.SetIsSystemCollectionSupported(false)
+func benchmarkNtesting(b *testing.B, processNumber int) {
+	// enable metrics
+	stats.SetMockedCollectorMetrics()
+	// create node node metrics
+	metricCollector := collector.NewCollector()
 
-	nodePlatformEnergy := map[string]float64{}
+	// create processes
+	metricCollector.ProcessStats = stats.CreateMockedProcessStats(processNumber)
+	metricCollector.NodeStats = stats.CreateMockedNodeStats()
+	// aggregate processes' resource utilization metrics to containers, virtual machines and nodes
+	metricCollector.AggregateProcessResourceUtilizationMetrics()
 
-	nodePlatformEnergy["sensor0"] = 10
-	nodeMetrics.SetNodePlatformEnergy(nodePlatformEnergy, true, false)
-	nodeMetrics.UpdateIdleEnergyWithMinValue(true)
+	// The default estimator model is the ratio
+	model.CreatePowerEstimatorModels(stats.ProcessFeaturesNames, stats.NodeMetadataFeatureNames, stats.NodeMetadataFeatureValues)
 
-	nodePlatformEnergy["sensor0"] = 20
-	nodeMetrics.SetNodePlatformEnergy(nodePlatformEnergy, true, false)
-	nodeMetrics.UpdateIdleEnergyWithMinValue(true)
-	nodeMetrics.UpdateDynEnergy()
-
-	componentsEnergies := make(map[int]source.NodeComponentsEnergy)
-	componentsEnergies[0] = source.NodeComponentsEnergy{
-		Pkg:    5,
-		Core:   5,
-		DRAM:   5,
-		Uncore: 5,
-	}
-	nodeMetrics.SetNodeComponentsEnergy(componentsEnergies, false, false)
-	componentsEnergies[0] = source.NodeComponentsEnergy{
-		Pkg:    10,
-		Core:   10,
-		DRAM:   10,
-		Uncore: 10,
-	}
-	nodeMetrics.SetNodeComponentsEnergy(componentsEnergies, false, false)
-	nodeMetrics.UpdateIdleEnergyWithMinValue(true)
-	componentsEnergies[0] = source.NodeComponentsEnergy{
-		Pkg:    uint64(containerNumber),
-		Core:   uint64(containerNumber),
-		DRAM:   uint64(containerNumber),
-		Uncore: uint64(containerNumber),
-	}
-	nodeMetrics.SetNodeComponentsEnergy(componentsEnergies, false, false)
-
-	nodeMetrics.UpdateIdleEnergyWithMinValue(true)
-	nodeMetrics.UpdateDynEnergy()
+	// update container and node metrics
 	b.ReportAllocs()
-	containersMetrics := map[string]*collector_metric.ContainerMetrics{}
-	const CONTAINER = "container"
-	for n := 0; n < containerNumber; n++ {
-		containersMetrics[CONTAINER+strconv.Itoa(n)] = collector_metric.NewContainerMetrics(CONTAINER+strconv.Itoa(n), "podA", "test", CONTAINER+strconv.Itoa(n))
-		containersMetrics[CONTAINER+strconv.Itoa(n)].BPFStats[config.CoreUsageMetric] = &types.UInt64Stat{}
-		_ = containersMetrics[CONTAINER+strconv.Itoa(n)].BPFStats[config.CoreUsageMetric].AddNewDelta(30000)
-	}
-	nodeMetrics.AddNodeResUsageFromContainerResUsage(containersMetrics)
 	b.ResetTimer()
-	model.CreatePowerEstimatorModels(collector_metric.ContainerFeaturesNames, collector_metric.NodeMetadataFeatureNames, collector_metric.NodeMetadataFeatureValues)
-	model.UpdateContainerEnergy(containersMetrics, nodeMetrics)
+	metricCollector.UpdateProcessEnergyUtilizationMetrics()
+	metricCollector.AggregateProcessEnergyUtilizationMetrics()
 	b.StopTimer()
 }
 
-func BenchmarkUpdateContainerWith1000Container(b *testing.B) {
+func BenchmarkUpdateProcessWith1000Process(b *testing.B) {
 	// disable side car estimator
 	os.Setenv("MODEL_CONFIG", configStrEstimator)
 	benchmarkNtesting(b, 1000)
 }
 
-func BenchmarkUpdateContainerWith2000Container(b *testing.B) {
+func BenchmarkUpdateProcessWith2000Process(b *testing.B) {
 	os.Setenv("MODEL_CONFIG", configStrEstimator)
 	benchmarkNtesting(b, 2000)
 }
 
-func BenchmarkUpdateContainerWith5000Container(b *testing.B) {
+func BenchmarkUpdateProcessWith4000Process(b *testing.B) {
 	os.Setenv("MODEL_CONFIG", configStrEstimator)
-	benchmarkNtesting(b, 5000)
+	benchmarkNtesting(b, 4000)
 }
 
-func BenchmarkUpdateContainerWith10000Container(b *testing.B) {
+func BenchmarkUpdateProcessWith8000Process(b *testing.B) {
 	os.Setenv("MODEL_CONFIG", configStrEstimator)
-	benchmarkNtesting(b, 10000)
+	benchmarkNtesting(b, 8000)
 }
diff --git a/pkg/model/container_energy.go b/pkg/model/container_energy.go
deleted file mode 100644
index a5d391d020..0000000000
--- a/pkg/model/container_energy.go
+++ /dev/null
@@ -1,307 +0,0 @@
-/*
-Copyright 2021.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-//nolint:dupl // process metrics should be here not in another package
-package model
-
-import (
-	"fmt"
-
-	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/model/types"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
-	"k8s.io/klog/v2"
-)
-
-var (
-	ContainerPlatformPowerModel  PowerMoldelInterface
-	ContainerComponentPowerModel PowerMoldelInterface
-)
-
-// createContainerPowerModelConfig: the container component power model must be set by default.
-func createContainerPowerModelConfig(powerSourceTarget string, containerFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues []string, energySource string) (modelConfig *types.ModelConfig) {
-	modelConfig = CreatePowerModelConfig(powerSourceTarget)
-	if modelConfig == nil {
-		return nil
-	}
-	if modelConfig.InitModelURL == "" {
-		modelConfig.InitModelFilepath = config.GetDefaultPowerModelURL(modelConfig.ModelOutputType.String(), energySource)
-	}
-	modelConfig.ContainerFeatureNames = containerFeatureNames
-	modelConfig.SystemMetaDataFeatureNames = systemMetaDataFeatureNames
-	modelConfig.SystemMetaDataFeatureValues = systemMetaDataFeatureValues
-
-	// Ratio power model has different features than the other estimators.
-	// Ratio power model has node resource and power consumption as features, as it is used to calculate the ratio.
-	if modelConfig.ModelType == types.Ratio {
-		if powerSourceTarget == config.ContainerComponentsPowerKey {
-			pkgUsageMetric := config.CoreUsageMetric
-			coreUsageMetric := config.CoreUsageMetric
-			dramUsageMetric := config.DRAMUsageMetric
-			if !attacher.HardwareCountersEnabled {
-				// Given that there is no HW counter in  some scenarios (e.g. on VMs), we have to use CPUTime data.
-				// Although a busy CPU is more likely to be accessing memory the CPU utilization (CPUTime) does not directly
-				// represent memory access, but it remains the only viable proxy available to approximate such information.
-				pkgUsageMetric, coreUsageMetric, dramUsageMetric = config.CPUTime, config.CPUTime, config.CPUTime
-			}
-			// ContainerFeatureNames contains the metrics that represents the container resource utilization
-			modelConfig.ContainerFeatureNames = []string{
-				pkgUsageMetric,            // for PKG resource usage
-				coreUsageMetric,           // for CORE resource usage
-				dramUsageMetric,           // for DRAM resource usage
-				config.GeneralUsageMetric, // for UNCORE resource usage
-				config.GeneralUsageMetric, // for OTHER resource usage
-				config.GpuUsageMetric,     // for GPU resource usage
-			}
-			// NodeFeatureNames contains the metrics that represents the node resource utilization plus the dynamic and idle power power consumption
-			modelConfig.NodeFeatureNames = modelConfig.ContainerFeatureNames
-			modelConfig.NodeFeatureNames = append(modelConfig.NodeFeatureNames, []string{
-				collector_metric.PKG + collector_metric.DYN,     // for dynamic PKG power consumption
-				collector_metric.CORE + collector_metric.DYN,    // for dynamic CORE power consumption
-				collector_metric.DRAM + collector_metric.DYN,    // for dynamic DRAM power consumption
-				collector_metric.UNCORE + collector_metric.DYN,  // for dynamic UNCORE power consumption
-				collector_metric.OTHER + collector_metric.DYN,   // for dynamic OTHER power consumption
-				collector_metric.GPU + collector_metric.DYN,     // for dynamic GPU power consumption
-				collector_metric.PKG + collector_metric.IDLE,    // for idle PKG power consumption
-				collector_metric.CORE + collector_metric.IDLE,   // for idle CORE power consumption
-				collector_metric.DRAM + collector_metric.IDLE,   // for idle DRAM power consumption
-				collector_metric.UNCORE + collector_metric.IDLE, // for idle UNCORE power consumption
-				collector_metric.OTHER + collector_metric.IDLE,  // for idle OTHER power consumption
-				collector_metric.GPU + collector_metric.IDLE,    // for idle GPU power consumption
-			}...)
-		} else if powerSourceTarget == config.ContainerPlatformPowerKey {
-			platformUsageMetric := config.CoreUsageMetric
-			if !attacher.HardwareCountersEnabled {
-				// Given that there is no HW counter in  some scenarios (e.g. on VMs), we have to use CPUTime data.
-				platformUsageMetric = config.CPUTime
-			}
-			modelConfig.ContainerFeatureNames = []string{
-				platformUsageMetric, // for PLATFORM resource usage
-			}
-			modelConfig.NodeFeatureNames = modelConfig.ContainerFeatureNames
-			modelConfig.NodeFeatureNames = append(modelConfig.NodeFeatureNames, []string{
-				collector_metric.PLATFORM + collector_metric.DYN,  // for dynamic PLATFORM power consumption
-				collector_metric.PLATFORM + collector_metric.IDLE, // for idle PLATFORM power consumption
-			}...)
-		}
-	}
-
-	return modelConfig
-}
-
-func CreateContainerPowerEstimatorModel(containerFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues []string) {
-	var err error
-	modelConfig := createContainerPowerModelConfig(config.ContainerPlatformPowerKey, containerFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues, types.PlatformEnergySource)
-	modelConfig.IsNodePowerModel = false
-	ContainerPlatformPowerModel, err = createPowerModelEstimator(modelConfig)
-	if err == nil {
-		klog.Infof("Using the %s Power Model to estimate Container Platform Power", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String())
-		klog.Infof("Container feature names: %v", modelConfig.ContainerFeatureNames)
-	} else {
-		klog.Infof("Failed to create %s Power Model to estimate Container Platform Power: %v\n", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String(), err)
-	}
-
-	modelConfig = createContainerPowerModelConfig(config.ContainerComponentsPowerKey, containerFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues, types.ComponentEnergySource)
-	modelConfig.IsNodePowerModel = false
-	ContainerComponentPowerModel, err = createPowerModelEstimator(modelConfig)
-	if err == nil {
-		klog.Infof("Using the %s Power Model to estimate Container Component Power", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String())
-		klog.Infof("Container feature names: %v", modelConfig.ContainerFeatureNames)
-	} else {
-		klog.Infof("Failed to create %s Power Model to estimate Container Component Power: %v\n", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String(), err)
-	}
-}
-
-// UpdateContainerEnergy resets the power model samples, add new samples to the power models, then estimates the idle and dynamic energy
-func UpdateContainerEnergy(containersMetrics map[string]*collector_metric.ContainerMetrics, nodeMetrics *collector_metric.NodeMetrics) {
-	if ContainerPlatformPowerModel == nil {
-		klog.Errorln("Container Platform Power Model was not created")
-	}
-	if ContainerComponentPowerModel == nil {
-		klog.Errorln("Container Component Power Model was not created")
-	}
-	// reset power sample slide window
-	ContainerPlatformPowerModel.ResetSampleIdx()
-	ContainerComponentPowerModel.ResetSampleIdx()
-
-	// add features values for prediction
-	containerIDList := addSamplesToPowerModels(containersMetrics, nodeMetrics)
-
-	addEstimatedEnergy(containerIDList, containersMetrics, idlePower)
-	addEstimatedEnergy(containerIDList, containersMetrics, absPower)
-}
-
-// addSamplesToPowerModels converts container's metrics to array to add the samples to the power model
-func addSamplesToPowerModels(containersMetrics map[string]*collector_metric.ContainerMetrics, nodeMetrics *collector_metric.NodeMetrics) []string {
-	containerIDList := []string{}
-	// Add container metrics
-	for containerID, c := range containersMetrics {
-		// add samples to estimate the platform power
-		if ContainerPlatformPowerModel.IsEnabled() {
-			featureValues := c.ToEstimatorValues(ContainerPlatformPowerModel.GetContainerFeatureNamesList(), true) // add container features with normalized values
-			ContainerPlatformPowerModel.AddContainerFeatureValues(featureValues)
-		}
-
-		// add samples to estimate the components (CPU and DRAM) power
-		if ContainerComponentPowerModel.IsEnabled() {
-			// Add container metrics
-			featureValues := c.ToEstimatorValues(ContainerComponentPowerModel.GetContainerFeatureNamesList(), true) // add node features with normalized values
-			ContainerComponentPowerModel.AddContainerFeatureValues(featureValues)
-		}
-
-		containerIDList = append(containerIDList, containerID)
-	}
-	// Add node metrics.
-	if ContainerPlatformPowerModel.IsEnabled() {
-		featureValues := nodeMetrics.ToEstimatorValues(ContainerPlatformPowerModel.GetNodeFeatureNamesList(), true) // add node features with normalized values
-		ContainerPlatformPowerModel.AddNodeFeatureValues(featureValues)
-	}
-	if ContainerComponentPowerModel.IsEnabled() {
-		featureValues := nodeMetrics.ToEstimatorValues(ContainerComponentPowerModel.GetNodeFeatureNamesList(), true) // add node features with normalized values
-		ContainerComponentPowerModel.AddNodeFeatureValues(featureValues)
-	}
-	return containerIDList
-}
-
-// addEstimatedEnergy estimates the idle power consumption
-func addEstimatedEnergy(containerIDList []string, containersMetrics map[string]*collector_metric.ContainerMetrics, isIdlePower bool) {
-	var err error
-	var containerGPUPower []float64
-	var containerPlatformPower []float64
-	var containerComponentsPower []source.NodeComponentsEnergy
-
-	errComp := fmt.Errorf("component power model is not enabled")
-	errGPU := fmt.Errorf("gpu power model is not enabled")
-	errPlat := fmt.Errorf("plat power model is not enabled")
-
-	// estimate the associated power comsumption of all RAPL node components for each container
-	if ContainerComponentPowerModel.IsEnabled() {
-		containerComponentsPower, errComp = ContainerComponentPowerModel.GetComponentsPower(isIdlePower)
-		if errComp != nil {
-			klog.V(5).Infoln("Could not estimate the Container Components Power")
-		}
-		// estimate the associated power comsumption of GPU for each container
-		if gpu.IsGPUCollectionSupported() {
-			containerGPUPower, errGPU = ContainerComponentPowerModel.GetGPUPower(isIdlePower)
-			if errGPU != nil {
-				klog.V(5).Infoln("Could not estimate the Container GPU Power")
-			}
-		}
-	}
-	// estimate the associated power comsumption of platform for each container
-	if ContainerPlatformPowerModel.IsEnabled() {
-		containerPlatformPower, errPlat = ContainerPlatformPowerModel.GetPlatformPower(isIdlePower)
-		if errPlat != nil {
-			klog.V(5).Infoln("Could not estimate the Container Platform Power")
-		}
-	}
-
-	var energy uint64
-	for i, containerID := range containerIDList {
-		if errComp == nil {
-			// add PKG power consumption
-			// since Kepler collects metrics at intervals of SamplePeriodSec, which is greater than 1 second, it is necessary to calculate the energy consumption for the entire waiting period
-			energy = containerComponentsPower[i].Pkg * config.SamplePeriodSec
-			if isIdlePower {
-				err = containersMetrics[containerID].IdleEnergyInPkg.AddNewDelta(energy)
-			} else {
-				err = containersMetrics[containerID].DynEnergyInPkg.AddNewDelta(energy)
-			}
-			if err != nil {
-				klog.V(5).Infoln(err)
-			}
-
-			// add CORE power consumption
-			energy = containerComponentsPower[i].Core * config.SamplePeriodSec
-			if isIdlePower {
-				err = containersMetrics[containerID].IdleEnergyInCore.AddNewDelta(energy)
-			} else {
-				err = containersMetrics[containerID].DynEnergyInCore.AddNewDelta(energy)
-			}
-			if err != nil {
-				klog.V(5).Infoln(err)
-			}
-
-			// add DRAM power consumption
-			energy = containerComponentsPower[i].DRAM * config.SamplePeriodSec
-			if isIdlePower {
-				err = containersMetrics[containerID].IdleEnergyInDRAM.AddNewDelta(energy)
-			} else {
-				err = containersMetrics[containerID].DynEnergyInDRAM.AddNewDelta(energy)
-			}
-			if err != nil {
-				klog.V(5).Infoln(err)
-			}
-
-			// add Uncore power consumption
-			energy = containerComponentsPower[i].Uncore * config.SamplePeriodSec
-			if isIdlePower {
-				err = containersMetrics[containerID].IdleEnergyInUncore.AddNewDelta(energy)
-			} else {
-				err = containersMetrics[containerID].DynEnergyInUncore.AddNewDelta(energy)
-			}
-			if err != nil {
-				klog.V(5).Infoln(err)
-			}
-
-			// add GPU power consumption
-			if errGPU == nil {
-				energy = uint64(containerGPUPower[i]) * (config.SamplePeriodSec)
-				if isIdlePower {
-					err = containersMetrics[containerID].IdleEnergyInGPU.AddNewDelta(energy)
-				} else {
-					err = containersMetrics[containerID].DynEnergyInGPU.AddNewDelta(energy)
-				}
-				if err != nil {
-					klog.V(5).Infoln(err)
-				}
-			}
-		}
-
-		if errPlat == nil {
-			energy = uint64(containerPlatformPower[i]) * config.SamplePeriodSec
-			if isIdlePower {
-				err = containersMetrics[containerID].IdleEnergyInPlatform.AddNewDelta(energy)
-			} else {
-				err = containersMetrics[containerID].DynEnergyInPlatform.AddNewDelta(energy)
-			}
-			if err != nil {
-				klog.V(5).Infoln(err)
-			}
-		}
-
-		// estimate other components power if both platform and components power are available
-		if errComp == nil && errPlat == nil {
-			// TODO: verify if Platform power also includes the GPU into consideration
-			otherPower := containerPlatformPower[i] - float64(containerComponentsPower[i].Pkg) - float64(containerComponentsPower[i].DRAM)
-			if otherPower < 0 {
-				otherPower = 0
-			}
-			energy = uint64(otherPower) * config.SamplePeriodSec
-			if isIdlePower {
-				err = containersMetrics[containerID].IdleEnergyInOther.AddNewDelta(energy)
-			} else {
-				err = containersMetrics[containerID].DynEnergyInOther.AddNewDelta(energy)
-			}
-			if err != nil {
-				klog.V(5).Infoln(err)
-			}
-		}
-	}
-}
diff --git a/pkg/model/container_energy_test.go b/pkg/model/container_energy_test.go
deleted file mode 100644
index 0e25b7f267..0000000000
--- a/pkg/model/container_energy_test.go
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
-Copyright 2021.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package model
-
-import (
-	"os"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
-	"github.com/sustainable-computing-io/kepler/pkg/power/platform"
-)
-
-// we need to add all metric to a container, otherwise it will not create the right usageMetric with all elements. The usageMetric is used in the Prediction Power Models
-// TODO: do not use a fixed usageMetric array in the power models, a structured data is more disarable.
-func setCollectorMetrics() {
-	if gpu.IsGPUCollectionSupported() {
-		err := gpu.Init() // create structure instances that will be accessed to create a containerMetric
-		Expect(err).NotTo(HaveOccurred())
-	}
-	// initialize the Available metrics since they are used to create a new containersMetrics instance
-	collector_metric.AvailableBPFHWCounters = []string{
-		config.CPUCycle,
-		config.CPUInstruction,
-		config.CacheMiss,
-	}
-	collector_metric.AvailableBPFSWCounters = []string{
-		config.CPUTime,
-		config.PageCacheHit,
-	}
-	collector_metric.AvailableCGroupMetrics = []string{
-		config.CgroupfsMemory,
-		config.CgroupfsKernelMemory,
-		config.CgroupfsTCPMemory,
-		config.CgroupfsCPU,
-		config.CgroupfsSystemCPU,
-		config.CgroupfsUserCPU,
-		config.CgroupfsReadIO,
-		config.CgroupfsWriteIO,
-		config.BlockDevicesIO,
-	}
-	collector_metric.AvailableKubeletMetrics = []string{
-		config.KubeletCPUUsage,
-		config.KubeletMemoryUsage,
-	}
-	collector_metric.ContainerUintFeaturesNames = []string{}
-	collector_metric.ContainerUintFeaturesNames = append(collector_metric.ContainerUintFeaturesNames, collector_metric.AvailableBPFSWCounters...)
-	collector_metric.ContainerUintFeaturesNames = append(collector_metric.ContainerUintFeaturesNames, collector_metric.AvailableBPFHWCounters...)
-	collector_metric.ContainerUintFeaturesNames = append(collector_metric.ContainerUintFeaturesNames, collector_metric.AvailableCGroupMetrics...)
-	collector_metric.ContainerUintFeaturesNames = append(collector_metric.ContainerUintFeaturesNames, collector_metric.AvailableKubeletMetrics...)
-	// ContainerFeaturesNames is used by the nodeMetrics to extract the resource usage. Only the metrics in ContainerFeaturesNames will be used.
-	collector_metric.ContainerFeaturesNames = collector_metric.ContainerUintFeaturesNames
-	collector_metric.CPUHardwareCounterEnabled = true
-}
-
-// add two containers with all metrics initialized
-func createMockContainersMetrics() map[string]*collector_metric.ContainerMetrics {
-	containersMetrics := map[string]*collector_metric.ContainerMetrics{}
-	containersMetrics["containerA"] = createMockContainerMetrics("containerA", "podA", "test")
-	containersMetrics["containerB"] = createMockContainerMetrics("containerB", "podB", "test")
-
-	return containersMetrics
-}
-
-// see usageMetrics for the list of used metrics. For the sake of visibility we add all metrics, but only few of them will be used.
-func createMockContainerMetrics(containerName, podName, namespace string) *collector_metric.ContainerMetrics {
-	containerMetrics := collector_metric.NewContainerMetrics(containerName, podName, namespace, containerName)
-	// counter - attacher package
-	err := containerMetrics.BPFStats[config.CPUCycle].AddNewDelta(30000)
-	Expect(err).NotTo(HaveOccurred())
-	err = containerMetrics.BPFStats[config.CPUInstruction].AddNewDelta(30000)
-	Expect(err).NotTo(HaveOccurred())
-	err = containerMetrics.BPFStats[config.CacheMiss].AddNewDelta(30000)
-	Expect(err).NotTo(HaveOccurred())
-	// bpf - cpu time
-	err = containerMetrics.BPFStats[config.CPUTime].AddNewDelta(30000) // config.CPUTime
-	Expect(err).NotTo(HaveOccurred())
-	// cgroup - cgroup package
-	// we need to add two aggregated values to the stats so that it can calculate a current value (i.e. agg diff)
-	// cgroup memory is expressed in bytes, to make it meaninful we set 1MB
-	// since kepler collects metrics for every 3s, the metrics will be normalized by 3 to estimate power, because of that to make the test easier we create delta  as multiple of 3
-	containerMetrics.CgroupStatMap[config.CgroupfsMemory].SetAggrStat(containerName, 1000000)
-	containerMetrics.CgroupStatMap[config.CgroupfsMemory].SetAggrStat(containerName, 4000000) // delta is 30MB
-	// cgroup kernel memory is expressed in bytes, to make it meaninful we set 100KB
-	containerMetrics.CgroupStatMap[config.CgroupfsKernelMemory].SetAggrStat(containerName, 100000)
-	containerMetrics.CgroupStatMap[config.CgroupfsKernelMemory].SetAggrStat(containerName, 400000) // delta is 30KB
-	containerMetrics.CgroupStatMap[config.CgroupfsTCPMemory].SetAggrStat(containerName, 100000)
-	containerMetrics.CgroupStatMap[config.CgroupfsTCPMemory].SetAggrStat(containerName, 400000)
-	// cgroup cpu time is expressed in microseconds, to make it meaninful we set it to 10ms
-	containerMetrics.CgroupStatMap[config.CgroupfsCPU].SetAggrStat(containerName, 10000)
-	containerMetrics.CgroupStatMap[config.CgroupfsCPU].SetAggrStat(containerName, 40000) // delta is 30ms
-	// cgroup cpu time is expressed in microseconds, to make it meaninful we set it to 1ms
-	containerMetrics.CgroupStatMap[config.CgroupfsSystemCPU].SetAggrStat(containerName, 1000)
-	containerMetrics.CgroupStatMap[config.CgroupfsSystemCPU].SetAggrStat(containerName, 4000)
-	containerMetrics.CgroupStatMap[config.CgroupfsUserCPU].SetAggrStat(containerName, 1000)
-	containerMetrics.CgroupStatMap[config.CgroupfsUserCPU].SetAggrStat(containerName, 4000)
-	// cgroup read and write IO are expressed in bytes, to make it meaninful we set 10KB
-	containerMetrics.CgroupStatMap[config.CgroupfsReadIO].SetAggrStat(containerName, 10000)
-	containerMetrics.CgroupStatMap[config.CgroupfsReadIO].SetAggrStat(containerName, 40000)
-	containerMetrics.CgroupStatMap[config.CgroupfsWriteIO].SetAggrStat(containerName, 10000)
-	containerMetrics.CgroupStatMap[config.CgroupfsWriteIO].SetAggrStat(containerName, 40000)
-	containerMetrics.CgroupStatMap[config.BlockDevicesIO].SetAggrStat(containerName, 1)
-	containerMetrics.CgroupStatMap[config.BlockDevicesIO].SetAggrStat(containerName, 1)
-	return containerMetrics
-}
-
-func createMockNodeMetrics(containersMetrics map[string]*collector_metric.ContainerMetrics) *collector_metric.NodeMetrics {
-	nodeMetrics := collector_metric.NewNodeMetrics()
-	nodeMetrics.AddNodeResUsageFromContainerResUsage(containersMetrics)
-
-	return nodeMetrics
-}
-
-var _ = Describe("ContainerPower", func() {
-	var (
-		containersMetrics map[string]*collector_metric.ContainerMetrics
-		nodeMetrics       *collector_metric.NodeMetrics
-
-		machineSensorID = "sensor0"
-		machineSocketID = 0
-
-		systemMetaDataFeatureNames  = []string{"cpu_architecture"}
-		systemMetaDataFeatureValues = []string{"Sandy Bridge"}
-	)
-
-	Context("with manually defined node power", func() {
-		BeforeEach(func() {
-			// we need to disable the system real time power metrics for testing since we add mock values or use power model estimator
-			components.SetIsSystemCollectionSupported(false)
-			platform.SetIsSystemCollectionSupported(false)
-			setCollectorMetrics()
-
-			containersMetrics = createMockContainersMetrics()
-			nodeMetrics = createMockNodeMetrics(containersMetrics)
-		})
-
-		// By default the Ratio power mode is used to get the container power
-		It("Get container power with Ratio power model and node component power", func() {
-			configStr := "CONTAINER_COMPONENTS_ESTIMATOR=false\n"
-			os.Setenv("MODEL_CONFIG", configStr)
-
-			// getEstimatorMetrics
-			CreatePowerEstimatorModels(containerFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
-
-			// initialize the node energy with aggregated energy, which will be used to calculate delta energy
-			// note that NodeComponentsEnergy contains aggregated energy over time
-			componentsEnergies := make(map[int]source.NodeComponentsEnergy)
-			componentsEnergies[machineSocketID] = source.NodeComponentsEnergy{
-				Pkg:    5000, // mJ
-				Core:   5000,
-				DRAM:   5000,
-				Uncore: 5000,
-			}
-			nodeMetrics.SetNodeComponentsEnergy(componentsEnergies, counter, absPower)
-			componentsEnergies[machineSocketID] = source.NodeComponentsEnergy{
-				Pkg:    10000, // mJ
-				Core:   10000,
-				DRAM:   10000,
-				Uncore: 10000,
-			}
-			// the second node energy will force to calculate a delta. The delta is calculates after added at least two aggregated metric
-			nodeMetrics.SetNodeComponentsEnergy(componentsEnergies, counter, absPower)
-			nodeMetrics.UpdateIdleEnergyWithMinValue(true)
-			// the third node energy will represent the idle and dynamic power. The idle power is only calculated after there at at least two delta values
-			componentsEnergies[machineSocketID] = source.NodeComponentsEnergy{
-				Pkg:    45000, // 35000mJ delta, which is 5000mJ idle, 30000mJ dynamic power
-				Core:   45000,
-				DRAM:   45000,
-				Uncore: 45000,
-			}
-			nodeMetrics.SetNodeComponentsEnergy(componentsEnergies, counter, absPower)
-			nodeMetrics.UpdateDynEnergy()
-
-			// calculate container energy consumption
-			UpdateContainerEnergy(containersMetrics, nodeMetrics)
-
-			// The default container power model is the Ratio, then container energy consumption will be as follows:
-			// The node components dynamic power were set to 30000mJ, since the kepler interval is 3s, the power is 10000mJ
-			// The test created 2 containers with 30000 CPU Instructions, since the kepler interval is 3s, the normalized value is 10000
-			// So the node total CPU Instructions is 20000
-			// The container power will be (10000/20000)*10000 = 5000
-			// Then, the container energy will be 5000*3 = 15000 mJ
-			Expect(containersMetrics["containerA"].DynEnergyInPkg.Delta).To(Equal(uint64(15000)))
-		})
-
-		It("Get container power with Ratio power model and node platform power ", func() {
-			configStr := "CONTAINER_COMPONENTS_ESTIMATOR=false\n"
-			os.Setenv("MODEL_CONFIG", configStr)
-
-			// getEstimatorMetrics
-			CreatePowerEstimatorModels(containerFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
-
-			// manually add the node power  metrics
-			// initialize the node energy with aggregated energy, which will be used to calculate delta energy
-			nodePlatformEnergy := map[string]float64{}
-			// initialize the node energy with aggregated energy, which will be used to calculate delta energy
-			nodePlatformEnergy[machineSensorID] = 5000 // mJ
-			nodeMetrics.SetNodePlatformEnergy(nodePlatformEnergy, gauge, absPower)
-			nodeMetrics.UpdateIdleEnergyWithMinValue(true)
-			// the second node energy will represent the idle and dynamic power. The idle power is only calculated after there at at least two delta values
-			nodePlatformEnergy[machineSensorID] = 35000
-			nodeMetrics.SetNodePlatformEnergy(nodePlatformEnergy, gauge, absPower)
-			nodeMetrics.UpdateDynEnergy()
-
-			// calculate container energy consumption
-			UpdateContainerEnergy(containersMetrics, nodeMetrics)
-
-			// The default container power model is the Ratio, then container energy consumption will be as follows:
-			// The node components dynamic power were set to 30000mJ, since the kepler interval is 3s, the power is 10000mJ
-			// The test created 2 containers with 30000 CPU Instructions, since the kepler interval is 3s, the normalized value is 10000
-			// So the node total CPU Instructions is 20000
-			// The container power will be (10000/20000)*10000 = 5000
-			// Then, the container energy will be 5000*3 = 15000 mJ
-			Expect(containersMetrics["containerA"].DynEnergyInPlatform.Delta).To(Equal(uint64(15000)))
-		})
-
-		// TODO: Get container power with no dependency and no node power.
-		// The current LR model has some problems, all the model weights are negative, which means that the energy consumption will decrease with larger resource utilization.
-		// Consequently the dynamic power will be 0 since the idle power with 0 resource utilization will be higher than the absolute power with non zero utilization
-		// Because of that we removed this test until we have a power model that is more accurate.
-		// It("Get container power with Ratio power model and node power with Linear Regression Power Model", func() {
-		// 	// the default power models will be linear regression for node power estimation and ratio for container power estimation
-		// 	CreatePowerEstimatorModels(containerFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
-		// 	// add node energy via estimator, using the LR model (the default configured one)
-		// 	// UpdateNodePlatformEnergy(nodeMetrics) currently we do not have the node platform abs power model, we will include that in the future
-		// 	UpdateNodeComponentEnergy(nodeMetrics)
-		// 	// calculate container energy consumption
-		// 	UpdateContainerEnergy(containersMetrics, nodeMetrics)
-		// 	Expect(containersMetrics["containerA"].DynEnergyInPkg.Delta).To(Equal(uint64(???)))
-		// })
-	})
-})
diff --git a/pkg/model/estimator/local/lr.go b/pkg/model/estimator/local/lr.go
index 6eccddeef3..abb32390c4 100644
--- a/pkg/model/estimator/local/lr.go
+++ b/pkg/model/estimator/local/lr.go
@@ -34,10 +34,8 @@ import (
 	"github.com/sustainable-computing-io/kepler/pkg/config"
 	"github.com/sustainable-computing-io/kepler/pkg/model/types"
 	"github.com/sustainable-computing-io/kepler/pkg/model/utils"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components/source"
 	"k8s.io/klog/v2"
-
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
 )
 
 const (
@@ -157,11 +155,11 @@ type LinearRegressor struct {
 	SystemMetaDataFeatureNames  []string
 	SystemMetaDataFeatureValues []string
 
-	floatFeatureValues [][]float64 // metrics per process/container/pod/node
+	floatFeatureValues [][]float64 // metrics per process/process/pod/node
 	// idle power is calculated with the minimal resource utilization, which means that the system is at rest
 	// due to performance reasons, we keep a shadow copy of the floatFeatureValues with 1 values
-	floatFeatureValuesForIdlePower [][]float64 // metrics per process/container/pod/node
-	// xidx represents the instance slide window position, where an instance can be process/container/pod/node
+	floatFeatureValuesForIdlePower [][]float64 // metrics per process/process/pod/node
+	// xidx represents the instance slide window position, where an instance can be process/process/pod/node
 	xidx int
 
 	enabled     bool
@@ -294,7 +292,7 @@ func (r *LinearRegressor) loadWeightFromURL() ([]byte, error) {
 	return body, nil
 }
 
-// GetPlatformPower applies ModelWeight prediction and return a list of power associated to each process/container/pod
+// GetPlatformPower applies ModelWeight prediction and return a list of power associated to each process/process/pod
 func (r *LinearRegressor) GetPlatformPower(isIdlePower bool) ([]float64, error) {
 	if !r.enabled {
 		return []float64{}, fmt.Errorf("disabled power model call: %s", r.OutputType.String())
@@ -304,7 +302,7 @@ func (r *LinearRegressor) GetPlatformPower(isIdlePower bool) ([]float64, error)
 		if isIdlePower {
 			floatFeatureValues = r.floatFeatureValuesForIdlePower[0:r.xidx]
 		}
-		if modelWeight, found := (*r.modelWeight)[collector_metric.PLATFORM]; found {
+		if modelWeight, found := (*r.modelWeight)[config.PLATFORM]; found {
 			power := modelWeight.predict(
 				r.FloatFeatureNames, floatFeatureValues,
 				r.SystemMetaDataFeatureNames, r.SystemMetaDataFeatureValues)
@@ -315,7 +313,7 @@ func (r *LinearRegressor) GetPlatformPower(isIdlePower bool) ([]float64, error)
 	return []float64{}, fmt.Errorf("model Weight for model type %s is nil", r.OutputType.String())
 }
 
-// GetComponentsPower applies each component's ModelWeight prediction and return a map of component power associated to each process/container/pod
+// GetComponentsPower applies each component's ModelWeight prediction and return a map of component power associated to each process/process/pod
 func (r *LinearRegressor) GetComponentsPower(isIdlePower bool) ([]source.NodeComponentsEnergy, error) {
 	if !r.enabled {
 		return []source.NodeComponentsEnergy{}, fmt.Errorf("disabled power model call: %s", r.OutputType.String())
@@ -336,19 +334,19 @@ func (r *LinearRegressor) GetComponentsPower(isIdlePower bool) ([]source.NodeCom
 	}
 
 	nodeComponentsPower := []source.NodeComponentsEnergy{}
-	num := r.xidx // number of processes/containers/pods
+	num := r.xidx // number of processes
 	for index := 0; index < num; index++ {
-		pkgPower := utils.GetComponentPower(compPowers, collector_metric.PKG, index)
-		corePower := utils.GetComponentPower(compPowers, collector_metric.CORE, index)
-		uncorePower := utils.GetComponentPower(compPowers, collector_metric.UNCORE, index)
-		dramPower := utils.GetComponentPower(compPowers, collector_metric.DRAM, index)
+		pkgPower := utils.GetComponentPower(compPowers, config.PKG, index)
+		corePower := utils.GetComponentPower(compPowers, config.CORE, index)
+		uncorePower := utils.GetComponentPower(compPowers, config.UNCORE, index)
+		dramPower := utils.GetComponentPower(compPowers, config.DRAM, index)
 		nodeComponentsPower = append(nodeComponentsPower, utils.FillNodeComponentsPower(pkgPower, corePower, uncorePower, dramPower))
 	}
 
 	return nodeComponentsPower, nil
 }
 
-// GetComponentsPower returns GPU Power in Watts associated to each each process/container/pod
+// GetComponentsPower returns GPU Power in Watts associated to each each process
 func (r *LinearRegressor) GetGPUPower(isIdlePower bool) ([]float64, error) {
 	return []float64{}, fmt.Errorf("current power model does not support GPUs")
 }
@@ -365,27 +363,27 @@ func (r *LinearRegressor) addFloatFeatureValues(x []float64) {
 				r.floatFeatureValuesForIdlePower[r.xidx] = append(r.floatFeatureValuesForIdlePower[r.xidx], 0)
 			}
 		} else {
-			// add new container
+			// add new process
 			r.floatFeatureValues = append(r.floatFeatureValues, []float64{})
 			r.floatFeatureValuesForIdlePower = append(r.floatFeatureValuesForIdlePower, []float64{})
-			// add feature of new container
+			// add feature of new process
 			r.floatFeatureValues[r.xidx] = append(r.floatFeatureValues[r.xidx], feature)
 			r.floatFeatureValuesForIdlePower[r.xidx] = append(r.floatFeatureValuesForIdlePower[r.xidx], 0)
 		}
 	}
-	r.xidx += 1 // mode pointer to next container
+	r.xidx += 1 // mode pointer to next process
 }
 
-// AddContainerFeatureValues adds the the x for prediction, which are the explanatory variables (or the independent variable) of regression.
+// AddProcessFeatureValues adds the the x for prediction, which are the explanatory variables (or the independent variable) of regression.
 // LinearRegressor is trained off-line then we cannot Add training samples. We might implement it in the future.
-// The LinearRegressor does not differentiate node or container power estimation, the difference will only be the amount of resource utilization
-func (r *LinearRegressor) AddContainerFeatureValues(x []float64) {
+// The LinearRegressor does not differentiate node or process power estimation, the difference will only be the amount of resource utilization
+func (r *LinearRegressor) AddProcessFeatureValues(x []float64) {
 	r.addFloatFeatureValues(x)
 }
 
 // AddNodeFeatureValues adds the the x for prediction, which is the variable used to calculate the ratio.
 // LinearRegressor is not trained, then we cannot Add training samples, only samples for prediction.
-// The LinearRegressor does not differentiate node or container power estimation, the difference will only be the amount of resource utilization
+// The LinearRegressor does not differentiate node or process power estimation, the difference will only be the amount of resource utilization
 func (r *LinearRegressor) AddNodeFeatureValues(x []float64) {
 	r.addFloatFeatureValues(x)
 }
@@ -416,14 +414,14 @@ func (r *LinearRegressor) GetModelType() types.ModelType {
 	return types.LinearRegressor
 }
 
-// GetContainerFeatureNamesList returns the list of float features that the model was configured to use
-// The LinearRegressor does not differentiate node or container power estimation, the difference will only be the amount of resource utilization
-func (r *LinearRegressor) GetContainerFeatureNamesList() []string {
+// GetProcessFeatureNamesList returns the list of float features that the model was configured to use
+// The LinearRegressor does not differentiate node or process power estimation, the difference will only be the amount of resource utilization
+func (r *LinearRegressor) GetProcessFeatureNamesList() []string {
 	return r.FloatFeatureNames
 }
 
 // GetNodeFeatureNamesList returns the list of float features that the model was configured to use
-// The LinearRegressor does not differentiate node or container power estimation, the difference will only be the amount of resource utilization
+// The LinearRegressor does not differentiate node or process power estimation, the difference will only be the amount of resource utilization
 func (r *LinearRegressor) GetNodeFeatureNamesList() []string {
 	return r.FloatFeatureNames
 }
diff --git a/pkg/model/estimator/local/lr_test.go b/pkg/model/estimator/local/lr_test.go
index 230543175c..b96a0461c4 100644
--- a/pkg/model/estimator/local/lr_test.go
+++ b/pkg/model/estimator/local/lr_test.go
@@ -31,7 +31,6 @@ import (
 	"net/http"
 	"net/http/httptest"
 
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
 	"github.com/sustainable-computing-io/kepler/pkg/model/types"
 )
@@ -39,7 +38,7 @@ import (
 var (
 	SampleDynPowerValue float64 = 100.0
 
-	containerFeatureNames = []string{
+	processFeatureNames = []string{
 		config.CPUCycle,
 		config.CPUInstruction,
 		config.CacheMiss,
@@ -52,13 +51,11 @@ var (
 		config.CgroupfsReadIO,
 		config.CgroupfsWriteIO,
 		config.BlockDevicesIO,
-		config.KubeletCPUUsage,
-		config.KubeletMemoryUsage,
 	}
 	systemMetaDataFeatureNames = []string{"cpu_architecture"}
-	containerFeatureValues     = [][]float64{
-		{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, // container A
-		{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, // container B
+	processFeatureValues       = [][]float64{
+		{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, // process A
+		{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, // process B
 	}
 	nodeFeatureValues           = []float64{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}
 	systemMetaDataFeatureValues = []string{"Sandy Bridge"}
@@ -77,11 +74,11 @@ var (
 		"cache_miss": {Weight: 1.0, Scale: 1},
 	}
 	SampleComponentWeightResponse = ComponentModelWeights{
-		collector_metric.CORE: genWeights(SampleCoreNumericalVars),
-		collector_metric.DRAM: genWeights(SampleDramNumbericalVars),
+		config.CORE: genWeights(SampleCoreNumericalVars),
+		config.DRAM: genWeights(SampleDramNumbericalVars),
 	}
 	SamplePlatformWeightResponse = ComponentModelWeights{
-		collector_metric.PLATFORM: genWeights(SampleCoreNumericalVars),
+		config.PLATFORM: genWeights(SampleCoreNumericalVars),
 	}
 )
 
@@ -122,7 +119,7 @@ func genLinearRegressor(outputType types.ModelOutputType, energySource, modelSer
 		ModelServerEndpoint:         modelServerEndpoint,
 		OutputType:                  outputType,
 		EnergySource:                energySource,
-		FloatFeatureNames:           containerFeatureNames,
+		FloatFeatureNames:           processFeatureNames,
 		SystemMetaDataFeatureNames:  systemMetaDataFeatureNames,
 		SystemMetaDataFeatureValues: systemMetaDataFeatureValues,
 		ModelWeightsURL:             modelWeightsURL,
@@ -162,36 +159,36 @@ var _ = Describe("Test LR Weight Unit", func() {
 			Expect(compPowers[0].Core).Should(BeEquivalentTo(4000))
 		})
 
-		It("Get Container Platform Power By Linear Regression Estimator with ModelServerEndpoint", func() {
+		It("Get Process Platform Power By Linear Regression Estimator with ModelServerEndpoint", func() {
 			testServer := httptest.NewServer(http.HandlerFunc(getDummyWeights))
 			modelWeightFilepath := config.GetDefaultPowerModelURL(types.DynPower.String(), types.PlatformEnergySource)
 			r := genLinearRegressor(types.DynPower, types.PlatformEnergySource, testServer.URL, "", modelWeightFilepath)
 			err := r.Start()
 			Expect(err).To(BeNil())
 			r.ResetSampleIdx()
-			for _, containerFeatureValues := range containerFeatureValues {
-				r.AddContainerFeatureValues(containerFeatureValues) // add samples to the power model
+			for _, processFeatureValues := range processFeatureValues {
+				r.AddProcessFeatureValues(processFeatureValues) // add samples to the power model
 			}
 			powers, err := r.GetPlatformPower(false)
 			Expect(err).NotTo(HaveOccurred())
-			Expect(len(powers)).Should(Equal(len(containerFeatureValues)))
+			Expect(len(powers)).Should(Equal(len(processFeatureValues)))
 			// TODO: verify if the power makes sense
 			Expect(powers[0]).Should(BeEquivalentTo(3))
 		})
 
-		It("Get Container Components Power By Linear Regression Estimator with ModelServerEndpoint", func() {
+		It("Get Process Components Power By Linear Regression Estimator with ModelServerEndpoint", func() {
 			testServer := httptest.NewServer(http.HandlerFunc(getDummyWeights))
 			modelWeightFilepath := config.GetDefaultPowerModelURL(types.DynPower.String(), types.ComponentEnergySource)
 			r := genLinearRegressor(types.DynPower, types.ComponentEnergySource, testServer.URL, "", modelWeightFilepath)
 			err := r.Start()
 			Expect(err).To(BeNil())
 			r.ResetSampleIdx()
-			for _, containerFeatureValues := range containerFeatureValues {
-				r.AddContainerFeatureValues(containerFeatureValues) // add samples to the power model
+			for _, processFeatureValues := range processFeatureValues {
+				r.AddProcessFeatureValues(processFeatureValues) // add samples to the power model
 			}
 			compPowers, err := r.GetComponentsPower(false)
 			Expect(err).NotTo(HaveOccurred())
-			Expect(len(compPowers)).Should(Equal(len(containerFeatureValues)))
+			Expect(len(compPowers)).Should(Equal(len(processFeatureValues)))
 			// TODO: verify if the power makes sense
 			Expect(compPowers[0].Core).Should(BeEquivalentTo(3000))
 		})
@@ -224,31 +221,31 @@ var _ = Describe("Test LR Weight Unit", func() {
 			Expect(err).NotTo(HaveOccurred())
 		})
 
-		It("Get Container Components Power By Linear Regression Estimator without ModelServerEndpoint", func() {
-			// Estimate Container Components Power using Linear Regression
+		It("Get Process Components Power By Linear Regression Estimator without ModelServerEndpoint", func() {
+			// Estimate Process Components Power using Linear Regression
 			modelWeightFilepath := config.GetDefaultPowerModelURL(types.DynPower.String(), types.ComponentEnergySource)
 			initModelURL := "https://raw.githubusercontent.com/sustainable-computing-io/kepler-model-db/main/models/v0.6/nx12/std_v0.6/acpi/DynPower/BPFOnly/SGDRegressorTrainer_1.json"
 			r := genLinearRegressor(types.DynPower, types.PlatformEnergySource, "", initModelURL, modelWeightFilepath)
 			err := r.Start()
 			Expect(err).To(BeNil())
 			r.ResetSampleIdx()
-			for _, containerFeatureValues := range containerFeatureValues {
-				r.AddContainerFeatureValues(containerFeatureValues) // add samples to the power model
+			for _, processFeatureValues := range processFeatureValues {
+				r.AddProcessFeatureValues(processFeatureValues) // add samples to the power model
 			}
 			_, err = r.GetComponentsPower(false)
 			Expect(err).NotTo(HaveOccurred())
 		})
 
-		It("Get Container Components Power By Linear Regression Estimator without ModelServerEndpoint", func() {
-			// Estimate Container Components Power using Linear Regression
+		It("Get Process Components Power By Linear Regression Estimator without ModelServerEndpoint", func() {
+			// Estimate Process Components Power using Linear Regression
 			modelWeightFilepath := config.GetDefaultPowerModelURL(types.DynPower.String(), types.ComponentEnergySource)
 			initModelURL := "https://raw.githubusercontent.com/sustainable-computing-io/kepler-model-db/main/models/v0.6/nx12/std_v0.6/rapl/DynPower/BPFOnly/SGDRegressorTrainer_1.json"
 			r := genLinearRegressor(types.DynPower, types.ComponentEnergySource, "", initModelURL, modelWeightFilepath)
 			err := r.Start()
 			Expect(err).To(BeNil())
 			r.ResetSampleIdx()
-			for _, containerFeatureValues := range containerFeatureValues {
-				r.AddContainerFeatureValues(containerFeatureValues) // add samples to the power model
+			for _, processFeatureValues := range processFeatureValues {
+				r.AddProcessFeatureValues(processFeatureValues) // add samples to the power model
 			}
 			_, err = r.GetComponentsPower(false)
 			Expect(err).NotTo(HaveOccurred())
diff --git a/pkg/model/estimator/local/ratio.go b/pkg/model/estimator/local/ratio.go
index 8c8562e37e..473f1363f9 100644
--- a/pkg/model/estimator/local/ratio.go
+++ b/pkg/model/estimator/local/ratio.go
@@ -16,17 +16,16 @@ limitations under the License.
 
 /*
 ratio.go
-calculate Containers' component and other power by ratio approach when node power is available.
+calculate Processes' component and other power by ratio approach when node power is available.
 */
 
-//nolint:dupl // the ratio process should be removed
 package local
 
 import (
 	"math"
 
 	"github.com/sustainable-computing-io/kepler/pkg/model/types"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components/source"
 )
 
 // The ratio features list follows this order
@@ -62,146 +61,151 @@ const (
 	PlatformIdlePower
 )
 
-// RatioPowerModel stores the feature samples of each container for prediction
+// RatioPowerModel stores the feature samples of each process for prediction
 // The feature will added ordered from cycles, instructions and cache-misses
 type RatioPowerModel struct {
-	NodeFeatureNames      []string
-	ContainerFeatureNames []string
+	NodeFeatureNames    []string
+	ProcessFeatureNames []string
 
-	containerFeatureValues [][]float64 // metrics per process/container/pod
-	nodeFeatureValues      []float64   // node metrics
+	processFeatureValues [][]float64 // metrics per process/process/pod
+	nodeFeatureValues    []float64   // node metrics
 	// xidx represents the features slide window position
 	xidx int
 }
 
-func (r *RatioPowerModel) getPowerByRatio(containerIdx, resUsageFeature, nodePowerFeature int, numContainers float64) float64 {
+func (r *RatioPowerModel) getPowerByRatio(processIdx, resUsageFeature, nodePowerFeature int, numProcesses float64) float64 {
 	var power float64
 	nodeResUsage := r.nodeFeatureValues[resUsageFeature]
 	nodePower := r.nodeFeatureValues[nodePowerFeature]
 	if nodeResUsage == 0 || resUsageFeature == int(UncoreUsageMetric) {
-		power = nodePower / numContainers
+		power = nodePower / numProcesses
 	} else {
-		containerResUsage := r.containerFeatureValues[containerIdx][resUsageFeature]
-		power = (containerResUsage / nodeResUsage) * nodePower
+		processResUsage := r.processFeatureValues[processIdx][resUsageFeature]
+		power = (processResUsage / nodeResUsage) * nodePower
 	}
+
 	return math.Ceil(power)
 }
 
 // GetPlatformPower applies ModelWeight prediction and return a list of total powers
 func (r *RatioPowerModel) GetPlatformPower(isIdlePower bool) ([]float64, error) {
-	var containerPlatformPower []float64
+	var processPlatformPower []float64
 
-	// the number of containers is used to evernly divide the power consumption for OTHER and UNCORE
+	// the number of processes is used to evernly divide the power consumption for OTHER and UNCORE
 	// we do not use CPU utilization for OTHER and UNCORE because they are not necessarily directly
-	numContainers := float64(r.xidx)
+	numProcesses := float64(r.xidx)
 
-	// estimate the power for each container
-	for containerIdx := 0; containerIdx < r.xidx; containerIdx++ {
-		var containerPower float64
+	// estimate the power for each process
+	for processIdx := 0; processIdx < r.xidx; processIdx++ {
+		var processPower float64
 		if isIdlePower {
-			// TODO: idle power should be divided accordinly to the container requested resource
-			containerPower = r.nodeFeatureValues[PlatformIdlePower] / numContainers
+			// TODO: idle power should be divided accordinly to the process requested resource
+			processPower = r.nodeFeatureValues[PlatformIdlePower] / numProcesses
 		} else {
-			containerPower = r.getPowerByRatio(containerIdx, int(PlatformUsageMetric), int(PlatformDynPower), numContainers)
+			processPower = r.getPowerByRatio(processIdx, int(PlatformUsageMetric), int(PlatformDynPower), numProcesses)
 		}
-		containerPlatformPower = append(containerPlatformPower, containerPower)
+		processPlatformPower = append(processPlatformPower, processPower)
 	}
-	return containerPlatformPower, nil
+	return processPlatformPower, nil
+}
+
+func uint64Division(x, y float64) uint64 {
+	return uint64(math.Ceil(x / y))
 }
 
 // GetComponentsPower applies each component's ModelWeight prediction and return a map of component powers
 func (r *RatioPowerModel) GetComponentsPower(isIdlePower bool) ([]source.NodeComponentsEnergy, error) {
-	nodeComponentsPowerOfAllContainers := []source.NodeComponentsEnergy{}
+	nodeComponentsPowerOfAllProcesses := []source.NodeComponentsEnergy{}
 
-	// the number of containers is used to evernly divide the power consumption for OTHER and UNCORE
+	// the number of processes is used to evernly divide the power consumption for OTHER and UNCORE
 	// we do not use CPU utilization for OTHER and UNCORE because they are not necessarily directly
-	numContainers := float64(r.xidx)
+	numProcesses := float64(r.xidx)
 
-	// estimate the power for each container
-	for containerIdx := 0; containerIdx < r.xidx; containerIdx++ {
-		var containerPower uint64
-		containerNodeComponentsPower := source.NodeComponentsEnergy{}
+	// estimate the power for each process
+	for processIdx := 0; processIdx < r.xidx; processIdx++ {
+		var processPower uint64
+		processNodeComponentsPower := source.NodeComponentsEnergy{}
 
 		// PKG power
-		// TODO: idle power should be divided accordinly to the container requested resource
+		// TODO: idle power should be divided accordinly to the process requested resource
 		if isIdlePower {
-			containerPower = uint64(r.nodeFeatureValues[PkgIdlePower] / numContainers)
+			processPower = uint64Division(r.nodeFeatureValues[PkgIdlePower], numProcesses)
 		} else {
-			containerPower = uint64(r.getPowerByRatio(containerIdx, int(PkgUsageMetric), int(PkgDynPower), numContainers))
+			processPower = uint64(r.getPowerByRatio(processIdx, int(PkgUsageMetric), int(PkgDynPower), numProcesses))
 		}
-		containerNodeComponentsPower.Pkg = containerPower
+		processNodeComponentsPower.Pkg = processPower
 
 		// CORE power
 		if isIdlePower {
-			containerPower = uint64(r.nodeFeatureValues[CoreIdlePower] / numContainers)
+			processPower = uint64Division(r.nodeFeatureValues[CoreIdlePower], numProcesses)
 		} else {
-			containerPower = uint64(r.getPowerByRatio(containerIdx, int(CoreUsageMetric), int(CoreDynPower), numContainers))
+			processPower = uint64(r.getPowerByRatio(processIdx, int(CoreUsageMetric), int(CoreDynPower), numProcesses))
 		}
-		containerNodeComponentsPower.Core = containerPower
+		processNodeComponentsPower.Core = processPower
 
 		// DRAM power
 		if isIdlePower {
-			containerPower = uint64(r.nodeFeatureValues[DramIdlePower] / numContainers)
+			processPower = uint64Division(r.nodeFeatureValues[DramIdlePower], numProcesses)
 		} else {
-			containerPower = uint64(r.getPowerByRatio(containerIdx, int(DramUsageMetric), int(DramDynPower), numContainers))
+			processPower = uint64(r.getPowerByRatio(processIdx, int(DramUsageMetric), int(DramDynPower), numProcesses))
 		}
-		containerNodeComponentsPower.DRAM = containerPower
+		processNodeComponentsPower.DRAM = processPower
 
 		// UNCORE power
 		if isIdlePower {
-			containerPower = uint64(r.nodeFeatureValues[UncoreIdlePower] / numContainers)
+			processPower = uint64Division(r.nodeFeatureValues[UncoreIdlePower], numProcesses)
 		} else {
-			containerPower = uint64(r.getPowerByRatio(containerIdx, int(UncoreUsageMetric), int(UncoreDynPower), numContainers))
+			processPower = uint64(r.getPowerByRatio(processIdx, int(UncoreUsageMetric), int(UncoreDynPower), numProcesses))
 		}
-		containerNodeComponentsPower.Uncore = containerPower
+		processNodeComponentsPower.Uncore = processPower
 
-		nodeComponentsPowerOfAllContainers = append(nodeComponentsPowerOfAllContainers, containerNodeComponentsPower)
+		nodeComponentsPowerOfAllProcesses = append(nodeComponentsPowerOfAllProcesses, processNodeComponentsPower)
 	}
-	return nodeComponentsPowerOfAllContainers, nil
+	return nodeComponentsPowerOfAllProcesses, nil
 }
 
-// GetComponentsPower returns GPU Power in Watts associated to each each process/container/pod
+// GetComponentsPower returns GPU Power in Watts associated to each each process/process/pod
 func (r *RatioPowerModel) GetGPUPower(isIdlePower bool) ([]float64, error) {
-	nodeComponentsPowerOfAllContainers := []float64{}
+	nodeComponentsPowerOfAllProcesses := []float64{}
 
-	// the number of containers is used to evernly divide the power consumption for OTHER and UNCORE
+	// the number of processes is used to evernly divide the power consumption for OTHER and UNCORE
 	// we do not use CPU utilization for OTHER and UNCORE because they are not necessarily directly
-	numContainers := float64(r.xidx)
+	numProcesses := float64(r.xidx)
 
-	// estimate the power for each container
-	for containerIdx := 0; containerIdx < r.xidx; containerIdx++ {
-		var containerPower float64
+	// estimate the power for each process
+	for processIdx := 0; processIdx < r.xidx; processIdx++ {
+		var processPower float64
 
-		// TODO: idle power should be divided accordinly to the container requested resource
+		// TODO: idle power should be divided accordinly to the process requested resource
 		if isIdlePower {
-			containerPower = r.nodeFeatureValues[GpuIdlePower] / numContainers
+			processPower = r.nodeFeatureValues[GpuIdlePower] / numProcesses
 		} else {
-			containerPower = r.getPowerByRatio(containerIdx, int(GpuUsageMetric), int(GpuDynPower), numContainers)
+			processPower = r.getPowerByRatio(processIdx, int(GpuUsageMetric), int(GpuDynPower), numProcesses)
 		}
-		nodeComponentsPowerOfAllContainers = append(nodeComponentsPowerOfAllContainers, containerPower)
+		nodeComponentsPowerOfAllProcesses = append(nodeComponentsPowerOfAllProcesses, processPower)
 	}
-	return nodeComponentsPowerOfAllContainers, nil
+	return nodeComponentsPowerOfAllProcesses, nil
 }
 
-// AddContainerFeatureValues adds the the x for prediction, which is the variable used to calculate the ratio.
+// AddProcessFeatureValues adds the the x for prediction, which is the variable used to calculate the ratio.
 // RatioPowerModel is not trained, then we cannot Add training samples, only samples for prediction.
-func (r *RatioPowerModel) AddContainerFeatureValues(x []float64) {
+func (r *RatioPowerModel) AddProcessFeatureValues(x []float64) {
 	for i, feature := range x {
-		// containerFeatureValues is a cyclic list, where we only append a new value if it is necessary.
-		if r.xidx < len(r.containerFeatureValues) {
-			if i < len(r.containerFeatureValues[r.xidx]) {
-				r.containerFeatureValues[r.xidx][i] = feature
+		// processFeatureValues is a cyclic list, where we only append a new value if it is necessary.
+		if r.xidx < len(r.processFeatureValues) {
+			if i < len(r.processFeatureValues[r.xidx]) {
+				r.processFeatureValues[r.xidx][i] = feature
 			} else {
-				r.containerFeatureValues[r.xidx] = append(r.containerFeatureValues[r.xidx], feature)
+				r.processFeatureValues[r.xidx] = append(r.processFeatureValues[r.xidx], feature)
 			}
 		} else {
-			// add new container
-			r.containerFeatureValues = append(r.containerFeatureValues, []float64{})
-			// add feature of new container
-			r.containerFeatureValues[r.xidx] = append(r.containerFeatureValues[r.xidx], feature)
+			// add new process
+			r.processFeatureValues = append(r.processFeatureValues, []float64{})
+			// add feature of new process
+			r.processFeatureValues[r.xidx] = append(r.processFeatureValues[r.xidx], feature)
 		}
 	}
-	r.xidx += 1 // mode pointer to next container
+	r.xidx += 1 // mode pointer to next process
 }
 
 // AddNodeFeatureValues adds the the x for prediction, which is the variable used to calculate the ratio.
@@ -241,12 +245,12 @@ func (r *RatioPowerModel) GetModelType() types.ModelType {
 	return types.Ratio
 }
 
-// GetcontainerFeatureNamesList returns the list of container features that the model was configured to use
-func (r *RatioPowerModel) GetContainerFeatureNamesList() []string {
-	return r.ContainerFeatureNames
+// GetProcessFeatureNamesList returns the list of process features that the model was configured to use
+func (r *RatioPowerModel) GetProcessFeatureNamesList() []string {
+	return r.ProcessFeatureNames
 }
 
-// GetNodeFeatureNamesList returns the list of container features that the model was configured to use
+// GetNodeFeatureNamesList returns the list of process features that the model was configured to use
 func (r *RatioPowerModel) GetNodeFeatureNamesList() []string {
 	return r.NodeFeatureNames
 }
diff --git a/pkg/model/estimator/local/ratio_model_test.go b/pkg/model/estimator/local/ratio_model_test.go
index 20d6d2e5a5..f45ccd688c 100644
--- a/pkg/model/estimator/local/ratio_model_test.go
+++ b/pkg/model/estimator/local/ratio_model_test.go
@@ -20,86 +20,41 @@ import (
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
-	"github.com/sustainable-computing-io/kepler/pkg/collector/metric/types"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
+	"github.com/sustainable-computing-io/kepler/pkg/utils"
 )
 
 var _ = Describe("Test Ratio Unit", func() {
-	It("GetContainerEnergyRatio", func() {
+	It("GetProcessEnergyRatio", func() {
+		stats.SetMockedCollectorMetrics()
+		processStats := stats.CreateMockedProcessStats(3)
 
-		containersMetrics := map[string]*collector_metric.ContainerMetrics{}
-		containersMetrics["containerA"] = collector_metric.NewContainerMetrics("containerA", "podA", "test", "containerA")
-		containersMetrics["containerA"].BPFStats[config.CoreUsageMetric] = &types.UInt64Stat{}
-		err := containersMetrics["containerA"].BPFStats[config.CoreUsageMetric].AddNewDelta(30000)
-		Expect(err).NotTo(HaveOccurred())
-		containersMetrics["containerB"] = collector_metric.NewContainerMetrics("containerB", "podB", "test", "containerB")
-		containersMetrics["containerB"].BPFStats[config.CoreUsageMetric] = &types.UInt64Stat{}
-		err = containersMetrics["containerB"].BPFStats[config.CoreUsageMetric].AddNewDelta(30000)
-		Expect(err).NotTo(HaveOccurred())
-		containersMetrics["containerC"] = collector_metric.NewContainerMetrics("containerC", "podC", "test", "containerC")
-		containersMetrics["containerC"].BPFStats[config.CoreUsageMetric] = &types.UInt64Stat{}
-		err = containersMetrics["containerC"].BPFStats[config.CoreUsageMetric].AddNewDelta(30000)
-		Expect(err).NotTo(HaveOccurred())
+		nodeStats := stats.CreateMockedNodeStats()
+		Expect(nodeStats.EnergyUsage[config.DynEnergyInPkg].SumAllDeltaValues()).Should(BeEquivalentTo(35000))
+		Expect(nodeStats.EnergyUsage[config.DynEnergyInCore].SumAllDeltaValues()).Should(BeEquivalentTo(35000))
+		Expect(nodeStats.EnergyUsage[config.DynEnergyInUnCore].SumAllDeltaValues()).Should(BeEquivalentTo(0))
+		Expect(nodeStats.EnergyUsage[config.DynEnergyInDRAM].SumAllDeltaValues()).Should(BeEquivalentTo(35000))
+		Expect(nodeStats.EnergyUsage[config.DynEnergyInPlatform].SumAllDeltaValues()).Should(BeEquivalentTo(35000))
 
-		nodeMetrics := collector_metric.NewNodeMetrics()
-		collector_metric.ContainerFeaturesNames = []string{config.CoreUsageMetric}
-		collector_metric.NodeMetadataFeatureNames = []string{"cpu_architecture"}
-		collector_metric.NodeMetadataFeatureValues = []string{"Sandy Bridge"}
-		nodeMetrics.AddNodeResUsageFromContainerResUsage(containersMetrics)
-		Expect(nodeMetrics.ResourceUsage[config.CoreUsageMetric]).Should(BeEquivalentTo(90000))
+		for _, pMetric := range processStats {
+			val := pMetric.ResourceUsage[config.CPUCycle].Stat[stats.MockedSocketID].GetDelta()
+			nodeStats.ResourceUsage[config.CPUCycle].AddDeltaStat(stats.MockedSocketID, val)
 
-		// manually add node mock values
-		// initialize the node energy with aggregated energy, which will be used to calculate delta energy
-		nodePlatformEnergy := map[string]float64{}
-		// initialize the node energy with aggregated energy, which will be used to calculate delta energy
-		nodePlatformEnergy["sensor0"] = 5000 // mJ
-		nodeMetrics.SetNodePlatformEnergy(nodePlatformEnergy, true, false)
-		nodeMetrics.UpdateIdleEnergyWithMinValue(true)
-		// the second node energy will represent the idle and dynamic power. The idle power is only calculated after there at at least two delta values
-		nodePlatformEnergy["sensor0"] = 35000
-		nodeMetrics.SetNodePlatformEnergy(nodePlatformEnergy, true, false)
-		nodeMetrics.UpdateDynEnergy()
+			val = pMetric.ResourceUsage[config.CPUInstruction].Stat[stats.MockedSocketID].GetDelta()
+			nodeStats.ResourceUsage[config.CPUInstruction].AddDeltaStat(stats.MockedSocketID, val)
 
-		// initialize the node energy with aggregated energy, which will be used to calculate delta energy
-		// note that NodeComponentsEnergy contains aggregated energy over time
-		componentsEnergies := make(map[int]source.NodeComponentsEnergy)
-		componentsEnergies[0] = source.NodeComponentsEnergy{
-			Pkg:    5000, // mJ
-			Core:   5000,
-			DRAM:   5000,
-			Uncore: 5000,
-		}
-		nodeMetrics.SetNodeComponentsEnergy(componentsEnergies, false, false)
-		componentsEnergies[0] = source.NodeComponentsEnergy{
-			Pkg:    10000, // mJ
-			Core:   10000,
-			DRAM:   10000,
-			Uncore: 10000,
-		}
-		// the second node energy will force to calculate a delta. The delta is calculates after added at least two aggregated metric
-		nodeMetrics.SetNodeComponentsEnergy(componentsEnergies, false, false)
-		nodeMetrics.UpdateIdleEnergyWithMinValue(true)
-		// the third node energy will represent the idle and dynamic power. The idle power is only calculated after there at at least two delta values
-		componentsEnergies[0] = source.NodeComponentsEnergy{
-			Pkg:    45000, // 35000mJ delta, which is 5000mJ idle, 30000mJ dynamic power
-			Core:   45000,
-			DRAM:   45000,
-			Uncore: 45000,
-		}
-		nodeMetrics.SetNodeComponentsEnergy(componentsEnergies, false, false)
-		nodeMetrics.UpdateDynEnergy()
+			val = pMetric.ResourceUsage[config.CacheMiss].Stat[stats.MockedSocketID].GetDelta()
+			nodeStats.ResourceUsage[config.CacheMiss].AddDeltaStat(stats.MockedSocketID, val)
 
-		Expect(nodeMetrics.GetSumDeltaDynEnergyFromAllSources(collector_metric.PKG)).Should(BeEquivalentTo(30000))
-		Expect(nodeMetrics.GetSumDeltaDynEnergyFromAllSources(collector_metric.CORE)).Should(BeEquivalentTo(30000))
-		Expect(nodeMetrics.GetSumDeltaDynEnergyFromAllSources(collector_metric.UNCORE)).Should(BeEquivalentTo(30000))
-		Expect(nodeMetrics.GetSumDeltaDynEnergyFromAllSources(collector_metric.DRAM)).Should(BeEquivalentTo(30000))
-		Expect(nodeMetrics.GetSumDeltaDynEnergyFromAllSources(collector_metric.PLATFORM)).Should(BeEquivalentTo(30000))
+			val = pMetric.ResourceUsage[config.CPUTime].Stat[stats.MockedSocketID].GetDelta()
+			nodeStats.ResourceUsage[config.CPUTime].AddDeltaStat(stats.MockedSocketID, val)
+		}
+		Expect(nodeStats.ResourceUsage[config.CoreUsageMetric].Stat[utils.GenericSocketID].GetDelta()).Should(BeEquivalentTo(90000))
 
 		// The default estimator model is the ratio
 		model := RatioPowerModel{
-			ContainerFeatureNames: []string{
+			ProcessFeatureNames: []string{
 				config.CoreUsageMetric,    // for PKG resource usage
 				config.CoreUsageMetric,    // for CORE resource usage
 				config.DRAMUsageMetric,    // for DRAM resource usage
@@ -108,50 +63,51 @@ var _ = Describe("Test Ratio Unit", func() {
 				config.GpuUsageMetric,     // for GPU resource usage
 			},
 			NodeFeatureNames: []string{
-				config.CoreUsageMetric,                          // for PKG resource usage
-				config.CoreUsageMetric,                          // for CORE resource usage
-				config.DRAMUsageMetric,                          // for DRAM resource usage
-				config.GeneralUsageMetric,                       // for UNCORE resource usage
-				config.GeneralUsageMetric,                       // for OTHER resource usage
-				config.GpuUsageMetric,                           // for GPU resource usage
-				collector_metric.PKG + collector_metric.DYN,     // for dynamic PKG power consumption
-				collector_metric.CORE + collector_metric.DYN,    // for dynamic CORE power consumption
-				collector_metric.DRAM + collector_metric.DYN,    // for dynamic PKG power consumption
-				collector_metric.UNCORE + collector_metric.DYN,  // for dynamic UNCORE power consumption
-				collector_metric.OTHER + collector_metric.DYN,   // for dynamic OTHER power consumption
-				collector_metric.GPU + collector_metric.DYN,     // for dynamic GPU power consumption
-				collector_metric.PKG + collector_metric.IDLE,    // for idle PKG power consumption
-				collector_metric.CORE + collector_metric.IDLE,   // for idle CORE power consumption
-				collector_metric.DRAM + collector_metric.IDLE,   // for idle PKG power consumption
-				collector_metric.UNCORE + collector_metric.IDLE, // for idle UNCORE power consumption
-				collector_metric.OTHER + collector_metric.IDLE,  // for idle OTHER power consumption
-				collector_metric.GPU + collector_metric.IDLE,    // for idle GPU power consumption
+				config.CoreUsageMetric,    // for PKG resource usage
+				config.CoreUsageMetric,    // for CORE resource usage
+				config.DRAMUsageMetric,    // for DRAM resource usage
+				config.GeneralUsageMetric, // for UNCORE resource usage
+				config.GeneralUsageMetric, // for OTHER resource usage
+				config.GpuUsageMetric,     // for GPU resource usage
+				config.DynEnergyInPkg,     // for dynamic PKG power consumption
+				config.DynEnergyInCore,    // for dynamic CORE power consumption
+				config.DynEnergyInDRAM,    // for dynamic PKG power consumption
+				config.DynEnergyInUnCore,  // for dynamic UNCORE power consumption
+				config.DynEnergyInOther,   // for dynamic OTHER power consumption
+				config.DynEnergyInGPU,     // for dynamic GPU power consumption
+				config.IdleEnergyInPkg,    // for idle PKG power consumption
+				config.IdleEnergyInCore,   // for idle CORE power consumption
+				config.IdleEnergyInDRAM,   // for idle PKG power consumption
+				config.IdleEnergyInUnCore, // for idle UNCORE power consumption
+				config.IdleEnergyInOther,  // for idle OTHER power consumption
+				config.IdleEnergyInGPU,    // for idle GPU power consumption
 			},
 		}
 		model.ResetSampleIdx()
-		// Add container metrics
-		for _, c := range containersMetrics {
+		// Add process metrics
+		for _, c := range processStats {
 			// add samples to estimate the components (CPU and DRAM) power
 			if model.IsEnabled() {
-				// Add container metrics
-				featureValues := c.ToEstimatorValues(model.GetContainerFeatureNamesList(), true) // add node features with normalized values
-				model.AddContainerFeatureValues(featureValues)
+				// Add process metrics
+				featureValues := c.ToEstimatorValues(model.GetProcessFeatureNamesList(), true) // add node features with normalized values
+				model.AddProcessFeatureValues(featureValues)
 			}
 		}
 		// Add node metrics.
 		if model.IsEnabled() {
-			featureValues := nodeMetrics.ToEstimatorValues(model.GetNodeFeatureNamesList(), true) // add node features with normalized values
+			featureValues := nodeStats.ToEstimatorValues(model.GetNodeFeatureNamesList(), true) // add node features with normalized values
 			model.AddNodeFeatureValues(featureValues)
 		}
 
-		containerPower, err := model.GetComponentsPower(false)
+		processPower, err := model.GetComponentsPower(false)
 		Expect(err).NotTo(HaveOccurred())
 
-		// The node energy consumption was manually set as 30J (30000mJ), but since the interval is 3s, the power is 10J
-		// There are 3 containers consuming 30000 ns, but since the interval is 3s, the normalized utilization is 10ms
-		// Then, the container resource usage ratio will be 0.3334. Consequently, the container power will be 0.3334 * the node power (10000mJ) = 3334
-		Expect(containerPower[0].Pkg).Should(BeEquivalentTo(uint64(3334)))
-		Expect(containerPower[1].Pkg).Should(BeEquivalentTo(uint64(3334)))
-		Expect(containerPower[2].Pkg).Should(BeEquivalentTo(uint64(3334)))
+		// The node energy consumption was manually set as 35J (35000mJ), but since the interval is 3s, the power is 11667mJ
+		// There are 3 processes consuming 30000ns, but since the interval is 3s, the normalized utilization is 10ms
+		// Then, the process resource usage ratio will be 0.3334. Consequently, the process power will be 0.3334 * the node power (11667mJ) = 3334
+		// Which is 3889mJ
+		Expect(processPower[0].Pkg).Should(BeEquivalentTo(uint64(3889)))
+		Expect(processPower[1].Pkg).Should(BeEquivalentTo(uint64(3889)))
+		Expect(processPower[2].Pkg).Should(BeEquivalentTo(uint64(3889)))
 	})
 })
diff --git a/pkg/model/estimator/local/ratio_process.go b/pkg/model/estimator/local/ratio_process.go
deleted file mode 100644
index 906c21db0d..0000000000
--- a/pkg/model/estimator/local/ratio_process.go
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
-Copyright 2023.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-/*
-ratio.go
-calculate Processs' component and other power by ratio approach when node power is available.
-*/
-
-//nolint:dupl // the ratio process should be removed
-package local
-
-import (
-	"math"
-
-	"github.com/sustainable-computing-io/kepler/pkg/model/types"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
-)
-
-const MaxProcesss = 2000
-
-// RatioProcessPowerModel stores the feature samples of each process for prediction
-// The feature will added ordered from cycles, instructions and cache-misses
-type RatioProcessPowerModel struct {
-	NodeFeatureNames    []string
-	ProcessFeatureNames []string
-
-	processFeatureValues [][]float64 // metrics per process/process/pod
-	nodeFeatureValues    []float64   // metrics per process/process/pod
-	// xidx represents the features slide window position
-	xidx int
-}
-
-func (r *RatioProcessPowerModel) getPowerByRatio(processIdx, resUsageFeature, nodePowerFeature int, numProcesss float64) float64 {
-	var power float64
-	nodeResUsage := r.nodeFeatureValues[resUsageFeature]
-	nodePower := r.nodeFeatureValues[nodePowerFeature]
-	if nodeResUsage == 0 || resUsageFeature == int(UncoreUsageMetric) {
-		power = nodePower / numProcesss
-	} else {
-		processResUsage := r.processFeatureValues[processIdx][resUsageFeature]
-		power = (processResUsage / nodeResUsage) * nodePower
-	}
-	return math.Ceil(power)
-}
-
-// GetPlatformPower applies ModelWeight prediction and return a list of total powers
-func (r *RatioProcessPowerModel) GetPlatformPower(isIdlePower bool) ([]float64, error) {
-	var processPlatformPower []float64
-
-	// the number of processes is used to evernly divide the power consumption for OTHER and UNCORE
-	// we do not use CPU utilization for OTHER and UNCORE because they are not necessarily directly
-	numProcesss := float64(r.xidx)
-
-	// estimate the power for each process
-	for processIdx := 0; processIdx < r.xidx; processIdx++ {
-		var processPower float64
-		if isIdlePower {
-			// TODO: idle power should be divided accordinly to the process requested resource
-			processPower = r.nodeFeatureValues[PlatformIdlePower] / numProcesss
-		} else {
-			processPower = r.getPowerByRatio(processIdx, int(PlatformUsageMetric), int(PlatformDynPower), numProcesss)
-		}
-		processPlatformPower = append(processPlatformPower, processPower)
-	}
-	return processPlatformPower, nil
-}
-
-// GetComponentsPower applies each component's ModelWeight prediction and return a map of component powers
-func (r *RatioProcessPowerModel) GetComponentsPower(isIdlePower bool) ([]source.NodeComponentsEnergy, error) {
-	nodeComponentsPowerOfAllProcesss := []source.NodeComponentsEnergy{}
-
-	// the number of processes is used to evernly divide the power consumption for OTHER and UNCORE
-	// we do not use CPU utilization for OTHER and UNCORE because they are not necessarily directly
-	numProcesss := float64(r.xidx)
-
-	// estimate the power for each process
-	for processIdx := 0; processIdx < r.xidx; processIdx++ {
-		var processPower uint64
-		processNodeComponentsPower := source.NodeComponentsEnergy{}
-
-		// PKG power
-		// TODO: idle power should be divided accordinly to the process requested resource
-		if isIdlePower {
-			processPower = uint64(r.nodeFeatureValues[PkgIdlePower] / numProcesss)
-		} else {
-			processPower = uint64(r.getPowerByRatio(processIdx, int(PkgUsageMetric), int(PkgDynPower), numProcesss))
-		}
-		processNodeComponentsPower.Pkg = processPower
-
-		// CORE power
-		if isIdlePower {
-			processPower = uint64(r.nodeFeatureValues[CoreIdlePower] / numProcesss)
-		} else {
-			processPower = uint64(r.getPowerByRatio(processIdx, int(CoreUsageMetric), int(CoreDynPower), numProcesss))
-		}
-		processNodeComponentsPower.Core = processPower
-
-		// DRAM power
-		if isIdlePower {
-			processPower = uint64(r.nodeFeatureValues[DramIdlePower] / numProcesss)
-		} else {
-			processPower = uint64(r.getPowerByRatio(processIdx, int(DramUsageMetric), int(DramDynPower), numProcesss))
-		}
-		processNodeComponentsPower.DRAM = processPower
-
-		// UNCORE power
-		if isIdlePower {
-			processPower = uint64(r.nodeFeatureValues[UncoreIdlePower] / numProcesss)
-		} else {
-			processPower = uint64(r.getPowerByRatio(processIdx, int(UncoreUsageMetric), int(UncoreDynPower), numProcesss))
-		}
-		processNodeComponentsPower.Uncore = processPower
-
-		nodeComponentsPowerOfAllProcesss = append(nodeComponentsPowerOfAllProcesss, processNodeComponentsPower)
-	}
-	return nodeComponentsPowerOfAllProcesss, nil
-}
-
-// GetComponentsPower returns GPU Power in Watts associated to each each process/process/pod
-func (r *RatioProcessPowerModel) GetGPUPower(isIdlePower bool) ([]float64, error) {
-	nodeComponentsPowerOfAllProcesss := []float64{}
-
-	// the number of processes is used to evernly divide the power consumption for OTHER and UNCORE
-	// we do not use CPU utilization for OTHER and UNCORE because they are not necessarily directly
-	numProcesss := float64(r.xidx)
-
-	// estimate the power for each process
-	for processIdx := 0; processIdx < r.xidx; processIdx++ {
-		var processPower float64
-
-		// TODO: idle power should be divided accordinly to the process requested resource
-		if isIdlePower {
-			processPower = r.nodeFeatureValues[GpuIdlePower] / numProcesss
-		} else {
-			processPower = r.getPowerByRatio(processIdx, int(GpuUsageMetric), int(GpuDynPower), numProcesss)
-		}
-		nodeComponentsPowerOfAllProcesss = append(nodeComponentsPowerOfAllProcesss, processPower)
-	}
-	return nodeComponentsPowerOfAllProcesss, nil
-}
-
-// AddProcessFeatureValues adds the the x for prediction, which is the variable used to calculate the ratio.
-// RatioProcessPowerModel is not trained, then we cannot Add training samples, only samples for prediction.
-func (r *RatioProcessPowerModel) AddProcessFeatureValues(x []float64) {
-	for i, feature := range x {
-		// processFeatureValues is a cyclic list, where we only append a new value if it is necessary.
-		if r.xidx < len(r.processFeatureValues) {
-			if i < len(r.processFeatureValues[r.xidx]) {
-				r.processFeatureValues[r.xidx][i] = feature
-			} else {
-				r.processFeatureValues[r.xidx] = append(r.processFeatureValues[r.xidx], feature)
-			}
-		} else {
-			// add new process
-			r.processFeatureValues = append(r.processFeatureValues, []float64{})
-			// add feature of new process
-			r.processFeatureValues[r.xidx] = append(r.processFeatureValues[r.xidx], feature)
-		}
-	}
-	r.xidx += 1 // mode pointer to next process
-}
-
-// AddNodeFeatureValues adds the the x for prediction, which is the variable used to calculate the ratio.
-// RatioProcessPowerModel is not trained, then we cannot Add training samples, only samples for prediction.
-func (r *RatioProcessPowerModel) AddNodeFeatureValues(x []float64) {
-	for i, feature := range x {
-		if i < len(r.nodeFeatureValues) {
-			r.nodeFeatureValues[i] = feature
-		} else {
-			r.nodeFeatureValues = append(r.nodeFeatureValues, feature)
-		}
-	}
-}
-
-// AddDesiredOutValue adds the the y, which is the response variable (or the dependent variable) of regression.
-// RatioProcessPowerModel is not trained, then we cannot Add training samples.
-func (r *RatioProcessPowerModel) AddDesiredOutValue(y float64) {
-}
-
-// ResetSampleIdx set the sample vector index to 0 to overwrite the old samples with new ones for trainning or prediction.
-func (r *RatioProcessPowerModel) ResetSampleIdx() {
-	r.xidx = 0
-	// reset the list if the size is very high to avoid use too much memory
-	// we should not reset the list too often to do not put pressure in the garbage collector
-	if len(r.processFeatureValues) > MaxProcesss {
-		r.processFeatureValues = [][]float64{}
-	}
-}
-
-// RatioProcessPowerModel is not trained, then this function does nothing.
-func (r *RatioProcessPowerModel) Train() error {
-	return nil
-}
-
-// IsEnabled returns true as Ratio Power model is always active
-func (r *RatioProcessPowerModel) IsEnabled() bool {
-	return true
-}
-
-// GetModelType returns the model type
-func (r *RatioProcessPowerModel) GetModelType() types.ModelType {
-	return types.Ratio
-}
-
-// GetprocessFeatureNamesList returns the list of process features that the model was configured to use
-func (r *RatioProcessPowerModel) GetProcessFeatureNamesList() []string {
-	return r.ProcessFeatureNames
-}
-
-// GetNodeFeatureNamesList returns the list of process features that the model was configured to use
-func (r *RatioProcessPowerModel) GetNodeFeatureNamesList() []string {
-	return r.NodeFeatureNames
-}
diff --git a/pkg/model/estimator/sidecar/estimate.go b/pkg/model/estimator/sidecar/estimate.go
index a13a35b3ad..2e1db03225 100644
--- a/pkg/model/estimator/sidecar/estimate.go
+++ b/pkg/model/estimator/sidecar/estimate.go
@@ -26,15 +26,14 @@ import (
 	"fmt"
 	"net"
 
+	"github.com/sustainable-computing-io/kepler/pkg/config"
 	"github.com/sustainable-computing-io/kepler/pkg/model/types"
 	"github.com/sustainable-computing-io/kepler/pkg/model/utils"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components/source"
 	"k8s.io/klog/v2"
-
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
 )
 
-const MaxContainers = 500 // 256 pods and 2 containers per pod
+const MaxProcesss = 500 // 256 pods and 2 processes per pod
 
 // PowerRequest defines a request to Kepler Estimator to get estimated powers
 type PowerRequest struct {
@@ -72,11 +71,11 @@ type EstimatorSidecar struct {
 	SystemMetaDataFeatureNames  []string
 	SystemMetaDataFeatureValues []string
 
-	floatFeatureValues [][]float64 // metrics per process/container/pod/node
+	floatFeatureValues [][]float64 // metrics per process/process/pod/node
 	// idle power is calculated with the minimal resource utilization, which means that the system is at rest
 	// due to performance reasons, we keep a shadow copy of the floatFeatureValues with 1 values
-	floatFeatureValuesForIdlePower [][]float64 // metrics per process/container/pod/node
-	// xidx represents the instance slide window position, where an instance can be process/container/pod/node
+	floatFeatureValuesForIdlePower [][]float64 // metrics per process/process/pod/node
+	// xidx represents the instance slide window position, where an instance can be process/process/pod/node
 	xidx int
 
 	enabled bool
@@ -160,8 +159,8 @@ func (c *EstimatorSidecar) GetPlatformPower(isIdlePower bool) ([]float64, error)
 	if len(power) == 0 {
 		return []float64{}, err
 	}
-	if powers, found := power[collector_metric.PLATFORM]; !found {
-		return []float64{}, fmt.Errorf("not found %s in response %v", collector_metric.PLATFORM, power)
+	if powers, found := power[config.PLATFORM]; !found {
+		return []float64{}, fmt.Errorf("not found %s in response %v", config.PLATFORM, power)
 	} else {
 		return powers, nil
 	}
@@ -181,26 +180,26 @@ func (c *EstimatorSidecar) GetComponentsPower(isIdlePower bool) ([]source.NodeCo
 		return []source.NodeComponentsEnergy{}, err
 	}
 	power := compPowers.(map[string][]float64)
-	num := 0 // number of processes/containers/pods
+	num := 0 // number of processes
 	for _, vals := range power {
-		// the vals list has one entry of the predicted value for each container
+		// the vals list has one entry of the predicted value for each process
 		num = len(vals)
 		break
 	}
 	nodeComponentsPower := make([]source.NodeComponentsEnergy, num)
 
 	for index := 0; index < num; index++ {
-		pkgPower := utils.GetComponentPower(power, collector_metric.PKG, index)
-		corePower := utils.GetComponentPower(power, collector_metric.CORE, index)
-		uncorePower := utils.GetComponentPower(power, collector_metric.UNCORE, index)
-		dramPower := utils.GetComponentPower(power, collector_metric.DRAM, index)
+		pkgPower := utils.GetComponentPower(power, config.PKG, index)
+		corePower := utils.GetComponentPower(power, config.CORE, index)
+		uncorePower := utils.GetComponentPower(power, config.UNCORE, index)
+		dramPower := utils.GetComponentPower(power, config.DRAM, index)
 		nodeComponentsPower[index] = utils.FillNodeComponentsPower(pkgPower, corePower, uncorePower, dramPower)
 	}
 
 	return nodeComponentsPower, err
 }
 
-// GetComponentsPower returns GPU Power in Watts associated to each each process/container/pod
+// GetComponentsPower returns GPU Power in Watts associated to each each process/process/pod
 func (c *EstimatorSidecar) GetGPUPower(isIdlePower bool) ([]float64, error) {
 	return []float64{}, fmt.Errorf("current power model does not support GPUs")
 }
@@ -217,27 +216,27 @@ func (c *EstimatorSidecar) addFloatFeatureValues(x []float64) {
 				c.floatFeatureValuesForIdlePower[c.xidx] = append(c.floatFeatureValuesForIdlePower[c.xidx], 0)
 			}
 		} else {
-			// add new container
+			// add new process
 			c.floatFeatureValues = append(c.floatFeatureValues, []float64{})
 			c.floatFeatureValuesForIdlePower = append(c.floatFeatureValuesForIdlePower, []float64{})
-			// add feature of new container
+			// add feature of new process
 			c.floatFeatureValues[c.xidx] = append(c.floatFeatureValues[c.xidx], feature)
 			c.floatFeatureValuesForIdlePower[c.xidx] = append(c.floatFeatureValuesForIdlePower[c.xidx], 0)
 		}
 	}
-	c.xidx += 1 // mode pointer to next container
+	c.xidx += 1 // mode pointer to next process
 }
 
-// AddContainerFeatureValues adds the the x for prediction, which are the explanatory variables (or the independent variable) of regression.
+// AddProcessFeatureValues adds the the x for prediction, which are the explanatory variables (or the independent variable) of regression.
 // EstimatorSidecar is trained off-line then we cannot Add training samples. We might implement it in the future.
-// The EstimatorSidecar does not differentiate node or container power estimation, the difference will only be the amount of resource utilization
-func (c *EstimatorSidecar) AddContainerFeatureValues(x []float64) {
+// The EstimatorSidecar does not differentiate node or process power estimation, the difference will only be the amount of resource utilization
+func (c *EstimatorSidecar) AddProcessFeatureValues(x []float64) {
 	c.addFloatFeatureValues(x)
 }
 
 // AddNodeFeatureValues adds the the x for prediction, which is the variable used to calculate the ratio.
 // EstimatorSidecar is not trained, then we cannot Add training samples, only samples for prediction.
-// The EstimatorSidecar does not differentiate node or container power estimation, the difference will only be the amount of resource utilization
+// The EstimatorSidecar does not differentiate node or process power estimation, the difference will only be the amount of resource utilization
 func (c *EstimatorSidecar) AddNodeFeatureValues(x []float64) {
 	c.addFloatFeatureValues(x)
 }
@@ -268,14 +267,14 @@ func (c *EstimatorSidecar) GetModelType() types.ModelType {
 	return types.EstimatorSidecar
 }
 
-// GetContainerFeatureNamesList returns the list of float features that the model was configured to use
-// The EstimatorSidecar does not differentiate node or container power estimation, the difference will only be the amount of resource utilization
-func (c *EstimatorSidecar) GetContainerFeatureNamesList() []string {
+// GetProcessFeatureNamesList returns the list of float features that the model was configured to use
+// The EstimatorSidecar does not differentiate node or process power estimation, the difference will only be the amount of resource utilization
+func (c *EstimatorSidecar) GetProcessFeatureNamesList() []string {
 	return c.FloatFeatureNames
 }
 
 // GetNodeFeatureNamesList returns the list of float features that the model was configured to use
-// The EstimatorSidecar does not differentiate node or container power estimation, the difference will only be the amount of resource utilization
+// The EstimatorSidecar does not differentiate node or process power estimation, the difference will only be the amount of resource utilization
 func (c *EstimatorSidecar) GetNodeFeatureNamesList() []string {
 	return c.FloatFeatureNames
 }
diff --git a/pkg/model/estimator/sidecar/estimate_test.go b/pkg/model/estimator/sidecar/estimate_test.go
index bc7d0f565b..9183f07e5f 100644
--- a/pkg/model/estimator/sidecar/estimate_test.go
+++ b/pkg/model/estimator/sidecar/estimate_test.go
@@ -24,7 +24,6 @@ import (
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
 	"github.com/sustainable-computing-io/kepler/pkg/model/types"
 )
@@ -32,7 +31,7 @@ import (
 var (
 	SampleDynEnergyValue float64 = 100000 // 100 mJ
 
-	containerFeatureNames = []string{
+	processFeatureNames = []string{
 		config.CPUCycle,
 		config.CPUInstruction,
 		config.CacheMiss,
@@ -45,14 +44,12 @@ var (
 		config.CgroupfsReadIO,
 		config.CgroupfsWriteIO,
 		config.BlockDevicesIO,
-		config.KubeletCPUUsage,
-		config.KubeletMemoryUsage,
 	}
 	systemMetaDataFeatureNames = []string{"cpu_architecture"}
-	featureNames               = append(containerFeatureNames, systemMetaDataFeatureNames...) // to predict node power, we will need the resource usage and metadata metrics
-	containerFeatureValues     = [][]float64{
-		{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, // container A
-		{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, // container B
+	featureNames               = append(processFeatureNames, systemMetaDataFeatureNames...) // to predict node power, we will need the resource usage and metadata metrics
+	processFeatureValues       = [][]float64{
+		{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, // process A
+		{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, // process B
 	}
 	nodeFeatureValues           = []float64{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}
 	systemMetaDataFeatureValues = []string{"Sandy Bridge"}
@@ -105,12 +102,12 @@ func dummyEstimator(serveSocket string, start, quit chan bool) {
 		var powerResponse ComponentPowerResponse
 		if powerRequest.EnergySource == types.ComponentEnergySource {
 			powerResponse = ComponentPowerResponse{
-				Powers:  map[string][]float64{collector_metric.PKG: powers},
+				Powers:  map[string][]float64{config.PKG: powers},
 				Message: msg,
 			}
 		} else {
 			powerResponse = ComponentPowerResponse{
-				Powers:  map[string][]float64{collector_metric.PLATFORM: powers},
+				Powers:  map[string][]float64{config.PLATFORM: powers},
 				Message: msg,
 			}
 		}
@@ -158,7 +155,7 @@ var _ = Describe("Test Estimate Unit", func() {
 		quit <- true
 	})
 
-	It("Get Container Platform Power By Sidecar Estimator", func() {
+	It("Get Process Platform Power By Sidecar Estimator", func() {
 		serveSocket := "/tmp/pod-total-power.sock"
 		start := make(chan bool)
 		quit := make(chan bool)
@@ -170,12 +167,12 @@ var _ = Describe("Test Estimate Unit", func() {
 		err := c.Start()
 		Expect(err).To(BeNil())
 		c.ResetSampleIdx()
-		for _, containerFeatureValues := range containerFeatureValues {
-			c.AddContainerFeatureValues(containerFeatureValues) // add samples to the power model
+		for _, processFeatureValues := range processFeatureValues {
+			c.AddProcessFeatureValues(processFeatureValues) // add samples to the power model
 		}
 		powers, err := c.GetPlatformPower(false)
 		Expect(err).NotTo(HaveOccurred())
-		Expect(len(powers)).Should(Equal(len(containerFeatureValues)))
+		Expect(len(powers)).Should(Equal(len(processFeatureValues)))
 		Expect(powers[0]).Should(Equal(SampleDynEnergyValue))
 		quit <- true
 	})
@@ -202,7 +199,7 @@ var _ = Describe("Test Estimate Unit", func() {
 		// 	"We are skiping this test until the power model is fixed.",
 		// Expect(powers[0].Pkg).Should(Equal(uint64(100000000)))
 	})
-	It("Get Container Component Power By Sidecar Estimator", func() {
+	It("Get Process Component Power By Sidecar Estimator", func() {
 		serveSocket := "/tmp/pod-comp-power.sock"
 		start := make(chan bool)
 		quit := make(chan bool)
@@ -214,13 +211,13 @@ var _ = Describe("Test Estimate Unit", func() {
 		err := c.Start()
 		Expect(err).To(BeNil())
 		c.ResetSampleIdx()
-		for _, containerFeatureValues := range containerFeatureValues {
-			c.AddContainerFeatureValues(containerFeatureValues) // add samples to the power model
+		for _, processFeatureValues := range processFeatureValues {
+			c.AddProcessFeatureValues(processFeatureValues) // add samples to the power model
 		}
 		powers, err := c.GetComponentsPower(false)
 		quit <- true
 		Expect(err).NotTo(HaveOccurred())
-		Expect(len(powers)).Should(Equal(len(containerFeatureValues)))
+		Expect(len(powers)).Should(Equal(len(processFeatureValues)))
 		// "The estimator node pkg power estimation is estimating 100 Kilo Joules or 0 Joules, " +
 		// 	"which is way to high or too low for the given resource utilization is set to only 1 in all features." +
 		// 	"We are skiping this test until the power model is fixed.",
diff --git a/pkg/model/model.go b/pkg/model/model.go
index e7257ef6b4..ee63a6eea5 100644
--- a/pkg/model/model.go
+++ b/pkg/model/model.go
@@ -24,7 +24,7 @@ import (
 	"github.com/sustainable-computing-io/kepler/pkg/model/estimator/local"
 	"github.com/sustainable-computing-io/kepler/pkg/model/estimator/sidecar"
 	"github.com/sustainable-computing-io/kepler/pkg/model/types"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components/source"
 	"k8s.io/klog/v2"
 )
 
@@ -41,9 +41,9 @@ var (
 
 // PowerMoldelInterface defines the power model sckeleton
 type PowerMoldelInterface interface {
-	// AddContainerFeatureValues adds the new x as a point for trainning or prediction. Where x are explanatory variable (or the independent variable).
+	// AddProcessFeatureValues adds the new x as a point for trainning or prediction. Where x are explanatory variable (or the independent variable).
 	// x values are added to a sliding window with circular list for dynamic data flow
-	AddContainerFeatureValues(x []float64)
+	AddProcessFeatureValues(x []float64)
 	// AddNodeFeatureValues adds the new x as a point for trainning or prediction. Where x are explanatory variable (or the independent variable).
 	AddNodeFeatureValues(x []float64)
 	// AddDesiredOutValue adds the new y as a point for trainning. Where y the response variable (or the dependent variable).
@@ -56,29 +56,29 @@ type PowerMoldelInterface interface {
 	IsEnabled() bool
 	// GetModelType returns if the model is Ratio, LinearRegressor or EstimatorSidecar
 	GetModelType() types.ModelType
-	// GetContainerFeatureNamesList returns the list of container features that the model was configured to use
-	GetContainerFeatureNamesList() []string
+	// GetProcessFeatureNamesList returns the list of process features that the model was configured to use
+	GetProcessFeatureNamesList() []string
 	// GetNodeFeatureNamesList returns the list of node features that the model was configured to use
 	GetNodeFeatureNamesList() []string
-	// GetPlatformPower returns the total Platform Power in Watts associated to each process/container/pod
+	// GetPlatformPower returns the total Platform Power in Watts associated to each process/process/pod
 	// If isIdlePower is true, return the idle power, otherwise return the dynamic or absolute power depending on the model.
 	GetPlatformPower(isIdlePower bool) ([]float64, error)
-	// GetComponentsPower returns RAPL components Power in Watts associated to each each process/container/pod
+	// GetComponentsPower returns RAPL components Power in Watts associated to each each process/process/pod
 	// If isIdlePower is true, return the idle power, otherwise return the dynamic or absolute power depending on the model.
 	GetComponentsPower(isIdlePower bool) ([]source.NodeComponentsEnergy, error)
-	// GetComponentsPower returns GPU Power in Watts associated to each each process/container/pod
+	// GetComponentsPower returns GPU Power in Watts associated to each each process/process/pod
 	// If isIdlePower is true, return the idle power, otherwise return the dynamic or absolute power depending on the model.
 	GetGPUPower(isIdlePower bool) ([]float64, error)
 }
 
 // CreatePowerEstimatorModels checks validity of power model and set estimate functions
-func CreatePowerEstimatorModels(containerFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues []string) {
+func CreatePowerEstimatorModels(processFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues []string) {
 	config.InitModelConfigMap()
-	CreateContainerPowerEstimatorModel(containerFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
-	CreateProcessPowerEstimatorModel(containerFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
-	// Node power estimator uses the container features to estimate node power, expect for the Ratio power model that contains additional metrics.
-	CreateNodePlatformPoweEstimatorModel(containerFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
-	CreateNodeComponentPoweEstimatorModel(containerFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
+	CreateProcessPowerEstimatorModel(processFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
+	CreateProcessPowerEstimatorModel(processFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
+	// Node power estimator uses the process features to estimate node power, expect for the Ratio power model that contains additional metrics.
+	CreateNodePlatformPoweEstimatorModel(processFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
+	CreateNodeComponentPoweEstimatorModel(processFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
 }
 
 // createPowerModelEstimator called by CreatePowerEstimatorModels to initiate estimate function for each power model.
@@ -88,8 +88,8 @@ func createPowerModelEstimator(modelConfig *types.ModelConfig) (PowerMoldelInter
 	switch modelConfig.ModelType {
 	case types.Ratio:
 		model := &local.RatioPowerModel{
-			ContainerFeatureNames: modelConfig.ContainerFeatureNames,
-			NodeFeatureNames:      modelConfig.NodeFeatureNames,
+			ProcessFeatureNames: modelConfig.ProcessFeatureNames,
+			NodeFeatureNames:    modelConfig.NodeFeatureNames,
 		}
 		klog.V(3).Infof("Using Power Model Ratio")
 		return model, nil
@@ -99,7 +99,7 @@ func createPowerModelEstimator(modelConfig *types.ModelConfig) (PowerMoldelInter
 		if modelConfig.IsNodePowerModel {
 			featuresNames = modelConfig.NodeFeatureNames
 		} else {
-			featuresNames = modelConfig.ContainerFeatureNames
+			featuresNames = modelConfig.ProcessFeatureNames
 		}
 		model := &local.LinearRegressor{
 			ModelServerEndpoint:         config.ModelServerEndpoint,
@@ -125,7 +125,7 @@ func createPowerModelEstimator(modelConfig *types.ModelConfig) (PowerMoldelInter
 		if modelConfig.IsNodePowerModel {
 			featuresNames = modelConfig.NodeFeatureNames
 		} else {
-			featuresNames = modelConfig.ContainerFeatureNames
+			featuresNames = modelConfig.ProcessFeatureNames
 		}
 		model := &sidecar.EstimatorSidecar{
 			Socket:                      EstimatorSidecarSocket,
@@ -200,7 +200,7 @@ func getPowerModelType(powerSourceTarget string) (modelType types.ModelType) {
 		modelType = types.LinearRegressor
 		return
 	}
-	// set the default container power model as Ratio
+	// set the default process power model as Ratio
 	modelType = types.Ratio
 	return
 }
@@ -243,19 +243,15 @@ func getPowerModelEnergySource(powerSourceTarget string) (energySource string) {
 	return ""
 }
 
-// getPowerModelOutputType return the model output type for a given power source, such as platform, components, container or node power sources.
+// getPowerModelOutputType return the model output type for a given power source, such as platform, components, process or node power sources.
 // getPowerModelOutputType only affects LinearRegressor or EstimatorSidecar model. The Ratio model does not download data from the Model Server.
-// AbsPower for Node, DynPower for container and process
+// AbsPower for Node, DynPower for process and process
 func getPowerModelOutputType(powerSourceTarget string) types.ModelOutputType {
 	switch powerSourceTarget {
-	case config.ContainerPlatformPowerKey:
-		return types.DynPower
-	case config.ContainerComponentsPowerKey:
+	case config.ProcessComponentsPowerKey:
 		return types.DynPower
 	case config.ProcessPlatformPowerKey:
 		return types.DynPower
-	case config.ProcessComponentsPowerKey:
-		return types.DynPower
 	case config.NodePlatformPowerKey:
 		return types.AbsPower
 	case config.NodeComponentsPowerKey:
diff --git a/pkg/model/model_test.go b/pkg/model/model_test.go
index d5b3981a24..2060ba2dd6 100644
--- a/pkg/model/model_test.go
+++ b/pkg/model/model_test.go
@@ -22,17 +22,18 @@ import (
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
-	"github.com/sustainable-computing-io/kepler/pkg/power/platform"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components/source"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/platform"
 )
 
 var _ = Describe("Test Model Unit", func() {
 
 	BeforeEach(func() {
 		source.SystemCollectionSupported = false // disable the system power collection to use the prediction power model
-		setCollectorMetrics()
+		stats.SetMockedCollectorMetrics()
 
 		configStr := "CONTAINER_COMPONENTS_INIT_URL=https://raw.githubusercontent.com/sustainable-computing-io/kepler-model-server/test_models/tests/test_models/DynComponentModelWeight/CgroupOnly/ScikitMixed/ScikitMixed.json\n"
 		os.Setenv("MODEL_CONFIG", configStr)
diff --git a/pkg/model/node_component_energy.go b/pkg/model/node_component_energy.go
index be9475c783..60829a947c 100644
--- a/pkg/model/node_component_energy.go
+++ b/pkg/model/node_component_energy.go
@@ -17,11 +17,13 @@ limitations under the License.
 package model
 
 import (
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
+	"fmt"
+
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
 	"github.com/sustainable-computing-io/kepler/pkg/model/types"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components/source"
 	"k8s.io/klog/v2"
 )
 
@@ -51,7 +53,7 @@ func CreateNodeComponentPoweEstimatorModel(nodeFeatureNames, systemMetaDataFeatu
 		// init func for NodeComponentPower
 		NodeComponentPowerModel, err = createPowerModelEstimator(modelConfig)
 		if err == nil {
-			klog.Infof("Using the %s Power Model to estimate Node Component Power", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String())
+			klog.V(1).Infof("Using the %s Power Model to estimate Node Component Power", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String())
 		} else {
 			klog.Infof("Failed to create %s Power Model to estimate Node Component Power: %v\n", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String(), err)
 		}
@@ -67,7 +69,7 @@ func IsNodeComponentPowerModelEnabled() bool {
 }
 
 // GetNodeComponentPowers returns estimated RAPL power for the node
-func GetNodeComponentPowers(nodeMetrics *collector_metric.NodeMetrics, isIdlePower bool) (nodeComponentsEnergy map[int]source.NodeComponentsEnergy) {
+func GetNodeComponentPowers(nodeMetrics *stats.NodeStats, isIdlePower bool) (nodeComponentsEnergy map[int]source.NodeComponentsEnergy) {
 	if NodeComponentPowerModel == nil {
 		klog.Errorln("Node Component Power Model was not created")
 	}
@@ -92,41 +94,21 @@ func GetNodeComponentPowers(nodeMetrics *collector_metric.NodeMetrics, isIdlePow
 }
 
 // UpdateNodeComponentIdleEnergy sets the power model samples, get absolute powers, and set gauge value for each component energy
-func UpdateNodeComponentEnergy(nodeMetrics *collector_metric.NodeMetrics) {
-	componentPower := GetNodeComponentPowers(nodeMetrics, absPower)
-	for id := range componentPower {
-		var ok bool
-		var power source.NodeComponentsEnergy
-		if power, ok = componentPower[id]; !ok {
-			continue
-		}
-		// convert power to energy
-		power.Pkg *= config.SamplePeriodSec
-		power.Core *= config.SamplePeriodSec
-		power.DRAM *= config.SamplePeriodSec
-		power.Uncore *= config.SamplePeriodSec
-		power.Core *= config.SamplePeriodSec
-		componentPower[id] = power
-	}
-	nodeMetrics.SetNodeComponentsEnergy(componentPower, gauge, absPower)
+func UpdateNodeComponentEnergy(nodeMetrics *stats.NodeStats) {
+	addEnergy(nodeMetrics, stats.AvailableAbsEnergyMetrics, absPower)
 }
 
 // UpdateNodeComponentIdleEnergy sets the power model samples to zeros, get idle powers, and set gauge value for each component idle energy
-func UpdateNodeComponentIdleEnergy(nodeMetrics *collector_metric.NodeMetrics) {
-	componentPower := GetNodeComponentPowers(nodeMetrics, idlePower)
-	for id := range componentPower {
-		var ok bool
-		var power source.NodeComponentsEnergy
-		if power, ok = componentPower[id]; !ok {
-			continue
-		}
-		// convert power to energy
-		power.Pkg *= config.SamplePeriodSec
-		power.Core *= config.SamplePeriodSec
-		power.DRAM *= config.SamplePeriodSec
-		power.Uncore *= config.SamplePeriodSec
-		power.Core *= config.SamplePeriodSec
-		componentPower[id] = power
+func UpdateNodeComponentIdleEnergy(nodeMetrics *stats.NodeStats) {
+	addEnergy(nodeMetrics, stats.AvailableIdleEnergyMetrics, idlePower)
+}
+
+func addEnergy(nodeMetrics *stats.NodeStats, metrics []string, isIdle bool) {
+	for socket, power := range GetNodeComponentPowers(nodeMetrics, isIdle) {
+		strID := fmt.Sprintf("%d", socket)
+		nodeMetrics.EnergyUsage[metrics[0]].SetDeltaStat(strID, power.Core*config.SamplePeriodSec)
+		nodeMetrics.EnergyUsage[metrics[1]].SetDeltaStat(strID, power.DRAM*config.SamplePeriodSec)
+		nodeMetrics.EnergyUsage[metrics[2]].SetDeltaStat(strID, power.Uncore*config.SamplePeriodSec)
+		nodeMetrics.EnergyUsage[metrics[3]].SetDeltaStat(strID, power.Pkg*config.SamplePeriodSec)
 	}
-	nodeMetrics.SetNodeComponentsEnergy(componentPower, gauge, idlePower)
 }
diff --git a/pkg/model/node_platform_energy.go b/pkg/model/node_platform_energy.go
index d4a2cede5c..878e97d930 100644
--- a/pkg/model/node_platform_energy.go
+++ b/pkg/model/node_platform_energy.go
@@ -19,12 +19,11 @@ package model
 import (
 	"fmt"
 
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
 	"github.com/sustainable-computing-io/kepler/pkg/model/types"
-	"github.com/sustainable-computing-io/kepler/pkg/power/platform"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/platform"
 	"k8s.io/klog/v2"
-
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
 )
 
 const (
@@ -50,7 +49,7 @@ func CreateNodePlatformPoweEstimatorModel(nodeFeatureNames, systemMetaDataFeatur
 		var err error
 		NodePlatformPowerModel, err = createPowerModelEstimator(modelConfig)
 		if err == nil {
-			klog.Infof("Using the %s Power Model to estimate Node Platform Power", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String())
+			klog.V(1).Infof("Using the %s Power Model to estimate Node Platform Power", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String())
 		} else {
 			klog.Infof("Failed to create %s Power Model to estimate Node Platform Power: %v\n", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String(), err)
 		}
@@ -66,7 +65,7 @@ func IsNodePlatformPowerModelEnabled() bool {
 }
 
 // GetNodePlatformPower returns a single estimated value of node total power
-func GetNodePlatformPower(nodeMetrics *collector_metric.NodeMetrics, isIdlePower bool) (platformEnergy map[string]float64) {
+func GetNodePlatformPower(nodeMetrics *stats.NodeStats, isIdlePower bool) (platformEnergy map[string]float64) {
 	if NodePlatformPowerModel == nil {
 		klog.Errorln("Node Platform Power Model was not created")
 	}
@@ -90,21 +89,17 @@ func GetNodePlatformPower(nodeMetrics *collector_metric.NodeMetrics, isIdlePower
 }
 
 // UpdateNodePlatformEnergy sets the power model samples, get absolute powers, and set platform energy
-func UpdateNodePlatformEnergy(nodeMetrics *collector_metric.NodeMetrics) {
+func UpdateNodePlatformEnergy(nodeMetrics *stats.NodeStats) {
 	platformPower := GetNodePlatformPower(nodeMetrics, absPower)
-	for id, power := range platformPower {
-		// convert power to energy
-		platformPower[id] = power * float64(config.SamplePeriodSec)
+	for sourceID, power := range platformPower {
+		nodeMetrics.EnergyUsage[config.AbsEnergyInPlatform].SetDeltaStat(sourceID, uint64(power)*config.SamplePeriodSec)
 	}
-	nodeMetrics.SetNodePlatformEnergy(platformPower, gauge, absPower)
 }
 
 // UpdateNodePlatformIdleEnergy sets the power model samples to zeros, get idle powers, and set platform energy
-func UpdateNodePlatformIdleEnergy(nodeMetrics *collector_metric.NodeMetrics) {
+func UpdateNodePlatformIdleEnergy(nodeMetrics *stats.NodeStats) {
 	platformPower := GetNodePlatformPower(nodeMetrics, idlePower)
-	for id, power := range platformPower {
-		// convert power to energy
-		platformPower[id] = power * float64(config.SamplePeriodSec)
+	for sourceID, power := range platformPower {
+		nodeMetrics.EnergyUsage[config.IdleEnergyInPlatform].SetDeltaStat(sourceID, uint64(power)*config.SamplePeriodSec)
 	}
-	nodeMetrics.SetNodePlatformEnergy(platformPower, gauge, idlePower)
 }
diff --git a/pkg/model/process_power.go b/pkg/model/process_energy.go
similarity index 66%
rename from pkg/model/process_power.go
rename to pkg/model/process_energy.go
index 059029f729..aef03267f0 100644
--- a/pkg/model/process_power.go
+++ b/pkg/model/process_energy.go
@@ -14,35 +14,36 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-//nolint:dupl // we should have only the container package
 package model
 
 import (
 	"fmt"
 
 	"github.com/sustainable-computing-io/kepler/pkg/bpfassets/attacher"
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
 	"github.com/sustainable-computing-io/kepler/pkg/config"
 	"github.com/sustainable-computing-io/kepler/pkg/model/types"
-	"github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components/source"
+	"github.com/sustainable-computing-io/kepler/pkg/utils"
 	"k8s.io/klog/v2"
 )
 
 var (
 	ProcessPlatformPowerModel  PowerMoldelInterface
 	ProcessComponentPowerModel PowerMoldelInterface
-
-	// cgroupOnly
 )
 
 // createProcessPowerModelConfig: the process component power model must be set by default.
-func createProcessPowerModelConfig(powerSourceTarget string, processFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues []string, energySource string) *types.ModelConfig {
-	modelConfig := CreatePowerModelConfig(powerSourceTarget)
+func createProcessPowerModelConfig(powerSourceTarget string, processFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues []string, energySource string) (modelConfig *types.ModelConfig) {
+	modelConfig = CreatePowerModelConfig(powerSourceTarget)
+	if modelConfig == nil {
+		return nil
+	}
 	if modelConfig.InitModelURL == "" {
 		modelConfig.InitModelFilepath = config.GetDefaultPowerModelURL(modelConfig.ModelOutputType.String(), energySource)
 	}
-	modelConfig.ContainerFeatureNames = processFeatureNames
+	modelConfig.ProcessFeatureNames = processFeatureNames
 	modelConfig.SystemMetaDataFeatureNames = systemMetaDataFeatureNames
 	modelConfig.SystemMetaDataFeatureValues = systemMetaDataFeatureValues
 
@@ -60,7 +61,7 @@ func createProcessPowerModelConfig(powerSourceTarget string, processFeatureNames
 				pkgUsageMetric, coreUsageMetric, dramUsageMetric = config.CPUTime, config.CPUTime, config.CPUTime
 			}
 			// ProcessFeatureNames contains the metrics that represents the process resource utilization
-			modelConfig.ContainerFeatureNames = []string{
+			modelConfig.ProcessFeatureNames = []string{
 				pkgUsageMetric,            // for PKG resource usage
 				coreUsageMetric,           // for CORE resource usage
 				dramUsageMetric,           // for DRAM resource usage
@@ -69,20 +70,20 @@ func createProcessPowerModelConfig(powerSourceTarget string, processFeatureNames
 				config.GpuUsageMetric,     // for GPU resource usage
 			}
 			// NodeFeatureNames contains the metrics that represents the node resource utilization plus the dynamic and idle power power consumption
-			modelConfig.NodeFeatureNames = modelConfig.ContainerFeatureNames
+			modelConfig.NodeFeatureNames = modelConfig.ProcessFeatureNames
 			modelConfig.NodeFeatureNames = append(modelConfig.NodeFeatureNames, []string{
-				collector_metric.PKG + collector_metric.DYN,     // for dynamic PKG power consumption
-				collector_metric.CORE + collector_metric.DYN,    // for dynamic CORE power consumption
-				collector_metric.DRAM + collector_metric.DYN,    // for dynamic DRAM power consumption
-				collector_metric.UNCORE + collector_metric.DYN,  // for dynamic UNCORE power consumption
-				collector_metric.OTHER + collector_metric.DYN,   // for dynamic OTHER power consumption
-				collector_metric.GPU + collector_metric.DYN,     // for dynamic GPU power consumption
-				collector_metric.PKG + collector_metric.IDLE,    // for idle PKG power consumption
-				collector_metric.CORE + collector_metric.IDLE,   // for idle CORE power consumption
-				collector_metric.DRAM + collector_metric.IDLE,   // for idle DRAM power consumption
-				collector_metric.UNCORE + collector_metric.IDLE, // for idle UNCORE power consumption
-				collector_metric.OTHER + collector_metric.IDLE,  // for idle OTHER power consumption
-				collector_metric.GPU + collector_metric.IDLE,    // for idle GPU power consumption
+				config.DynEnergyInPkg,     // for dynamic PKG power consumption
+				config.DynEnergyInCore,    // for dynamic CORE power consumption
+				config.DynEnergyInDRAM,    // for dynamic DRAM power consumption
+				config.DynEnergyInUnCore,  // for dynamic UNCORE power consumption
+				config.DynEnergyInOther,   // for dynamic OTHER power consumption
+				config.DynEnergyInGPU,     // for dynamic GPU power consumption
+				config.IdleEnergyInPkg,    // for idle PKG power consumption
+				config.IdleEnergyInCore,   // for idle CORE power consumption
+				config.IdleEnergyInDRAM,   // for idle DRAM power consumption
+				config.IdleEnergyInUnCore, // for idle UNCORE power consumption
+				config.IdleEnergyInOther,  // for idle OTHER power consumption
+				config.IdleEnergyInGPU,    // for idle GPU power consumption
 			}...)
 		} else if powerSourceTarget == config.ProcessPlatformPowerKey {
 			platformUsageMetric := config.CoreUsageMetric
@@ -90,13 +91,13 @@ func createProcessPowerModelConfig(powerSourceTarget string, processFeatureNames
 				// Given that there is no HW counter in  some scenarios (e.g. on VMs), we have to use CPUTime data.
 				platformUsageMetric = config.CPUTime
 			}
-			modelConfig.ContainerFeatureNames = []string{
+			modelConfig.ProcessFeatureNames = []string{
 				platformUsageMetric, // for PLATFORM resource usage
 			}
-			modelConfig.NodeFeatureNames = modelConfig.ContainerFeatureNames
+			modelConfig.NodeFeatureNames = modelConfig.ProcessFeatureNames
 			modelConfig.NodeFeatureNames = append(modelConfig.NodeFeatureNames, []string{
-				collector_metric.PLATFORM + collector_metric.DYN,  // for dynamic PLATFORM power consumption
-				collector_metric.PLATFORM + collector_metric.IDLE, // for idle PLATFORM power consumption
+				config.DynEnergyInPlatform,  // for dynamic PLATFORM power consumption
+				config.IdleEnergyInPlatform, // for idle PLATFORM power consumption
 			}...)
 		}
 	}
@@ -110,8 +111,8 @@ func CreateProcessPowerEstimatorModel(processFeatureNames, systemMetaDataFeature
 	modelConfig.IsNodePowerModel = false
 	ProcessPlatformPowerModel, err = createPowerModelEstimator(modelConfig)
 	if err == nil {
-		klog.Infof("Using the %s Power Model to estimate Process Platform Power", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String())
-		klog.Infof("Container feature names: %v", modelConfig.ContainerFeatureNames)
+		klog.V(1).Infof("Using the %s Power Model to estimate Process Platform Power", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String())
+		klog.V(1).Infof("Process feature names: %v", modelConfig.ProcessFeatureNames)
 	} else {
 		klog.Infof("Failed to create %s Power Model to estimate Process Platform Power: %v\n", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String(), err)
 	}
@@ -120,15 +121,15 @@ func CreateProcessPowerEstimatorModel(processFeatureNames, systemMetaDataFeature
 	modelConfig.IsNodePowerModel = false
 	ProcessComponentPowerModel, err = createPowerModelEstimator(modelConfig)
 	if err == nil {
-		klog.Infof("Using the %s Power Model to estimate Process Component Power", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String())
-		klog.Infof("Container feature names: %v", modelConfig.ContainerFeatureNames)
+		klog.V(1).Infof("Using the %s Power Model to estimate Process Component Power", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String())
+		klog.V(1).Infof("Process feature names: %v", modelConfig.ProcessFeatureNames)
 	} else {
 		klog.Infof("Failed to create %s Power Model to estimate Process Component Power: %v\n", modelConfig.ModelType.String()+"/"+modelConfig.ModelOutputType.String(), err)
 	}
 }
 
 // UpdateProcessEnergy resets the power model samples, add new samples to the power models, then estimates the idle and dynamic energy
-func UpdateProcessEnergy(processMetrics map[uint64]*collector_metric.ProcessMetrics, nodeMetrics *collector_metric.NodeMetrics) {
+func UpdateProcessEnergy(processesMetrics map[uint64]*stats.ProcessStats, nodeMetrics *stats.NodeStats) {
 	if ProcessPlatformPowerModel == nil {
 		klog.Errorln("Process Platform Power Model was not created")
 	}
@@ -140,28 +141,27 @@ func UpdateProcessEnergy(processMetrics map[uint64]*collector_metric.ProcessMetr
 	ProcessComponentPowerModel.ResetSampleIdx()
 
 	// add features values for prediction
-	processIDList := addProcessSamplesToPowerModels(processMetrics, nodeMetrics)
-
-	addProcessEstimatedEnergy(processIDList, processMetrics, idlePower)
-	addProcessEstimatedEnergy(processIDList, processMetrics, absPower)
+	processIDList := addSamplesToPowerModels(processesMetrics, nodeMetrics)
+	addEstimatedEnergy(processIDList, processesMetrics, idlePower)
+	addEstimatedEnergy(processIDList, processesMetrics, absPower)
 }
 
-// addProcessSamplesToPowerModels converts process's metrics to array to add the samples to the power model
-func addProcessSamplesToPowerModels(processMetrics map[uint64]*collector_metric.ProcessMetrics, nodeMetrics *collector_metric.NodeMetrics) []uint64 {
+// addSamplesToPowerModels converts process's metrics to array to add the samples to the power model
+func addSamplesToPowerModels(processesMetrics map[uint64]*stats.ProcessStats, nodeMetrics *stats.NodeStats) []uint64 {
 	processIDList := []uint64{}
 	// Add process metrics
-	for processID, c := range processMetrics {
+	for processID, c := range processesMetrics {
 		// add samples to estimate the platform power
 		if ProcessPlatformPowerModel.IsEnabled() {
-			featureValues := c.ToEstimatorValues(ProcessPlatformPowerModel.GetContainerFeatureNamesList(), true) // add process features with normalized values
-			ProcessPlatformPowerModel.AddContainerFeatureValues(featureValues)
+			featureValues := c.ToEstimatorValues(ProcessPlatformPowerModel.GetProcessFeatureNamesList(), true) // add process features with normalized values
+			ProcessPlatformPowerModel.AddProcessFeatureValues(featureValues)
 		}
 
 		// add samples to estimate the components (CPU and DRAM) power
 		if ProcessComponentPowerModel.IsEnabled() {
 			// Add process metrics
-			featureValues := c.ToEstimatorValues(ProcessComponentPowerModel.GetContainerFeatureNamesList(), true) // add node features with normalized values
-			ProcessComponentPowerModel.AddContainerFeatureValues(featureValues)
+			featureValues := c.ToEstimatorValues(ProcessComponentPowerModel.GetProcessFeatureNamesList(), true) // add node features with normalized values
+			ProcessComponentPowerModel.AddProcessFeatureValues(featureValues)
 		}
 
 		processIDList = append(processIDList, processID)
@@ -178,8 +178,8 @@ func addProcessSamplesToPowerModels(processMetrics map[uint64]*collector_metric.
 	return processIDList
 }
 
-// addProcessEstimatedEnergy estimates the idle power consumption
-func addProcessEstimatedEnergy(processIDList []uint64, processMetrics map[uint64]*collector_metric.ProcessMetrics, isIdlePower bool) {
+// addEstimatedEnergy estimates the idle power consumption
+func addEstimatedEnergy(processIDList []uint64, processesMetrics map[uint64]*stats.ProcessStats, isIdlePower bool) {
 	var err error
 	var processGPUPower []float64
 	var processPlatformPower []float64
@@ -218,9 +218,9 @@ func addProcessEstimatedEnergy(processIDList []uint64, processMetrics map[uint64
 			// since Kepler collects metrics at intervals of SamplePeriodSec, which is greater than 1 second, it is necessary to calculate the energy consumption for the entire waiting period
 			energy = processComponentsPower[i].Pkg * config.SamplePeriodSec
 			if isIdlePower {
-				err = processMetrics[processID].IdleEnergyInPkg.AddNewDelta(energy)
+				processesMetrics[processID].EnergyUsage[config.IdleEnergyInPkg].SetDeltaStat(utils.GenericSocketID, energy)
 			} else {
-				err = processMetrics[processID].DynEnergyInPkg.AddNewDelta(energy)
+				processesMetrics[processID].EnergyUsage[config.DynEnergyInPkg].SetDeltaStat(utils.GenericSocketID, energy)
 			}
 			if err != nil {
 				klog.V(5).Infoln(err)
@@ -229,9 +229,9 @@ func addProcessEstimatedEnergy(processIDList []uint64, processMetrics map[uint64
 			// add CORE power consumption
 			energy = processComponentsPower[i].Core * config.SamplePeriodSec
 			if isIdlePower {
-				err = processMetrics[processID].IdleEnergyInCore.AddNewDelta(energy)
+				processesMetrics[processID].EnergyUsage[config.IdleEnergyInCore].SetDeltaStat(utils.GenericSocketID, energy)
 			} else {
-				err = processMetrics[processID].DynEnergyInCore.AddNewDelta(energy)
+				processesMetrics[processID].EnergyUsage[config.DynEnergyInCore].SetDeltaStat(utils.GenericSocketID, energy)
 			}
 			if err != nil {
 				klog.V(5).Infoln(err)
@@ -240,9 +240,9 @@ func addProcessEstimatedEnergy(processIDList []uint64, processMetrics map[uint64
 			// add DRAM power consumption
 			energy = processComponentsPower[i].DRAM * config.SamplePeriodSec
 			if isIdlePower {
-				err = processMetrics[processID].IdleEnergyInDRAM.AddNewDelta(energy)
+				processesMetrics[processID].EnergyUsage[config.IdleEnergyInDRAM].SetDeltaStat(utils.GenericSocketID, energy)
 			} else {
-				err = processMetrics[processID].DynEnergyInDRAM.AddNewDelta(energy)
+				processesMetrics[processID].EnergyUsage[config.DynEnergyInDRAM].SetDeltaStat(utils.GenericSocketID, energy)
 			}
 			if err != nil {
 				klog.V(5).Infoln(err)
@@ -251,9 +251,9 @@ func addProcessEstimatedEnergy(processIDList []uint64, processMetrics map[uint64
 			// add Uncore power consumption
 			energy = processComponentsPower[i].Uncore * config.SamplePeriodSec
 			if isIdlePower {
-				err = processMetrics[processID].IdleEnergyInUncore.AddNewDelta(energy)
+				processesMetrics[processID].EnergyUsage[config.IdleEnergyInUnCore].SetDeltaStat(utils.GenericSocketID, energy)
 			} else {
-				err = processMetrics[processID].DynEnergyInUncore.AddNewDelta(energy)
+				processesMetrics[processID].EnergyUsage[config.DynEnergyInUnCore].SetDeltaStat(utils.GenericSocketID, energy)
 			}
 			if err != nil {
 				klog.V(5).Infoln(err)
@@ -263,9 +263,9 @@ func addProcessEstimatedEnergy(processIDList []uint64, processMetrics map[uint64
 			if errGPU == nil {
 				energy = uint64(processGPUPower[i]) * (config.SamplePeriodSec)
 				if isIdlePower {
-					err = processMetrics[processID].IdleEnergyInGPU.AddNewDelta(energy)
+					processesMetrics[processID].EnergyUsage[config.IdleEnergyInGPU].SetDeltaStat(utils.GenericSocketID, energy)
 				} else {
-					err = processMetrics[processID].DynEnergyInGPU.AddNewDelta(energy)
+					processesMetrics[processID].EnergyUsage[config.DynEnergyInGPU].SetDeltaStat(utils.GenericSocketID, energy)
 				}
 				if err != nil {
 					klog.V(5).Infoln(err)
@@ -276,9 +276,9 @@ func addProcessEstimatedEnergy(processIDList []uint64, processMetrics map[uint64
 		if errPlat == nil {
 			energy = uint64(processPlatformPower[i]) * config.SamplePeriodSec
 			if isIdlePower {
-				err = processMetrics[processID].IdleEnergyInPlatform.AddNewDelta(energy)
+				processesMetrics[processID].EnergyUsage[config.IdleEnergyInPlatform].SetDeltaStat(utils.GenericSocketID, energy)
 			} else {
-				err = processMetrics[processID].DynEnergyInPlatform.AddNewDelta(energy)
+				processesMetrics[processID].EnergyUsage[config.DynEnergyInPlatform].SetDeltaStat(utils.GenericSocketID, energy)
 			}
 			if err != nil {
 				klog.V(5).Infoln(err)
@@ -294,9 +294,9 @@ func addProcessEstimatedEnergy(processIDList []uint64, processMetrics map[uint64
 			}
 			energy = uint64(otherPower) * config.SamplePeriodSec
 			if isIdlePower {
-				err = processMetrics[processID].IdleEnergyInOther.AddNewDelta(energy)
+				processesMetrics[processID].EnergyUsage[config.IdleEnergyInOther].SetDeltaStat(utils.GenericSocketID, energy)
 			} else {
-				err = processMetrics[processID].DynEnergyInOther.AddNewDelta(energy)
+				processesMetrics[processID].EnergyUsage[config.DynEnergyInOther].SetDeltaStat(utils.GenericSocketID, energy)
 			}
 			if err != nil {
 				klog.V(5).Infoln(err)
diff --git a/pkg/model/process_energy_test.go b/pkg/model/process_energy_test.go
new file mode 100644
index 0000000000..d381147f1f
--- /dev/null
+++ b/pkg/model/process_energy_test.go
@@ -0,0 +1,144 @@
+/*
+Copyright 2021.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package model
+
+import (
+	"os"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/sustainable-computing-io/kepler/pkg/collector/stats"
+	"github.com/sustainable-computing-io/kepler/pkg/config"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/platform"
+	"github.com/sustainable-computing-io/kepler/pkg/utils"
+)
+
+var _ = Describe("ProcessPower", func() {
+	var (
+		processStats map[uint64]*stats.ProcessStats
+		nodeStats    stats.NodeStats
+
+		systemMetaDataFeatureNames  = []string{"cpu_architecture"}
+		systemMetaDataFeatureValues = []string{"Sandy Bridge"}
+	)
+
+	Context("with manually defined node power", func() {
+		BeforeEach(func() {
+			// we need to disable the system real time power metrics for testing since we add mock values or use power model estimator
+			components.SetIsSystemCollectionSupported(false)
+			platform.SetIsSystemCollectionSupported(false)
+			stats.SetMockedCollectorMetrics()
+
+			processStats = stats.CreateMockedProcessStats(2)
+			nodeStats = stats.CreateMockedNodeStats()
+			for _, pMetric := range processStats {
+				val := pMetric.ResourceUsage[config.CPUCycle].Stat[stats.MockedSocketID].GetDelta()
+				nodeStats.ResourceUsage[config.CPUCycle].AddDeltaStat(stats.MockedSocketID, val)
+
+				val = pMetric.ResourceUsage[config.CPUInstruction].Stat[stats.MockedSocketID].GetDelta()
+				nodeStats.ResourceUsage[config.CPUInstruction].AddDeltaStat(stats.MockedSocketID, val)
+
+				val = pMetric.ResourceUsage[config.CacheMiss].Stat[stats.MockedSocketID].GetDelta()
+				nodeStats.ResourceUsage[config.CacheMiss].AddDeltaStat(stats.MockedSocketID, val)
+
+				val = pMetric.ResourceUsage[config.CPUTime].Stat[stats.MockedSocketID].GetDelta()
+				nodeStats.ResourceUsage[config.CPUTime].AddDeltaStat(stats.MockedSocketID, val)
+			}
+		})
+
+		// By default the Ratio power mode is used to get the process power
+		It("Get process power with Ratio power model and node component power", func() {
+			configStr := "CONTAINER_COMPONENTS_ESTIMATOR=false\n"
+			os.Setenv("MODEL_CONFIG", configStr)
+
+			// getEstimatorMetrics
+			CreatePowerEstimatorModels(stats.ProcessFeaturesNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
+
+			// initialize the node energy with aggregated energy, which will be used to calculate delta energy
+			// add first values to be the idle power
+			nodeStats.EnergyUsage[config.AbsEnergyInPkg].SetDeltaStat(utils.GenericSocketID, 5000) // mili joules
+			nodeStats.EnergyUsage[config.AbsEnergyInCore].SetDeltaStat(utils.GenericSocketID, 5000)
+			nodeStats.EnergyUsage[config.AbsEnergyInDRAM].SetDeltaStat(utils.GenericSocketID, 5000)
+			// add second values to have dynamic power
+			nodeStats.EnergyUsage[config.AbsEnergyInPkg].SetDeltaStat(utils.GenericSocketID, 10000)
+			nodeStats.EnergyUsage[config.AbsEnergyInCore].SetDeltaStat(utils.GenericSocketID, 10000)
+			nodeStats.EnergyUsage[config.AbsEnergyInDRAM].SetDeltaStat(utils.GenericSocketID, 10000)
+			nodeStats.UpdateIdleEnergyWithMinValue(true)
+			// add second values to have dynamic power
+			nodeStats.EnergyUsage[config.AbsEnergyInPkg].SetDeltaStat(utils.GenericSocketID, 45000)
+			nodeStats.EnergyUsage[config.AbsEnergyInCore].SetDeltaStat(utils.GenericSocketID, 45000)
+			nodeStats.EnergyUsage[config.AbsEnergyInDRAM].SetDeltaStat(utils.GenericSocketID, 45000)
+			nodeStats.UpdateDynEnergy()
+
+			// calculate process energy consumption
+			UpdateProcessEnergy(processStats, &nodeStats)
+
+			// The default process power model is the Ratio, then process energy consumption will be as follows:
+			// The node components dynamic power were set to 35000mJ, since the kepler interval is 3s, the power is 11667mJ
+			// The test created 2 processes with 30000 CPU Instructions
+			// So the node total CPU Instructions is 60000
+			// The process power will be (30000/60000)*11667 = 5834
+			// Then, the process energy will be 5834*3 = 17502 mJ
+			Expect(processStats[uint64(1)].EnergyUsage[config.DynEnergyInPkg].Stat[utils.GenericSocketID].GetDelta()).To(Equal(uint64(17502)))
+		})
+
+		It("Get process power with Ratio power model and node platform power ", func() {
+			configStr := "CONTAINER_COMPONENTS_ESTIMATOR=false\n"
+			os.Setenv("MODEL_CONFIG", configStr)
+
+			// getEstimatorMetrics
+			CreatePowerEstimatorModels(stats.ProcessFeaturesNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
+
+			// initialize the node energy with aggregated energy, which will be used to calculate delta energy
+			// add first values to be the idle power
+			nodeStats.EnergyUsage[config.AbsEnergyInPlatform].SetDeltaStat(utils.GenericSocketID, 5000) // mili joules
+			// add second values to have dynamic power
+			nodeStats.EnergyUsage[config.AbsEnergyInPlatform].SetDeltaStat(utils.GenericSocketID, 10000)
+			nodeStats.UpdateIdleEnergyWithMinValue(true)
+			// add second values to have dynamic power
+			nodeStats.EnergyUsage[config.AbsEnergyInPlatform].SetDeltaStat(utils.GenericSocketID, 45000)
+			nodeStats.UpdateDynEnergy()
+
+			// calculate process energy consumption
+			UpdateProcessEnergy(processStats, &nodeStats)
+
+			// The default process power model is the Ratio, then process energy consumption will be as follows:
+			// The node components dynamic power were set to 35000mJ, since the kepler interval is 3s, the power is 11667mJ
+			// The test created 2 processes with 30000 CPU Instructions
+			// So the node total CPU Instructions is 60000
+			// The process power will be (30000/60000)*11667 = 5834
+			// Then, the process energy will be 5834*3 = 17502 mJ
+			Expect(processStats[uint64(1)].EnergyUsage[config.DynEnergyInPlatform].Stat[utils.GenericSocketID].GetDelta()).To(Equal(uint64(17502)))
+		})
+
+		// TODO: Get process power with no dependency and no node power.
+		// The current LR model has some problems, all the model weights are negative, which means that the energy consumption will decrease with larger resource utilization.
+		// Consequently the dynamic power will be 0 since the idle power with 0 resource utilization will be higher than the absolute power with non zero utilization
+		// Because of that we removed this test until we have a power model that is more accurate.
+		// It("Get process power with Ratio power model and node power with Linear Regression Power Model", func() {
+		// 	// the default power models will be linear regression for node power estimation and ratio for process power estimation
+		// 	CreatePowerEstimatorModels(processFeatureNames, systemMetaDataFeatureNames, systemMetaDataFeatureValues)
+		// 	// add node energy via estimator, using the LR model (the default configured one)
+		// 	// UpdateNodePlatformEnergy(nodeStats) currently we do not have the node platform abs power model, we will include that in the future
+		// 	UpdateNodeComponentEnergy(nodeStats)
+		// 	// calculate process energy consumption
+		// 	UpdateProcessEnergy(processStats, nodeStats)
+		// 	Expect(processStats["processA"].DynEnergyInPkg.Delta).To(Equal(uint64(???)))
+		// })
+	})
+})
diff --git a/pkg/model/suite_test.go b/pkg/model/suite_test.go
index 48169e7a2f..0490c9f96e 100644
--- a/pkg/model/suite_test.go
+++ b/pkg/model/suite_test.go
@@ -21,26 +21,6 @@ import (
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	"github.com/sustainable-computing-io/kepler/pkg/config"
-)
-
-var (
-	containerFeatureNames = []string{
-		config.CPUCycle,
-		config.CPUInstruction,
-		config.CacheMiss,
-		config.CgroupfsMemory,
-		config.CgroupfsKernelMemory,
-		config.CgroupfsTCPMemory,
-		config.CgroupfsCPU,
-		config.CgroupfsSystemCPU,
-		config.CgroupfsUserCPU,
-		config.CgroupfsReadIO,
-		config.CgroupfsWriteIO,
-		config.BlockDevicesIO,
-		config.KubeletCPUUsage,
-		config.KubeletMemoryUsage,
-	}
 )
 
 func TestModels(t *testing.T) {
diff --git a/pkg/model/types/types.go b/pkg/model/types/types.go
index c56a9e3e60..2b2256125c 100644
--- a/pkg/model/types/types.go
+++ b/pkg/model/types/types.go
@@ -76,7 +76,7 @@ type ModelConfig struct {
 	IsNodePowerModel bool
 
 	// initial samples to start the model
-	ContainerFeatureNames       []string
+	ProcessFeatureNames         []string
 	NodeFeatureNames            []string
 	SystemMetaDataFeatureNames  []string
 	SystemMetaDataFeatureValues []string
diff --git a/pkg/model/utils/utils.go b/pkg/model/utils/utils.go
index c3cd588b4f..d7f2bfd952 100644
--- a/pkg/model/utils/utils.go
+++ b/pkg/model/utils/utils.go
@@ -17,7 +17,7 @@ limitations under the License.
 package utils
 
 import (
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components/source"
 )
 
 const (
diff --git a/pkg/model/vm_power.go b/pkg/model/vm_power.go
deleted file mode 100644
index 5596f615a1..0000000000
--- a/pkg/model/vm_power.go
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-Copyright 2023.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package model
-
-import (
-	collector_metric "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
-)
-
-// UpdateVMEnergy matches the VM metrics with the process metrics already computed
-// TODO: remove data duplication, we don;t need to have a separate map for VM metrics, the processes metrics just need to have the VM ID label.
-func UpdateVMEnergy(vmMetrics map[uint64]*collector_metric.VMMetrics, processMetrics map[uint64]*collector_metric.ProcessMetrics) {
-	for _, vmmetrics := range vmMetrics {
-		for _, procmetrics := range processMetrics {
-			if procmetrics.PID != vmmetrics.PID {
-				continue
-			}
-
-			vmmetrics.BPFStats = procmetrics.BPFStats
-
-			vmmetrics.DynEnergyInCore = procmetrics.DynEnergyInCore
-			vmmetrics.DynEnergyInDRAM = procmetrics.DynEnergyInDRAM
-			vmmetrics.DynEnergyInUncore = procmetrics.DynEnergyInUncore
-			vmmetrics.DynEnergyInPkg = procmetrics.DynEnergyInPkg
-			vmmetrics.DynEnergyInGPU = procmetrics.DynEnergyInGPU
-			vmmetrics.DynEnergyInOther = procmetrics.DynEnergyInOther
-			vmmetrics.DynEnergyInPlatform = procmetrics.DynEnergyInPlatform
-
-			vmmetrics.IdleEnergyInCore = procmetrics.IdleEnergyInCore
-			vmmetrics.IdleEnergyInDRAM = procmetrics.IdleEnergyInDRAM
-			vmmetrics.IdleEnergyInUncore = procmetrics.IdleEnergyInUncore
-			vmmetrics.IdleEnergyInPkg = procmetrics.IdleEnergyInPkg
-			vmmetrics.IdleEnergyInGPU = procmetrics.IdleEnergyInGPU
-			vmmetrics.IdleEnergyInOther = procmetrics.IdleEnergyInOther
-			vmmetrics.IdleEnergyInPlatform = procmetrics.IdleEnergyInPlatform
-		}
-	}
-}
diff --git a/pkg/nodecred/csv_cred.go b/pkg/nodecred/csv_cred.go
index 2a4cba3218..bfa63db990 100644
--- a/pkg/nodecred/csv_cred.go
+++ b/pkg/nodecred/csv_cred.go
@@ -21,7 +21,7 @@ import (
 	"fmt"
 	"os"
 
-	metric_util "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
+	metric_util "github.com/sustainable-computing-io/kepler/pkg/collector/stats"
 
 	"k8s.io/klog/v2"
 )
diff --git a/pkg/nodecred/csv_cred_test.go b/pkg/nodecred/csv_cred_test.go
index ab5d087785..be5af4adbb 100644
--- a/pkg/nodecred/csv_cred_test.go
+++ b/pkg/nodecred/csv_cred_test.go
@@ -20,7 +20,7 @@ import (
 	"os"
 	"testing"
 
-	metric_util "github.com/sustainable-computing-io/kepler/pkg/collector/metric"
+	metric_util "github.com/sustainable-computing-io/kepler/pkg/collector/stats"
 )
 
 func TestGetNodeCredByNodeName(t *testing.T) {
diff --git a/pkg/power/accelerator/gpu/gpu.go b/pkg/sensors/accelerator/gpu/gpu.go
similarity index 94%
rename from pkg/power/accelerator/gpu/gpu.go
rename to pkg/sensors/accelerator/gpu/gpu.go
index 0c27716bb0..7e7e1a3ffa 100644
--- a/pkg/power/accelerator/gpu/gpu.go
+++ b/pkg/sensors/accelerator/gpu/gpu.go
@@ -20,7 +20,7 @@ limitations under the License.
 package gpu
 
 import (
-	gpu_source "github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu/source"
+	gpu_source "github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu/source"
 	"k8s.io/klog/v2"
 )
 
diff --git a/pkg/power/accelerator/gpu/power.go b/pkg/sensors/accelerator/gpu/power.go
similarity index 97%
rename from pkg/power/accelerator/gpu/power.go
rename to pkg/sensors/accelerator/gpu/power.go
index 454950899b..463f7508d0 100644
--- a/pkg/power/accelerator/gpu/power.go
+++ b/pkg/sensors/accelerator/gpu/power.go
@@ -21,7 +21,7 @@ import (
 	"time"
 
 	"github.com/sustainable-computing-io/kepler/pkg/config"
-	gpu_source "github.com/sustainable-computing-io/kepler/pkg/power/accelerator/gpu/source"
+	gpu_source "github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/gpu/source"
 	"k8s.io/klog/v2"
 )
 
diff --git a/pkg/power/accelerator/gpu/source/gpu_dummy.go b/pkg/sensors/accelerator/gpu/source/gpu_dummy.go
similarity index 100%
rename from pkg/power/accelerator/gpu/source/gpu_dummy.go
rename to pkg/sensors/accelerator/gpu/source/gpu_dummy.go
diff --git a/pkg/power/accelerator/gpu/source/gpu_nvml.go b/pkg/sensors/accelerator/gpu/source/gpu_nvml.go
similarity index 100%
rename from pkg/power/accelerator/gpu/source/gpu_nvml.go
rename to pkg/sensors/accelerator/gpu/source/gpu_nvml.go
diff --git a/pkg/power/accelerator/gpu/source/type.go b/pkg/sensors/accelerator/gpu/source/type.go
similarity index 100%
rename from pkg/power/accelerator/gpu/source/type.go
rename to pkg/sensors/accelerator/gpu/source/type.go
diff --git a/pkg/power/accelerator/qat/power.go b/pkg/sensors/accelerator/qat/power.go
similarity index 87%
rename from pkg/power/accelerator/qat/power.go
rename to pkg/sensors/accelerator/qat/power.go
index 30d3f2d661..8c015f3d12 100644
--- a/pkg/power/accelerator/qat/power.go
+++ b/pkg/sensors/accelerator/qat/power.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 
 	"github.com/sustainable-computing-io/kepler/pkg/config"
-	qat_source "github.com/sustainable-computing-io/kepler/pkg/power/accelerator/qat/source"
+	qat_source "github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/qat/source"
 	"k8s.io/klog/v2"
 )
 
@@ -52,21 +52,21 @@ func Init() error {
 }
 
 func Shutdown() bool {
-	if qatImpl != nil && config.EnabledQAT {
+	if qatImpl != nil && config.IsExposeQATMetricsEnabled() {
 		return qatImpl.Shutdown()
 	}
 	return true
 }
 
 func GetQATs() map[string]interface{} {
-	if qatImpl != nil && config.EnabledQAT {
+	if qatImpl != nil && config.IsExposeQATMetricsEnabled() {
 		return qatImpl.GetQATs()
 	}
 	return map[string]interface{}{}
 }
 
 func GetQATUtilization(devices map[string]interface{}) (map[string]qat_source.DeviceUtilizationSample, error) {
-	if qatImpl != nil && config.EnabledQAT {
+	if qatImpl != nil && config.IsExposeQATMetricsEnabled() {
 		deviceUtilization, err := qatImpl.GetQATUtilization(devices)
 		if err != nil {
 			klog.Infof("failed to collector QAT metrics, trying to initizalize again: %v \n", err)
@@ -82,14 +82,14 @@ func GetQATUtilization(devices map[string]interface{}) (map[string]qat_source.De
 }
 
 func IsQATCollectionSupported() bool {
-	if qatImpl != nil && config.EnabledQAT {
+	if qatImpl != nil && config.IsExposeQATMetricsEnabled() {
 		return qatImpl.IsQATCollectionSupported()
 	}
 	return false
 }
 
 func SetQATCollectionSupported(supported bool) {
-	if qatImpl != nil && config.EnabledQAT {
+	if qatImpl != nil && config.IsExposeQATMetricsEnabled() {
 		qatImpl.SetQATCollectionSupported(supported)
 	}
 }
diff --git a/pkg/power/accelerator/qat/qat.go b/pkg/sensors/accelerator/qat/qat.go
similarity index 91%
rename from pkg/power/accelerator/qat/qat.go
rename to pkg/sensors/accelerator/qat/qat.go
index a5586a211b..b8f9fc6f8b 100644
--- a/pkg/power/accelerator/qat/qat.go
+++ b/pkg/sensors/accelerator/qat/qat.go
@@ -17,7 +17,7 @@ limitations under the License.
 package qat
 
 import (
-	qat_source "github.com/sustainable-computing-io/kepler/pkg/power/accelerator/qat/source"
+	qat_source "github.com/sustainable-computing-io/kepler/pkg/sensors/accelerator/qat/source"
 	"k8s.io/klog/v2"
 )
 
diff --git a/pkg/power/accelerator/qat/source/qat_telemetry.go b/pkg/sensors/accelerator/qat/source/qat_telemetry.go
similarity index 100%
rename from pkg/power/accelerator/qat/source/qat_telemetry.go
rename to pkg/sensors/accelerator/qat/source/qat_telemetry.go
diff --git a/pkg/power/accelerator/qat/source/qat_test.go b/pkg/sensors/accelerator/qat/source/qat_test.go
similarity index 100%
rename from pkg/power/accelerator/qat/source/qat_test.go
rename to pkg/sensors/accelerator/qat/source/qat_test.go
diff --git a/pkg/power/accelerator/qat/source/qat_utils.go b/pkg/sensors/accelerator/qat/source/qat_utils.go
similarity index 100%
rename from pkg/power/accelerator/qat/source/qat_utils.go
rename to pkg/sensors/accelerator/qat/source/qat_utils.go
diff --git a/pkg/power/accelerator/qat/source/type.go b/pkg/sensors/accelerator/qat/source/type.go
similarity index 50%
rename from pkg/power/accelerator/qat/source/type.go
rename to pkg/sensors/accelerator/qat/source/type.go
index a562347b5a..ea37a3d95a 100644
--- a/pkg/power/accelerator/qat/source/type.go
+++ b/pkg/sensors/accelerator/qat/source/type.go
@@ -22,14 +22,24 @@ Further understand the device utilization obtained through telemetry by viewing
 */
 
 type DeviceUtilizationSample struct {
-	SampleCnt   uint64
+	// SampleCnt is a message counter
+	SampleCnt uint64
+	// PciTransCnt is a PCIe Partial Transaction counter
 	PciTransCnt uint64
-	Latency     uint64
-	BwIn        uint64
-	BwOut       uint64
-	CprUtil     uint64
-	DcprUtil    uint64
-	XltUtil     uint64
-	CphUtil     uint64
-	AthUtil     uint64
+	// Latency is the Average Get To Put latency in nanoseconds
+	Latency uint64
+	// BwIn is the PCIe write bandwidth in Mbps
+	BwIn uint64
+	// BwOut is the PCIe read bandwidth in Mbps
+	BwOut uint64
+	// CprUtil is the Compression Slice Utilization On Slice X in percentage execution cycles
+	CprUtil uint64
+	// DcprUtil is the Decompression Slice Utilization On Slice X in percentage execution cycles
+	DcprUtil uint64
+	// XltUtil is the Translator Slice Utilization On Slice X in percentage execution cycles
+	XltUtil uint64
+	// CphUtil is the Cipher Slice Utilization On Slice X in percentage execution cycles
+	CphUtil uint64
+	// AthUtil is the Authentication Slice Utilization On Slice X, percentage execution cycles
+	AthUtil uint64
 }
diff --git a/pkg/power/components/power.go b/pkg/sensors/components/power.go
similarity index 97%
rename from pkg/power/components/power.go
rename to pkg/sensors/components/power.go
index dccab16766..1c1fbb9ca8 100644
--- a/pkg/power/components/power.go
+++ b/pkg/sensors/components/power.go
@@ -20,7 +20,7 @@ import (
 	"k8s.io/klog/v2"
 
 	"github.com/sustainable-computing-io/kepler/pkg/config"
-	"github.com/sustainable-computing-io/kepler/pkg/power/components/source"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/components/source"
 )
 
 type powerInterface interface {
diff --git a/pkg/power/components/source/apm_xgene_sysfs.go b/pkg/sensors/components/source/apm_xgene_sysfs.go
similarity index 100%
rename from pkg/power/components/source/apm_xgene_sysfs.go
rename to pkg/sensors/components/source/apm_xgene_sysfs.go
diff --git a/pkg/power/components/source/dummy.go b/pkg/sensors/components/source/dummy.go
similarity index 100%
rename from pkg/power/components/source/dummy.go
rename to pkg/sensors/components/source/dummy.go
diff --git a/pkg/power/components/source/estimate.go b/pkg/sensors/components/source/estimate.go
similarity index 100%
rename from pkg/power/components/source/estimate.go
rename to pkg/sensors/components/source/estimate.go
diff --git a/pkg/power/components/source/rapl_metric_type.go b/pkg/sensors/components/source/rapl_metric_type.go
similarity index 100%
rename from pkg/power/components/source/rapl_metric_type.go
rename to pkg/sensors/components/source/rapl_metric_type.go
diff --git a/pkg/power/components/source/rapl_msr.go b/pkg/sensors/components/source/rapl_msr.go
similarity index 100%
rename from pkg/power/components/source/rapl_msr.go
rename to pkg/sensors/components/source/rapl_msr.go
diff --git a/pkg/power/components/source/rapl_msr_util.go b/pkg/sensors/components/source/rapl_msr_util.go
similarity index 100%
rename from pkg/power/components/source/rapl_msr_util.go
rename to pkg/sensors/components/source/rapl_msr_util.go
diff --git a/pkg/power/components/source/rapl_sysfs.go b/pkg/sensors/components/source/rapl_sysfs.go
similarity index 100%
rename from pkg/power/components/source/rapl_sysfs.go
rename to pkg/sensors/components/source/rapl_sysfs.go
diff --git a/pkg/power/components/source/rapl_sysfs_util.go b/pkg/sensors/components/source/rapl_sysfs_util.go
similarity index 100%
rename from pkg/power/components/source/rapl_sysfs_util.go
rename to pkg/sensors/components/source/rapl_sysfs_util.go
diff --git a/pkg/power/platform/power.go b/pkg/sensors/platform/power.go
similarity index 97%
rename from pkg/power/platform/power.go
rename to pkg/sensors/platform/power.go
index 6f0c651c74..5dc67a90cf 100644
--- a/pkg/power/platform/power.go
+++ b/pkg/sensors/platform/power.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"runtime"
 
-	"github.com/sustainable-computing-io/kepler/pkg/power/platform/source"
+	"github.com/sustainable-computing-io/kepler/pkg/sensors/platform/source"
 	"k8s.io/klog/v2"
 )
 
diff --git a/pkg/power/platform/source/acpi.go b/pkg/sensors/platform/source/acpi.go
similarity index 99%
rename from pkg/power/platform/source/acpi.go
rename to pkg/sensors/platform/source/acpi.go
index e25f47f349..7bb129f326 100644
--- a/pkg/power/platform/source/acpi.go
+++ b/pkg/sensors/platform/source/acpi.go
@@ -67,6 +67,7 @@ func NewACPIPowerMeter() *ACPI {
 			klog.Infoln("Could not find any ACPI power meter path. Is it a VM?")
 		}
 	}
+
 	return acpi
 }
 
diff --git a/pkg/power/platform/source/hmc.go b/pkg/sensors/platform/source/hmc.go
similarity index 100%
rename from pkg/power/platform/source/hmc.go
rename to pkg/sensors/platform/source/hmc.go
diff --git a/pkg/power/platform/source/redfish.go b/pkg/sensors/platform/source/redfish.go
similarity index 100%
rename from pkg/power/platform/source/redfish.go
rename to pkg/sensors/platform/source/redfish.go
diff --git a/pkg/power/platform/source/redfish_test.go b/pkg/sensors/platform/source/redfish_test.go
similarity index 100%
rename from pkg/power/platform/source/redfish_test.go
rename to pkg/sensors/platform/source/redfish_test.go
diff --git a/pkg/power/platform/source/redfish_util.go b/pkg/sensors/platform/source/redfish_util.go
similarity index 100%
rename from pkg/power/platform/source/redfish_util.go
rename to pkg/sensors/platform/source/redfish_util.go
diff --git a/pkg/power/power_suite_test.go b/pkg/sensors/power_suite_test.go
similarity index 91%
rename from pkg/power/power_suite_test.go
rename to pkg/sensors/power_suite_test.go
index 044a610864..e0869b04ae 100644
--- a/pkg/power/power_suite_test.go
+++ b/pkg/sensors/power_suite_test.go
@@ -1,4 +1,4 @@
-package power
+package sensors
 
 import (
 	"testing"
diff --git a/pkg/utils/utils.go b/pkg/utils/utils.go
index 4aed4248f3..ffe7d38685 100644
--- a/pkg/utils/utils.go
+++ b/pkg/utils/utils.go
@@ -43,8 +43,12 @@ func DetermineHostByteOrder() binary.ByteOrder {
 }
 
 const (
+	KernelProcessName      string = "kernel_processes"
+	KernelProcessNamespace string = "kernel"
 	SystemProcessName      string = "system_processes"
 	SystemProcessNamespace string = "system"
+	EmptyString            string = ""
+	GenericSocketID        string = "socket0"
 )
 
 func GetPathFromPID(searchPath string, pid uint64) (string, error) {