Merge pull request #238 from marceloamaral/log-verbosity

Update log lib to klog to enable log verbosity support

Author: rootfs

cmd/exporter.go

@@ -19,7 +19,6 @@ package main
 import (
 	"flag"
 	"fmt"
-	"log"
 	"net/http"
 
 	"github.com/sustainable-computing-io/kepler/pkg/collector"
@@ -31,6 +30,8 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"github.com/prometheus/common/version"
+
+	"k8s.io/klog/v2"
 )
 
 var (
@@ -42,11 +43,12 @@ var (
 )
 
 func main() {
+	klog.InitFlags(nil)
 	flag.Parse()
 
 	err := prometheus.Register(version.NewCollector("energy_stats_exporter"))
 	if err != nil {
-		log.Fatalf("failed to register : %v", err)
+		klog.Fatalf("failed to register : %v", err)
 	}
 
 	if *enableGPU {
@@ -65,16 +67,16 @@ func main() {
 	defer newCollector.Destroy()
 	defer rapl.StopPower()
 	if err != nil {
-		log.Panicf("%s", fmt.Sprintf("failed to create collector: %v", err))
+		klog.Fatalf("%s", fmt.Sprintf("failed to create collector: %v", err))
 	}
 	err = newCollector.Attach()
 	if err != nil {
-		log.Panicf("%s", fmt.Sprintf("failed to attach : %v", err))
+		klog.Fatalf("%s", fmt.Sprintf("failed to attach : %v", err))
 	}
 
 	err = prometheus.Register(newCollector)
 	if err != nil {
-		log.Panicf("%s", fmt.Sprintf("failed to register collector: %v", err))
+		klog.Fatalf("%s", fmt.Sprintf("failed to register collector: %v", err))
 	}
 
 	http.Handle(*metricsPath, promhttp.Handler())
@@ -87,12 +89,12 @@ func main() {
 			</body>
 			</html>`))
 		if err != nil {
-			log.Panicf("%s", fmt.Sprintf("failed to write response: %v", err))
+			klog.Fatalf("%s", fmt.Sprintf("failed to write response: %v", err))
 		}
 	})
 
 	err = http.ListenAndServe(*address, nil)
 	if err != nil {
-		log.Panicf("%s", fmt.Sprintf("failed to bind on %s: %v", *address, err))
+		klog.Fatalf("%s", fmt.Sprintf("failed to bind on %s: %v", *address, err))
 	}
 }

go.mod

@@ -13,6 +13,7 @@ require (
 	github.com/prometheus/common v0.37.0
 	golang.org/x/sys v0.0.0-20220829200755-d48e67d00261
 	k8s.io/api v0.25.0
+	k8s.io/klog/v2 v2.70.1
 )
 
 require (
@@ -38,7 +39,6 @@ require (
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	k8s.io/apimachinery v0.25.0 // indirect
-	k8s.io/klog/v2 v2.70.1 // indirect
 	k8s.io/utils v0.0.0-20220728103510-ee6ede2d64ed // indirect
 	sigs.k8s.io/json v0.0.0-20220713155537-f223a00ba0e2 // indirect
 	sigs.k8s.io/structured-merge-diff/v4 v4.2.3 // indirect

manifests/kubernetes/deployment.yaml

@@ -69,6 +69,7 @@ spec:
         - 0.0.0.0:9102
         - -enable-gpu=true
         - -enable-cgroup-id=true
+        - -v=1
         ports:
         - containerPort: 9102
           hostPort: 9102

pkg/attacher/bcc_attacher.go

@@ -31,6 +31,8 @@ import (
 	"github.com/sustainable-computing-io/kepler/pkg/model"
 
 	bpf "github.com/iovisor/gobpf/bcc"
+
+	"k8s.io/klog/v2"
 )
 
 type perfCounter struct {
@@ -81,7 +83,7 @@ func loadModule(objProg []byte, options []string) (*bpf.Module, error) {
 		perfErr := openPerfEvent(t, counter.evType, counter.evConfig)
 		if perfErr != nil {
 			// some hypervisors don't expose perf counters
-			fmt.Printf("failed to attach perf event %s: %v\n", arrayName, perfErr)
+			klog.Infof("failed to attach perf event %s: %v\n", arrayName, perfErr)
 			counter.enabled = false
 			// if perf counters are not available, it is likely running on a VM
 			model.SetVMCoeff()
@@ -106,12 +108,12 @@ func AttachBPFAssets() (*BpfModuleTables, error) {
 	}
 	m, err := loadModule(objProg, options)
 	if err != nil {
-		fmt.Printf("failed to attach perf module with options %v: %v\n", options, err)
+		klog.Infof("failed to attach perf module with options %v: %v\n", options, err)
 		options = []string{"-DNUM_CPUS=" + strconv.Itoa(runtime.NumCPU())}
 		EnableCPUFreq = false
 		m, err = loadModule(objProg, options)
 		if err != nil {
-			fmt.Printf("failed to attach perf module with options %v: %v\n", options, err)
+			klog.Infof("failed to attach perf module with options %v: %v\n", options, err)
 			// at this time, there is not much we can do with the eBPF module
 			return nil, err
 		}

pkg/bpfassets/perf_event_bindata.go

@@ -26,10 +26,11 @@ This file is a main file of cgroup module containing
 package cgroup
 
 import (
-	"log"
 	"os"
 	"path/filepath"
 	"strings"
+
+	"k8s.io/klog/v2"
 )
 
 const (
@@ -112,7 +113,7 @@ func InitSliceHandler() *SliceHandler {
 		}
 	}
 	handler.Init()
-	log.Printf("InitSliceHandler: %v", handler)
+	klog.V(3).Infof("InitSliceHandler: %v", handler)
 	return handler
 }
 

pkg/cgroup/slice_handler.go

@@ -22,7 +22,7 @@ import (
 	"github.com/sustainable-computing-io/kepler/pkg/model"
 	"github.com/sustainable-computing-io/kepler/pkg/podlister"
 
-	"log"
+	"k8s.io/klog/v2"
 )
 
 const (
@@ -59,9 +59,9 @@ func getUIntFeatures() []string {
 	// kubelet metric
 	metrics = append(metrics, availableKubeletMetrics...)
 	metrics = append(metrics, iostatMetrics...)
-	log.Printf("Available counter metrics: %v", availableCounters)
-	log.Printf("Available cgroup metrics: %v", availableCgroupMetrics)
-	log.Printf("Available kubelet metrics: %v", availableKubeletMetrics)
+	klog.V(3).Infof("Available counter metrics: %v", availableCounters)
+	klog.V(3).Infof("Available cgroup metrics: %v", availableCgroupMetrics)
+	klog.V(3).Infof("Available kubelet metrics: %v", availableKubeletMetrics)
 	return metrics
 }
 

pkg/collector/metrics.go

@@ -22,6 +22,7 @@ import (
 	"strconv"
 
 	"github.com/sustainable-computing-io/kepler/pkg/power/rapl/source"
+	"k8s.io/klog/v2"
 )
 
 var (
@@ -80,7 +81,6 @@ func (v *NodeEnergy) ResetCurr() {
 }
 
 func (v *NodeEnergy) SetValues(sensorEnergy map[string]float64, pkgEnergy map[int]source.PackageEnergy, totalGPUDelta uint64, usage map[string]float64) {
-	fmt.Printf("%v %v\n", sensorEnergy, pkgEnergy)
 	for sensorID, energy := range sensorEnergy {
 		v.SensorEnergy.AddStat(sensorID, uint64(energy))
 	}
@@ -92,7 +92,7 @@ func (v *NodeEnergy) SetValues(sensorEnergy map[string]float64, pkgEnergy map[in
 		v.EnergyInPkg.AddStat(key, energy.Pkg)
 	}
 	v.EnergyInGPU = totalGPUDelta
-	fmt.Printf("node energy stat core %v dram %v uncore %v pkg %v gpu %v sensor %v\n", v.EnergyInCore, v.EnergyInDRAM, v.EnergyInUncore, v.EnergyInPkg, v.EnergyInGPU, v.SensorEnergy)
+	klog.V(3).Infof("node energy stat core %v dram %v uncore %v pkg %v gpu %v sensor %v\n", v.EnergyInCore, v.EnergyInDRAM, v.EnergyInUncore, v.EnergyInPkg, v.EnergyInGPU, v.SensorEnergy)
 	totalSensorDelta := v.SensorEnergy.Curr()
 	totalPkgDelta := v.EnergyInPkg.Curr()
 	if totalSensorDelta > (totalPkgDelta + totalGPUDelta) {

pkg/collector/node_energy.go

@@ -18,10 +18,10 @@ package collector
 
 import (
 	"fmt"
-	"log"
 	"strconv"
 
 	"github.com/sustainable-computing-io/kepler/pkg/attacher"
+	"k8s.io/klog/v2"
 )
 
 type PodEnergy struct {
@@ -156,7 +156,7 @@ func (v *PodEnergy) extractUIntCurrAggr(metric string) (curr, aggr uint64) {
 		return v.BytesWrite.Curr(), v.BytesWrite.Aggr()
 	}
 
-	log.Printf("cannot extract: %s", metric)
+	klog.V(4).Infof("cannot extract: %s", metric)
 	return 0, 0
 }
 

pkg/collector/pod_energy.go

@@ -19,8 +19,6 @@ package collector
 import (
 	"bytes"
 	"encoding/binary"
-	"fmt"
-	"log"
 	"math"
 	"sync"
 	"time"
@@ -34,6 +32,8 @@ import (
 	"github.com/sustainable-computing-io/kepler/pkg/power/gpu"
 	"github.com/sustainable-computing-io/kepler/pkg/power/rapl"
 	"github.com/sustainable-computing-io/kepler/pkg/power/rapl/source"
+
+	"k8s.io/klog/v2"
 )
 
 // #define CPU_VECTOR_SIZE 128
@@ -108,15 +108,14 @@ func (c *Collector) readBPFEvent() (pidPodName map[uint32]string, containerIDPod
 		data := it.Leaf()
 		err := binary.Read(bytes.NewBuffer(data), binary.LittleEndian, &ct)
 		if err != nil {
-			log.Printf("failed to decode received data: %v", err)
+			klog.V(5).Infof("failed to decode received data: %v", err)
 			continue
 		}
 		comm := (*C.char)(unsafe.Pointer(&ct.Command))
-		fmt.Printf("pid %v cgroup %v cmd %v\n", ct.PID, ct.CGroupPID, C.GoString(comm))
 		podName, err := podlister.GetPodName(ct.CGroupPID, ct.PID)
 
 		if err != nil {
-			log.Printf("failed to resolve pod for cGroup ID %v: %v, set podName=%s", ct.CGroupPID, err, systemProcessName)
+			klog.V(5).Infof("failed to resolve pod for cGroup ID %v: %v, set podName=%s", ct.CGroupPID, err, systemProcessName)
 			podName = systemProcessName
 		}
 		if _, ok := podEnergy[podName]; !ok {
@@ -127,7 +126,7 @@ func (c *Collector) readBPFEvent() (pidPodName map[uint32]string, containerIDPod
 			} else {
 				podNamespace, err = podlister.GetPodNameSpace(ct.CGroupPID, ct.PID)
 				if err != nil {
-					log.Printf("failed to find namespace for cGroup ID %v: %v", ct.CGroupPID, err)
+					klog.V(5).Infof("failed to find namespace for cGroup ID %v: %v", ct.CGroupPID, err)
 					podNamespace = "unknown"
 				}
 			}
@@ -153,7 +152,7 @@ func (c *Collector) readBPFEvent() (pidPodName map[uint32]string, containerIDPod
 		}
 
 		if err = podEnergy[podName].CPUTime.AddNewCurr(totalCPUTime); err != nil {
-			log.Println(err)
+			klog.V(5).Infoln(err)
 		}
 
 		for _, counterKey := range availableCounters {
@@ -169,14 +168,14 @@ func (c *Collector) readBPFEvent() (pidPodName map[uint32]string, containerIDPod
 				val = 0
 			}
 			if err = podEnergy[podName].CounterStats[counterKey].AddNewCurr(val); err != nil {
-				log.Println(err)
+				klog.V(5).Infoln(err)
 			}
 		}
 
 		podEnergy[podName].CurrProcesses++
 		containerID, err := podlister.GetContainerID(ct.CGroupPID, ct.PID)
 		if err != nil {
-			log.Println(err)
+			klog.V(5).Infoln(err)
 		}
 		// first-time found container (should not include non-container event)
 		if _, found := containerIDPodName[containerID]; !found && podName != systemProcessName {
@@ -225,18 +224,18 @@ func (c *Collector) readCgroup(containerIDPodName map[string]string) {
 func (c *Collector) readKubelet() {
 	if len(availableKubeletMetrics) == 2 {
 		podCPU, podMem, _, _, _ := podlister.GetPodMetrics()
-		log.Printf("Kubelet Read: %v, %v\n", podCPU, podMem)
+		klog.V(5).Infof("Kubelet Read: %v, %v\n", podCPU, podMem)
 		for podName, v := range podEnergy {
 			k := v.Namespace + "/" + podName
 			readCPU := uint64(podCPU[k])
 			readMem := uint64(podMem[k])
 			cpuMetricName := availableKubeletMetrics[0]
 			memMetricName := availableKubeletMetrics[1]
 			if err := v.KubeletStats[cpuMetricName].SetNewAggr(readCPU); err != nil {
-				log.Println(err)
+				klog.V(5).Infoln(err)
 			}
 			if err := v.KubeletStats[memMetricName].SetNewAggr(readMem); err != nil {
-				log.Println(err)
+				klog.V(5).Infoln(err)
 			}
 		}
 	}
@@ -321,38 +320,38 @@ func (c *Collector) reader() {
 			// set pod energy
 			for i, podName := range podNameList {
 				if err := podEnergy[podName].EnergyInCore.AddNewCurr(podCore[i]); err != nil {
-					log.Println(err)
+					klog.V(5).Infoln(err)
 				}
 				if err := podEnergy[podName].EnergyInDRAM.AddNewCurr(podDRAM[i]); err != nil {
-					log.Println(err)
+					klog.V(5).Infoln(err)
 				}
 				if err := podEnergy[podName].EnergyInUncore.AddNewCurr(podUncore[i]); err != nil {
-					log.Println(err)
+					klog.V(5).Infoln(err)
 				}
 				if err := podEnergy[podName].EnergyInPkg.AddNewCurr(podPkg[i]); err != nil {
-					log.Println(err)
+					klog.V(5).Infoln(err)
 				}
 				podGPU := uint64(math.Ceil(podGPUDelta[podName]))
 				if err := podEnergy[podName].EnergyInGPU.AddNewCurr(podGPU); err != nil {
-					log.Println(err)
+					klog.V(5).Infoln(err)
 				}
 				if err := podEnergy[podName].EnergyInOther.AddNewCurr(podOther); err != nil {
-					log.Println(err)
+					klog.V(5).Infoln(err)
 				}
 			}
 			if len(podDynamicPower) != 0 {
 				for i, podName := range podNameList {
 					power := uint64(podDynamicPower[i])
 					if err := podEnergy[podName].DynEnergy.AddNewCurr(power); err != nil {
-						log.Println(err)
+						klog.V(5).Infoln(err)
 					}
 				}
-				fmt.Printf("Get pod powers: %v \n %v from %v (%d x %d)\n", podMetricValues[0:2], podDynamicPower, metricNames, len(podMetricValues), len(podMetricValues[0]))
+				klog.V(3).Infof("Get pod powers: %v \n %v from %v (%d x %d)\n", podMetricValues[0:2], podDynamicPower, metricNames, len(podMetricValues), len(podMetricValues[0]))
 			}
 			for _, v := range podEnergy {
-				fmt.Println(v)
+				klog.V(3).Infoln(v)
 			}
-			fmt.Println(nodeEnergy)
+			klog.V(3).Infoln(nodeEnergy)
 			lock.Unlock()
 		}
 	}()