diff --git a/.github/workflows/runonce.yml b/.github/workflows/runonce.yml index f5ce3fa..fedcc8b 100644 --- a/.github/workflows/runonce.yml +++ b/.github/workflows/runonce.yml @@ -35,11 +35,6 @@ jobs: run: | go install github.com/reviewdog/reviewdog/cmd/reviewdog@latest - # See: https://staticcheck.io - - name: Install staticcheck - run: | - go install honnef.co/go/tools/cmd/staticcheck@latest - # See: https://golangci-lint.run - name: Install GolangCI-Lint run: | @@ -54,21 +49,7 @@ jobs: # Running the linter requires likwid.h, which gets downloaded in the build step - name: Static Analysis with GolangCI-Lint and Upload Report with reviewdog run: | - golangci-lint run | reviewdog -f=golangci-lint -name "Check golangci-lint on build-latest" -reporter=github-check -filter-mode=nofilter -fail-level none - env: - REVIEWDOG_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }} - - # Running the linter requires likwid.h, which gets downloaded in the build step - - name: Run Static Analysis with go vet and Upload Report with reviewdog - run: | - go vet ./... | reviewdog -f=govet -name "Check govet on build-latest" -reporter=github-check -filter-mode=nofilter -fail-level none - env: - REVIEWDOG_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }} - - # Running the linter requires likwid.h, which gets downloaded in the build step - - name: Run Static Analysis with staticcheck and Upload Report with reviewdog - run: | - staticcheck ./... | reviewdog -f=staticcheck -name "Check staticcheck on build-latest" -reporter=github-check -filter-mode=nofilter -fail-level none + golangci-lint run --enable modernize,staticcheck,govet | reviewdog -f=golangci-lint -name "Check golangci-lint on build-latest" -reporter=github-check -filter-mode=nofilter -fail-level none env: REVIEWDOG_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/collectors/beegfsmetaMetric.go b/collectors/beegfsmetaMetric.go index 3c1c544..5d44878 100644 --- a/collectors/beegfsmetaMetric.go +++ b/collectors/beegfsmetaMetric.go @@ -225,7 +225,7 @@ func (m *BeegfsMetaCollector) Read(interval time.Duration, output chan lp.CCMess for key, data := range m.matches { value, _ := strconv.ParseFloat(data, 32) - y, err := lp.NewMessage(key, m.tags, m.meta, map[string]interface{}{"value": value}, time.Now()) + y, err := lp.NewMessage(key, m.tags, m.meta, map[string]any{"value": value}, time.Now()) if err == nil { output <- y } diff --git a/collectors/beegfsstorageMetric.go b/collectors/beegfsstorageMetric.go index 0c80387..feb8604 100644 --- a/collectors/beegfsstorageMetric.go +++ b/collectors/beegfsstorageMetric.go @@ -217,7 +217,7 @@ func (m *BeegfsStorageCollector) Read(interval time.Duration, output chan lp.CCM for key, data := range m.matches { value, _ := strconv.ParseFloat(data, 32) - y, err := lp.NewMessage(key, m.tags, m.meta, map[string]interface{}{"value": value}, time.Now()) + y, err := lp.NewMessage(key, m.tags, m.meta, map[string]any{"value": value}, time.Now()) if err == nil { output <- y } diff --git a/collectors/cpufreqCpuinfoMetric.go b/collectors/cpufreqCpuinfoMetric.go index 014bc09..4b2e184 100644 --- a/collectors/cpufreqCpuinfoMetric.go +++ b/collectors/cpufreqCpuinfoMetric.go @@ -171,7 +171,7 @@ func (m *CPUFreqCpuInfoCollector) Read(interval time.Duration, output chan lp.CC fmt.Sprintf("Read(): Failed to convert cpu MHz '%s' to float64: %v", lineSplit[1], err)) return } - if y, err := lp.NewMessage("cpufreq", t.tagSet, m.meta, map[string]interface{}{"value": value}, now); err == nil { + if y, err := lp.NewMessage("cpufreq", t.tagSet, m.meta, map[string]any{"value": value}, now); err == nil { output <- y } } diff --git a/collectors/cpufreqMetric.go b/collectors/cpufreqMetric.go index 80c3a92..ca2190f 100644 --- a/collectors/cpufreqMetric.go +++ b/collectors/cpufreqMetric.go @@ -126,7 +126,7 @@ func (m *CPUFreqCollector) Read(interval time.Duration, output chan lp.CCMessage continue } - if y, err := lp.NewMessage("cpufreq", t.tagSet, m.meta, map[string]interface{}{"value": cpuFreq}, now); err == nil { + if y, err := lp.NewMessage("cpufreq", t.tagSet, m.meta, map[string]any{"value": cpuFreq}, now); err == nil { output <- y } } diff --git a/collectors/cpustatMetric.go b/collectors/cpustatMetric.go index 5530e73..b21d60c 100644 --- a/collectors/cpustatMetric.go +++ b/collectors/cpustatMetric.go @@ -138,7 +138,7 @@ func (m *CpustatCollector) parseStatLine(linefields []string, tags map[string]st sum := float64(0) for name, value := range values { sum += value - y, err := lp.NewMessage(name, tags, m.meta, map[string]interface{}{"value": value * 100}, now) + y, err := lp.NewMessage(name, tags, m.meta, map[string]any{"value": value * 100}, now) if err == nil { y.AddTag("unit", "Percent") output <- y @@ -146,7 +146,7 @@ func (m *CpustatCollector) parseStatLine(linefields []string, tags map[string]st } if v, ok := values["cpu_idle"]; ok { sum -= v - y, err := lp.NewMessage("cpu_used", tags, m.meta, map[string]interface{}{"value": sum * 100}, now) + y, err := lp.NewMessage("cpu_used", tags, m.meta, map[string]any{"value": sum * 100}, now) if err == nil { y.AddTag("unit", "Percent") output <- y @@ -191,7 +191,7 @@ func (m *CpustatCollector) Read(interval time.Duration, output chan lp.CCMessage num_cpus_metric, err := lp.NewMessage("num_cpus", m.nodetags, m.meta, - map[string]interface{}{"value": int(num_cpus)}, + map[string]any{"value": int(num_cpus)}, now, ) if err == nil { diff --git a/collectors/diskstatMetric.go b/collectors/diskstatMetric.go index 9ad8512..84c2680 100644 --- a/collectors/diskstatMetric.go +++ b/collectors/diskstatMetric.go @@ -124,7 +124,7 @@ mountLoop: tags := map[string]string{"type": "node", "device": linefields[0]} total := (stat.Blocks * uint64(stat.Bsize)) / uint64(1000000000) if m.allowedMetrics["disk_total"] { - y, err := lp.NewMessage("disk_total", tags, m.meta, map[string]interface{}{"value": total}, time.Now()) + y, err := lp.NewMessage("disk_total", tags, m.meta, map[string]any{"value": total}, time.Now()) if err == nil { y.AddMeta("unit", "GBytes") output <- y @@ -132,7 +132,7 @@ mountLoop: } free := (stat.Bfree * uint64(stat.Bsize)) / uint64(1000000000) if m.allowedMetrics["disk_free"] { - y, err := lp.NewMessage("disk_free", tags, m.meta, map[string]interface{}{"value": free}, time.Now()) + y, err := lp.NewMessage("disk_free", tags, m.meta, map[string]any{"value": free}, time.Now()) if err == nil { y.AddMeta("unit", "GBytes") output <- y @@ -146,7 +146,7 @@ mountLoop: } } if m.allowedMetrics["part_max_used"] { - y, err := lp.NewMessage("part_max_used", map[string]string{"type": "node"}, m.meta, map[string]interface{}{"value": int(part_max_used)}, time.Now()) + y, err := lp.NewMessage("part_max_used", map[string]string{"type": "node"}, m.meta, map[string]any{"value": int(part_max_used)}, time.Now()) if err == nil { y.AddMeta("unit", "percent") output <- y diff --git a/collectors/gpfsMetric.go b/collectors/gpfsMetric.go index cf75432..f83328f 100644 --- a/collectors/gpfsMetric.go +++ b/collectors/gpfsMetric.go @@ -593,7 +593,7 @@ func (m *GpfsCollector) Read(interval time.Duration, output chan lp.CCMessage) { for _, metric := range m.definitions { vold, vold_ok := m.lastState[filesystem][metric.prefix] vnew, vnew_ok := newstate[metric.prefix] - var value interface{} + var value any value_ok := false switch metric.calc { case "none": diff --git a/collectors/infinibandMetric.go b/collectors/infinibandMetric.go index 96ad611..f7499d9 100644 --- a/collectors/infinibandMetric.go +++ b/collectors/infinibandMetric.go @@ -10,6 +10,7 @@ package collectors import ( "fmt" "os" + "slices" cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger" lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage" @@ -113,14 +114,7 @@ func (m *InfinibandCollector) Init(config json.RawMessage) error { port := pathSplit[6] // Skip excluded devices - skip := false - for _, excludedDevice := range m.config.ExcludeDevices { - if excludedDevice == device { - skip = true - break - } - } - if skip { + if slices.Contains(m.config.ExcludeDevices, device) { continue } @@ -243,7 +237,7 @@ func (m *InfinibandCollector) Read(interval time.Duration, output chan lp.CCMess counterDef.name, info.tagSet, m.meta, - map[string]interface{}{ + map[string]any{ "value": counterDef.currentState, }, now); err == nil { @@ -261,7 +255,7 @@ func (m *InfinibandCollector) Read(interval time.Duration, output chan lp.CCMess counterDef.name+"_bw", info.tagSet, m.meta, - map[string]interface{}{ + map[string]any{ "value": rate, }, now); err == nil { @@ -291,7 +285,7 @@ func (m *InfinibandCollector) Read(interval time.Duration, output chan lp.CCMess "ib_total", info.tagSet, m.meta, - map[string]interface{}{ + map[string]any{ "value": ib_total, }, now); err == nil { @@ -304,7 +298,7 @@ func (m *InfinibandCollector) Read(interval time.Duration, output chan lp.CCMess "ib_total_pkts", info.tagSet, m.meta, - map[string]interface{}{ + map[string]any{ "value": ib_total_pkts, }, now); err == nil { diff --git a/collectors/ipmiMetric.go b/collectors/ipmiMetric.go index 9e6f34d..fc21e8c 100644 --- a/collectors/ipmiMetric.go +++ b/collectors/ipmiMetric.go @@ -130,7 +130,7 @@ func (m *IpmiCollector) readIpmiTool(cmd string, output chan lp.CCMessage) { unit = "Watts" } - y, err := lp.NewMessage(name, map[string]string{"type": "node"}, m.meta, map[string]interface{}{"value": v}, time.Now()) + y, err := lp.NewMessage(name, map[string]string{"type": "node"}, m.meta, map[string]any{"value": v}, time.Now()) if err == nil { y.AddMeta("unit", unit) output <- y @@ -175,7 +175,7 @@ func (m *IpmiCollector) readIpmiSensors(cmd string, output chan lp.CCMessage) { v, err := strconv.ParseFloat(lv[3], 64) if err == nil { name := strings.ToLower(strings.ReplaceAll(lv[1], " ", "_")) - y, err := lp.NewMessage(name, map[string]string{"type": "node"}, m.meta, map[string]interface{}{"value": v}, time.Now()) + y, err := lp.NewMessage(name, map[string]string{"type": "node"}, m.meta, map[string]any{"value": v}, time.Now()) if err == nil { if len(lv) > 4 { y.AddMeta("unit", lv[4]) diff --git a/collectors/likwidMetric.go b/collectors/likwidMetric.go index f5e1c81..1f6d354 100644 --- a/collectors/likwidMetric.go +++ b/collectors/likwidMetric.go @@ -617,7 +617,6 @@ func (m *LikwidCollector) calcEventsetMetrics(evset LikwidEventsetConfig, interv evset.metrics[tid][metric.Name] = value // Now we have the result, send it with the proper tags if !math.IsNaN(value) && metric.Publish { - fields := map[string]interface{}{"value": value} y, err := lp.NewMessage( metric.Name, @@ -625,7 +624,9 @@ func (m *LikwidCollector) calcEventsetMetrics(evset LikwidEventsetConfig, interv "type": metric.Type, }, m.meta, - fields, + map[string]any{ + "value": value, + }, now, ) if err == nil { @@ -663,7 +664,7 @@ func (m *LikwidCollector) calcEventsetMetrics(evset LikwidEventsetConfig, interv "type-id": fmt.Sprintf("%d", coreID), }, m.meta, - map[string]interface{}{ + map[string]any{ "value": value, }, now, @@ -700,7 +701,7 @@ func (m *LikwidCollector) calcEventsetMetrics(evset LikwidEventsetConfig, interv "type-id": fmt.Sprintf("%d", socketID), }, m.meta, - map[string]interface{}{ + map[string]any{ "value": value, }, now, @@ -734,7 +735,7 @@ func (m *LikwidCollector) calcEventsetMetrics(evset LikwidEventsetConfig, interv "type": "node", }, m.meta, - map[string]interface{}{ + map[string]any{ "value": totalNodeValue, }, now, @@ -792,7 +793,7 @@ func (m *LikwidCollector) calcGlobalMetrics(groups []LikwidEventsetConfig, inter "type": metric.Type, }, m.meta, - map[string]interface{}{ + map[string]any{ "value": value, }, now, diff --git a/collectors/loadavgMetric.go b/collectors/loadavgMetric.go index 7010084..350cede 100644 --- a/collectors/loadavgMetric.go +++ b/collectors/loadavgMetric.go @@ -102,7 +102,7 @@ func (m *LoadavgCollector) Read(interval time.Duration, output chan lp.CCMessage if m.load_skips[i] { continue } - y, err := lp.NewMessage(name, m.tags, m.meta, map[string]interface{}{"value": x}, now) + y, err := lp.NewMessage(name, m.tags, m.meta, map[string]any{"value": x}, now) if err == nil { output <- y } @@ -121,7 +121,7 @@ func (m *LoadavgCollector) Read(interval time.Duration, output chan lp.CCMessage if m.proc_skips[i] { continue } - y, err := lp.NewMessage(name, m.tags, m.meta, map[string]interface{}{"value": x}, now) + y, err := lp.NewMessage(name, m.tags, m.meta, map[string]any{"value": x}, now) if err == nil { output <- y } diff --git a/collectors/lustreMetric.go b/collectors/lustreMetric.go index 23bf9ae..3689dc7 100644 --- a/collectors/lustreMetric.go +++ b/collectors/lustreMetric.go @@ -404,23 +404,23 @@ func (m *LustreCollector) Read(interval time.Duration, output chan lp.CCMessage) } else { use_x = devData[def.name] } - var value interface{} + var value any switch def.calc { case "none": value = use_x - y, err = lp.NewMessage(def.name, m.tags, m.meta, map[string]interface{}{"value": value}, time.Now()) + y, err = lp.NewMessage(def.name, m.tags, m.meta, map[string]any{"value": value}, time.Now()) case "difference": value = use_x - devData[def.name] if value.(int64) < 0 { value = 0 } - y, err = lp.NewMessage(def.name, m.tags, m.meta, map[string]interface{}{"value": value}, time.Now()) + y, err = lp.NewMessage(def.name, m.tags, m.meta, map[string]any{"value": value}, time.Now()) case "derivative": value = float64(use_x-devData[def.name]) / tdiff.Seconds() if value.(float64) < 0 { value = 0 } - y, err = lp.NewMessage(def.name, m.tags, m.meta, map[string]interface{}{"value": value}, time.Now()) + y, err = lp.NewMessage(def.name, m.tags, m.meta, map[string]any{"value": value}, time.Now()) } if err == nil { y.AddTag("device", device) diff --git a/collectors/memstatMetric.go b/collectors/memstatMetric.go index b934b36..e3b7e87 100644 --- a/collectors/memstatMetric.go +++ b/collectors/memstatMetric.go @@ -188,7 +188,7 @@ func (m *MemstatCollector) Read(interval time.Duration, output chan lp.CCMessage } } - y, err := lp.NewMessage(name, tags, m.meta, map[string]interface{}{"value": value}, time.Now()) + y, err := lp.NewMessage(name, tags, m.meta, map[string]any{"value": value}, time.Now()) if err == nil { if len(unit) > 0 { y.AddMeta("unit", unit) @@ -221,7 +221,7 @@ func (m *MemstatCollector) Read(interval time.Duration, output chan lp.CCMessage } } } - y, err := lp.NewMessage("mem_used", tags, m.meta, map[string]interface{}{"value": memUsed}, time.Now()) + y, err := lp.NewMessage("mem_used", tags, m.meta, map[string]any{"value": memUsed}, time.Now()) if err == nil { if len(unit) > 0 { y.AddMeta("unit", unit) diff --git a/collectors/netstatMetric.go b/collectors/netstatMetric.go index 877e83c..e8037d8 100644 --- a/collectors/netstatMetric.go +++ b/collectors/netstatMetric.go @@ -240,14 +240,14 @@ func (m *NetstatCollector) Read(interval time.Duration, output chan lp.CCMessage continue } if m.config.SendAbsoluteValues { - if y, err := lp.NewMessage(metric.name, metric.tags, metric.meta, map[string]interface{}{"value": v}, now); err == nil { + if y, err := lp.NewMessage(metric.name, metric.tags, metric.meta, map[string]any{"value": v}, now); err == nil { output <- y } } if m.config.SendDerivedValues { if metric.lastValue >= 0 { rate := float64(v-metric.lastValue) / timeDiff - if y, err := lp.NewMessage(metric.name+"_bw", metric.tags, metric.meta_rates, map[string]interface{}{"value": rate}, now); err == nil { + if y, err := lp.NewMessage(metric.name+"_bw", metric.tags, metric.meta_rates, map[string]any{"value": rate}, now); err == nil { output <- y } } diff --git a/collectors/nfsMetric.go b/collectors/nfsMetric.go index 7e8b57b..072b21b 100644 --- a/collectors/nfsMetric.go +++ b/collectors/nfsMetric.go @@ -167,7 +167,7 @@ func (m *nfsCollector) Read(interval time.Duration, output chan lp.CCMessage) { continue } value := data.current - data.last - y, err := lp.NewMessage(fmt.Sprintf("%s_%s", prefix, name), m.tags, m.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage(fmt.Sprintf("%s_%s", prefix, name), m.tags, m.meta, map[string]any{"value": value}, timestamp) if err == nil { y.AddMeta("version", m.version) output <- y diff --git a/collectors/nfsiostatMetric.go b/collectors/nfsiostatMetric.go index e23b8b4..76ef237 100644 --- a/collectors/nfsiostatMetric.go +++ b/collectors/nfsiostatMetric.go @@ -143,7 +143,7 @@ func (m *NfsIOStatCollector) Read(interval time.Duration, output chan lp.CCMessa if old, ok := m.data[mntpoint]; ok { for name, newVal := range values { if m.config.SendAbsoluteValues { - msg, err := lp.NewMessage(fmt.Sprintf("nfsio_%s", name), m.tags, m.meta, map[string]interface{}{"value": newVal}, now) + msg, err := lp.NewMessage(fmt.Sprintf("nfsio_%s", name), m.tags, m.meta, map[string]any{"value": newVal}, now) if err == nil { msg.AddTag("stype", "filesystem") msg.AddTag("stype-id", mntpoint) @@ -152,7 +152,7 @@ func (m *NfsIOStatCollector) Read(interval time.Duration, output chan lp.CCMessa } if m.config.SendDerivedValues { rate := float64(newVal-old[name]) / timeDiff - msg, err := lp.NewMessage(fmt.Sprintf("nfsio_%s_bw", name), m.tags, m.meta, map[string]interface{}{"value": rate}, now) + msg, err := lp.NewMessage(fmt.Sprintf("nfsio_%s_bw", name), m.tags, m.meta, map[string]any{"value": rate}, now) if err == nil { if strings.HasPrefix(name, "page") { msg.AddMeta("unit", "4K_pages/s") diff --git a/collectors/nvidiaMetric.go b/collectors/nvidiaMetric.go index db6d7e0..6a06daa 100644 --- a/collectors/nvidiaMetric.go +++ b/collectors/nvidiaMetric.go @@ -109,7 +109,7 @@ func (m *NvidiaCollector) Init(config json.RawMessage) error { // For all GPUs idx := 0 m.gpus = make([]NvidiaCollectorDevice, num_gpus) - for i := 0; i < num_gpus; i++ { + for i := range num_gpus { // Skip excluded devices by ID str_i := fmt.Sprintf("%d", i) @@ -239,7 +239,7 @@ func readMemoryInfo(device *NvidiaCollectorDevice, output chan lp.CCMessage) err if !device.excludeMetrics["nv_fb_mem_total"] { t := float64(total) / (1024 * 1024) - y, err := lp.NewMessage("nv_fb_mem_total", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now()) + y, err := lp.NewMessage("nv_fb_mem_total", device.tags, device.meta, map[string]any{"value": t}, time.Now()) if err == nil { y.AddMeta("unit", "MByte") output <- y @@ -248,7 +248,7 @@ func readMemoryInfo(device *NvidiaCollectorDevice, output chan lp.CCMessage) err if !device.excludeMetrics["nv_fb_mem_used"] { f := float64(used) / (1024 * 1024) - y, err := lp.NewMessage("nv_fb_mem_used", device.tags, device.meta, map[string]interface{}{"value": f}, time.Now()) + y, err := lp.NewMessage("nv_fb_mem_used", device.tags, device.meta, map[string]any{"value": f}, time.Now()) if err == nil { y.AddMeta("unit", "MByte") output <- y @@ -257,7 +257,7 @@ func readMemoryInfo(device *NvidiaCollectorDevice, output chan lp.CCMessage) err if v2 && !device.excludeMetrics["nv_fb_mem_reserved"] { r := float64(reserved) / (1024 * 1024) - y, err := lp.NewMessage("nv_fb_mem_reserved", device.tags, device.meta, map[string]interface{}{"value": r}, time.Now()) + y, err := lp.NewMessage("nv_fb_mem_reserved", device.tags, device.meta, map[string]any{"value": r}, time.Now()) if err == nil { y.AddMeta("unit", "MByte") output <- y @@ -276,7 +276,7 @@ func readBarMemoryInfo(device *NvidiaCollectorDevice, output chan lp.CCMessage) } if !device.excludeMetrics["nv_bar1_mem_total"] { t := float64(meminfo.Bar1Total) / (1024 * 1024) - y, err := lp.NewMessage("nv_bar1_mem_total", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now()) + y, err := lp.NewMessage("nv_bar1_mem_total", device.tags, device.meta, map[string]any{"value": t}, time.Now()) if err == nil { y.AddMeta("unit", "MByte") output <- y @@ -284,7 +284,7 @@ func readBarMemoryInfo(device *NvidiaCollectorDevice, output chan lp.CCMessage) } if !device.excludeMetrics["nv_bar1_mem_used"] { t := float64(meminfo.Bar1Used) / (1024 * 1024) - y, err := lp.NewMessage("nv_bar1_mem_used", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now()) + y, err := lp.NewMessage("nv_bar1_mem_used", device.tags, device.meta, map[string]any{"value": t}, time.Now()) if err == nil { y.AddMeta("unit", "MByte") output <- y @@ -318,14 +318,14 @@ func readUtilization(device *NvidiaCollectorDevice, output chan lp.CCMessage) er util, ret := nvml.DeviceGetUtilizationRates(device.device) if ret == nvml.SUCCESS { if !device.excludeMetrics["nv_util"] { - y, err := lp.NewMessage("nv_util", device.tags, device.meta, map[string]interface{}{"value": float64(util.Gpu)}, time.Now()) + y, err := lp.NewMessage("nv_util", device.tags, device.meta, map[string]any{"value": float64(util.Gpu)}, time.Now()) if err == nil { y.AddMeta("unit", "%") output <- y } } if !device.excludeMetrics["nv_mem_util"] { - y, err := lp.NewMessage("nv_mem_util", device.tags, device.meta, map[string]interface{}{"value": float64(util.Memory)}, time.Now()) + y, err := lp.NewMessage("nv_mem_util", device.tags, device.meta, map[string]any{"value": float64(util.Memory)}, time.Now()) if err == nil { y.AddMeta("unit", "%") output <- y @@ -345,7 +345,7 @@ func readTemp(device *NvidiaCollectorDevice, output chan lp.CCMessage) error { // * NVML_TEMPERATURE_COUNT temp, ret := nvml.DeviceGetTemperature(device.device, nvml.TEMPERATURE_GPU) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_temp", device.tags, device.meta, map[string]interface{}{"value": float64(temp)}, time.Now()) + y, err := lp.NewMessage("nv_temp", device.tags, device.meta, map[string]any{"value": float64(temp)}, time.Now()) if err == nil { y.AddMeta("unit", "degC") output <- y @@ -368,7 +368,7 @@ func readFan(device *NvidiaCollectorDevice, output chan lp.CCMessage) error { // This value may exceed 100% in certain cases. fan, ret := nvml.DeviceGetFanSpeed(device.device) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_fan", device.tags, device.meta, map[string]interface{}{"value": float64(fan)}, time.Now()) + y, err := lp.NewMessage("nv_fan", device.tags, device.meta, map[string]any{"value": float64(fan)}, time.Now()) if err == nil { y.AddMeta("unit", "%") output <- y @@ -415,17 +415,17 @@ func readEccMode(device *NvidiaCollectorDevice, output chan lp.CCMessage) error var err error switch ecc_pend { case nvml.FEATURE_DISABLED: - y, err = lp.NewMessage("nv_ecc_mode", device.tags, device.meta, map[string]interface{}{"value": "OFF"}, time.Now()) + y, err = lp.NewMessage("nv_ecc_mode", device.tags, device.meta, map[string]any{"value": "OFF"}, time.Now()) case nvml.FEATURE_ENABLED: - y, err = lp.NewMessage("nv_ecc_mode", device.tags, device.meta, map[string]interface{}{"value": "ON"}, time.Now()) + y, err = lp.NewMessage("nv_ecc_mode", device.tags, device.meta, map[string]any{"value": "ON"}, time.Now()) default: - y, err = lp.NewMessage("nv_ecc_mode", device.tags, device.meta, map[string]interface{}{"value": "UNKNOWN"}, time.Now()) + y, err = lp.NewMessage("nv_ecc_mode", device.tags, device.meta, map[string]any{"value": "UNKNOWN"}, time.Now()) } if err == nil { output <- y } case nvml.ERROR_NOT_SUPPORTED: - y, err := lp.NewMessage("nv_ecc_mode", device.tags, device.meta, map[string]interface{}{"value": "N/A"}, time.Now()) + y, err := lp.NewMessage("nv_ecc_mode", device.tags, device.meta, map[string]any{"value": "N/A"}, time.Now()) if err == nil { output <- y } @@ -445,7 +445,7 @@ func readPerfState(device *NvidiaCollectorDevice, output chan lp.CCMessage) erro // 32: Unknown performance state. pState, ret := nvml.DeviceGetPerformanceState(device.device) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_perf_state", device.tags, device.meta, map[string]interface{}{"value": fmt.Sprintf("P%d", int(pState))}, time.Now()) + y, err := lp.NewMessage("nv_perf_state", device.tags, device.meta, map[string]any{"value": fmt.Sprintf("P%d", int(pState))}, time.Now()) if err == nil { output <- y } @@ -471,7 +471,7 @@ func readPowerUsage(device *NvidiaCollectorDevice, output chan lp.CCMessage) err if mode == nvml.FEATURE_ENABLED { power, ret := nvml.DeviceGetPowerUsage(device.device) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_power_usage", device.tags, device.meta, map[string]interface{}{"value": float64(power) / 1000}, time.Now()) + y, err := lp.NewMessage("nv_power_usage", device.tags, device.meta, map[string]any{"value": float64(power) / 1000}, time.Now()) if err == nil { y.AddMeta("unit", "watts") output <- y @@ -539,7 +539,7 @@ func readClocks(device *NvidiaCollectorDevice, output chan lp.CCMessage) error { if !device.excludeMetrics["nv_graphics_clock"] { graphicsClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_GRAPHICS) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_graphics_clock", device.tags, device.meta, map[string]interface{}{"value": float64(graphicsClock)}, time.Now()) + y, err := lp.NewMessage("nv_graphics_clock", device.tags, device.meta, map[string]any{"value": float64(graphicsClock)}, time.Now()) if err == nil { y.AddMeta("unit", "MHz") output <- y @@ -550,7 +550,7 @@ func readClocks(device *NvidiaCollectorDevice, output chan lp.CCMessage) error { if !device.excludeMetrics["nv_sm_clock"] { smCock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_SM) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_sm_clock", device.tags, device.meta, map[string]interface{}{"value": float64(smCock)}, time.Now()) + y, err := lp.NewMessage("nv_sm_clock", device.tags, device.meta, map[string]any{"value": float64(smCock)}, time.Now()) if err == nil { y.AddMeta("unit", "MHz") output <- y @@ -561,7 +561,7 @@ func readClocks(device *NvidiaCollectorDevice, output chan lp.CCMessage) error { if !device.excludeMetrics["nv_mem_clock"] { memClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_MEM) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_mem_clock", device.tags, device.meta, map[string]interface{}{"value": float64(memClock)}, time.Now()) + y, err := lp.NewMessage("nv_mem_clock", device.tags, device.meta, map[string]any{"value": float64(memClock)}, time.Now()) if err == nil { y.AddMeta("unit", "MHz") output <- y @@ -571,7 +571,7 @@ func readClocks(device *NvidiaCollectorDevice, output chan lp.CCMessage) error { if !device.excludeMetrics["nv_video_clock"] { memClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_VIDEO) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_video_clock", device.tags, device.meta, map[string]interface{}{"value": float64(memClock)}, time.Now()) + y, err := lp.NewMessage("nv_video_clock", device.tags, device.meta, map[string]any{"value": float64(memClock)}, time.Now()) if err == nil { y.AddMeta("unit", "MHz") output <- y @@ -652,7 +652,7 @@ func readEccErrors(device *NvidiaCollectorDevice, output chan lp.CCMessage) erro // i.e. the total set of errors across the entire device. ecc_db, ret := nvml.DeviceGetTotalEccErrors(device.device, nvml.MEMORY_ERROR_TYPE_UNCORRECTED, nvml.AGGREGATE_ECC) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_ecc_uncorrected_error", device.tags, device.meta, map[string]interface{}{"value": float64(ecc_db)}, time.Now()) + y, err := lp.NewMessage("nv_ecc_uncorrected_error", device.tags, device.meta, map[string]any{"value": float64(ecc_db)}, time.Now()) if err == nil { output <- y } @@ -661,7 +661,7 @@ func readEccErrors(device *NvidiaCollectorDevice, output chan lp.CCMessage) erro if !device.excludeMetrics["nv_ecc_corrected_error"] { ecc_sb, ret := nvml.DeviceGetTotalEccErrors(device.device, nvml.MEMORY_ERROR_TYPE_CORRECTED, nvml.AGGREGATE_ECC) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_ecc_corrected_error", device.tags, device.meta, map[string]interface{}{"value": float64(ecc_sb)}, time.Now()) + y, err := lp.NewMessage("nv_ecc_corrected_error", device.tags, device.meta, map[string]any{"value": float64(ecc_sb)}, time.Now()) if err == nil { output <- y } @@ -680,7 +680,7 @@ func readPowerLimit(device *NvidiaCollectorDevice, output chan lp.CCMessage) err // If the card's total power draw reaches this limit the power management algorithm kicks in. pwr_limit, ret := nvml.DeviceGetPowerManagementLimit(device.device) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_power_max_limit", device.tags, device.meta, map[string]interface{}{"value": float64(pwr_limit) / 1000}, time.Now()) + y, err := lp.NewMessage("nv_power_max_limit", device.tags, device.meta, map[string]any{"value": float64(pwr_limit) / 1000}, time.Now()) if err == nil { y.AddMeta("unit", "watts") output <- y @@ -707,7 +707,7 @@ func readEncUtilization(device *NvidiaCollectorDevice, output chan lp.CCMessage) // Note: On MIG-enabled GPUs, querying encoder utilization is not currently supported. enc_util, _, ret := nvml.DeviceGetEncoderUtilization(device.device) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_encoder_util", device.tags, device.meta, map[string]interface{}{"value": float64(enc_util)}, time.Now()) + y, err := lp.NewMessage("nv_encoder_util", device.tags, device.meta, map[string]any{"value": float64(enc_util)}, time.Now()) if err == nil { y.AddMeta("unit", "%") output <- y @@ -734,7 +734,7 @@ func readDecUtilization(device *NvidiaCollectorDevice, output chan lp.CCMessage) // Note: On MIG-enabled GPUs, querying encoder utilization is not currently supported. dec_util, _, ret := nvml.DeviceGetDecoderUtilization(device.device) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_decoder_util", device.tags, device.meta, map[string]interface{}{"value": float64(dec_util)}, time.Now()) + y, err := lp.NewMessage("nv_decoder_util", device.tags, device.meta, map[string]any{"value": float64(dec_util)}, time.Now()) if err == nil { y.AddMeta("unit", "%") output <- y @@ -761,13 +761,13 @@ func readRemappedRows(device *NvidiaCollectorDevice, output chan lp.CCMessage) e corrected, uncorrected, pending, failure, ret := nvml.DeviceGetRemappedRows(device.device) if ret == nvml.SUCCESS { if !device.excludeMetrics["nv_remapped_rows_corrected"] { - y, err := lp.NewMessage("nv_remapped_rows_corrected", device.tags, device.meta, map[string]interface{}{"value": float64(corrected)}, time.Now()) + y, err := lp.NewMessage("nv_remapped_rows_corrected", device.tags, device.meta, map[string]any{"value": float64(corrected)}, time.Now()) if err == nil { output <- y } } if !device.excludeMetrics["nv_remapped_rows_uncorrected"] { - y, err := lp.NewMessage("nv_remapped_rows_corrected", device.tags, device.meta, map[string]interface{}{"value": float64(uncorrected)}, time.Now()) + y, err := lp.NewMessage("nv_remapped_rows_corrected", device.tags, device.meta, map[string]any{"value": float64(uncorrected)}, time.Now()) if err == nil { output <- y } @@ -777,7 +777,7 @@ func readRemappedRows(device *NvidiaCollectorDevice, output chan lp.CCMessage) e if pending { p = 1 } - y, err := lp.NewMessage("nv_remapped_rows_pending", device.tags, device.meta, map[string]interface{}{"value": p}, time.Now()) + y, err := lp.NewMessage("nv_remapped_rows_pending", device.tags, device.meta, map[string]any{"value": p}, time.Now()) if err == nil { output <- y } @@ -787,7 +787,7 @@ func readRemappedRows(device *NvidiaCollectorDevice, output chan lp.CCMessage) e if failure { f = 1 } - y, err := lp.NewMessage("nv_remapped_rows_failure", device.tags, device.meta, map[string]interface{}{"value": f}, time.Now()) + y, err := lp.NewMessage("nv_remapped_rows_failure", device.tags, device.meta, map[string]any{"value": f}, time.Now()) if err == nil { output <- y } @@ -821,7 +821,7 @@ func readProcessCounts(device *NvidiaCollectorDevice, output chan lp.CCMessage) // Querying per-instance information using MIG device handles is not supported if the device is in vGPU Host virtualization mode. procList, ret := nvml.DeviceGetComputeRunningProcesses(device.device) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_compute_processes", device.tags, device.meta, map[string]interface{}{"value": len(procList)}, time.Now()) + y, err := lp.NewMessage("nv_compute_processes", device.tags, device.meta, map[string]any{"value": len(procList)}, time.Now()) if err == nil { output <- y } @@ -850,7 +850,7 @@ func readProcessCounts(device *NvidiaCollectorDevice, output chan lp.CCMessage) // Querying per-instance information using MIG device handles is not supported if the device is in vGPU Host virtualization mode. procList, ret := nvml.DeviceGetGraphicsRunningProcesses(device.device) if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_graphics_processes", device.tags, device.meta, map[string]interface{}{"value": len(procList)}, time.Now()) + y, err := lp.NewMessage("nv_graphics_processes", device.tags, device.meta, map[string]any{"value": len(procList)}, time.Now()) if err == nil { output <- y } @@ -908,7 +908,7 @@ func readViolationStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_POWER) if ret == nvml.SUCCESS { t := float64(violTime.ViolationTime) * 1e-9 - y, err := lp.NewMessage("nv_violation_power", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now()) + y, err := lp.NewMessage("nv_violation_power", device.tags, device.meta, map[string]any{"value": t}, time.Now()) if err == nil { y.AddMeta("unit", "sec") output <- y @@ -920,7 +920,7 @@ func readViolationStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_THERMAL) if ret == nvml.SUCCESS { t := float64(violTime.ViolationTime) * 1e-9 - y, err := lp.NewMessage("nv_violation_thermal", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now()) + y, err := lp.NewMessage("nv_violation_thermal", device.tags, device.meta, map[string]any{"value": t}, time.Now()) if err == nil { y.AddMeta("unit", "sec") output <- y @@ -932,7 +932,7 @@ func readViolationStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_SYNC_BOOST) if ret == nvml.SUCCESS { t := float64(violTime.ViolationTime) * 1e-9 - y, err := lp.NewMessage("nv_violation_sync_boost", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now()) + y, err := lp.NewMessage("nv_violation_sync_boost", device.tags, device.meta, map[string]any{"value": t}, time.Now()) if err == nil { y.AddMeta("unit", "sec") output <- y @@ -944,7 +944,7 @@ func readViolationStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_BOARD_LIMIT) if ret == nvml.SUCCESS { t := float64(violTime.ViolationTime) * 1e-9 - y, err := lp.NewMessage("nv_violation_board_limit", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now()) + y, err := lp.NewMessage("nv_violation_board_limit", device.tags, device.meta, map[string]any{"value": t}, time.Now()) if err == nil { y.AddMeta("unit", "sec") output <- y @@ -956,7 +956,7 @@ func readViolationStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_LOW_UTILIZATION) if ret == nvml.SUCCESS { t := float64(violTime.ViolationTime) * 1e-9 - y, err := lp.NewMessage("nv_violation_low_util", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now()) + y, err := lp.NewMessage("nv_violation_low_util", device.tags, device.meta, map[string]any{"value": t}, time.Now()) if err == nil { y.AddMeta("unit", "sec") output <- y @@ -968,7 +968,7 @@ func readViolationStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_RELIABILITY) if ret == nvml.SUCCESS { t := float64(violTime.ViolationTime) * 1e-9 - y, err := lp.NewMessage("nv_violation_reliability", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now()) + y, err := lp.NewMessage("nv_violation_reliability", device.tags, device.meta, map[string]any{"value": t}, time.Now()) if err == nil { y.AddMeta("unit", "sec") output <- y @@ -980,7 +980,7 @@ func readViolationStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_TOTAL_APP_CLOCKS) if ret == nvml.SUCCESS { t := float64(violTime.ViolationTime) * 1e-9 - y, err := lp.NewMessage("nv_violation_below_app_clock", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now()) + y, err := lp.NewMessage("nv_violation_below_app_clock", device.tags, device.meta, map[string]any{"value": t}, time.Now()) if err == nil { y.AddMeta("unit", "sec") output <- y @@ -992,7 +992,7 @@ func readViolationStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_TOTAL_BASE_CLOCKS) if ret == nvml.SUCCESS { t := float64(violTime.ViolationTime) * 1e-9 - y, err := lp.NewMessage("nv_violation_below_base_clock", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now()) + y, err := lp.NewMessage("nv_violation_below_base_clock", device.tags, device.meta, map[string]any{"value": t}, time.Now()) if err == nil { y.AddMeta("unit", "sec") output <- y @@ -1015,7 +1015,7 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er var aggregate_recovery_errors uint64 = 0 var aggregate_crc_flit_errors uint64 = 0 - for i := 0; i < nvml.NVLINK_MAX_LINKS; i++ { + for i := range nvml.NVLINK_MAX_LINKS { state, ret := nvml.DeviceGetNvLinkState(device.device, i) if ret == nvml.SUCCESS { if state == nvml.FEATURE_ENABLED { @@ -1024,7 +1024,7 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_CRC_DATA) aggregate_crc_errors = aggregate_crc_errors + count if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_nvlink_crc_errors", device.tags, device.meta, map[string]interface{}{"value": count}, time.Now()) + y, err := lp.NewMessage("nv_nvlink_crc_errors", device.tags, device.meta, map[string]any{"value": count}, time.Now()) if err == nil { y.AddTag("stype", "nvlink") y.AddTag("stype-id", fmt.Sprintf("%d", i)) @@ -1037,7 +1037,7 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_ECC_DATA) aggregate_ecc_errors = aggregate_ecc_errors + count if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_nvlink_ecc_errors", device.tags, device.meta, map[string]interface{}{"value": count}, time.Now()) + y, err := lp.NewMessage("nv_nvlink_ecc_errors", device.tags, device.meta, map[string]any{"value": count}, time.Now()) if err == nil { y.AddTag("stype", "nvlink") y.AddTag("stype-id", fmt.Sprintf("%d", i)) @@ -1050,7 +1050,7 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_REPLAY) aggregate_replay_errors = aggregate_replay_errors + count if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_nvlink_replay_errors", device.tags, device.meta, map[string]interface{}{"value": count}, time.Now()) + y, err := lp.NewMessage("nv_nvlink_replay_errors", device.tags, device.meta, map[string]any{"value": count}, time.Now()) if err == nil { y.AddTag("stype", "nvlink") y.AddTag("stype-id", fmt.Sprintf("%d", i)) @@ -1063,7 +1063,7 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_RECOVERY) aggregate_recovery_errors = aggregate_recovery_errors + count if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_nvlink_recovery_errors", device.tags, device.meta, map[string]interface{}{"value": count}, time.Now()) + y, err := lp.NewMessage("nv_nvlink_recovery_errors", device.tags, device.meta, map[string]any{"value": count}, time.Now()) if err == nil { y.AddTag("stype", "nvlink") y.AddTag("stype-id", fmt.Sprintf("%d", i)) @@ -1076,7 +1076,7 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_CRC_FLIT) aggregate_crc_flit_errors = aggregate_crc_flit_errors + count if ret == nvml.SUCCESS { - y, err := lp.NewMessage("nv_nvlink_crc_flit_errors", device.tags, device.meta, map[string]interface{}{"value": count}, time.Now()) + y, err := lp.NewMessage("nv_nvlink_crc_flit_errors", device.tags, device.meta, map[string]any{"value": count}, time.Now()) if err == nil { y.AddTag("stype", "nvlink") y.AddTag("stype-id", fmt.Sprintf("%d", i)) @@ -1091,7 +1091,7 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er // Export aggegated values if !device.excludeMetrics["nv_nvlink_crc_errors"] { // Data link receive data CRC error counter - y, err := lp.NewMessage("nv_nvlink_crc_errors_sum", device.tags, device.meta, map[string]interface{}{"value": aggregate_crc_errors}, time.Now()) + y, err := lp.NewMessage("nv_nvlink_crc_errors_sum", device.tags, device.meta, map[string]any{"value": aggregate_crc_errors}, time.Now()) if err == nil { y.AddTag("stype", "nvlink") output <- y @@ -1099,7 +1099,7 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er } if !device.excludeMetrics["nv_nvlink_ecc_errors"] { // Data link receive data ECC error counter - y, err := lp.NewMessage("nv_nvlink_ecc_errors_sum", device.tags, device.meta, map[string]interface{}{"value": aggregate_ecc_errors}, time.Now()) + y, err := lp.NewMessage("nv_nvlink_ecc_errors_sum", device.tags, device.meta, map[string]any{"value": aggregate_ecc_errors}, time.Now()) if err == nil { y.AddTag("stype", "nvlink") output <- y @@ -1107,7 +1107,7 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er } if !device.excludeMetrics["nv_nvlink_replay_errors"] { // Data link transmit replay error counter - y, err := lp.NewMessage("nv_nvlink_replay_errors_sum", device.tags, device.meta, map[string]interface{}{"value": aggregate_replay_errors}, time.Now()) + y, err := lp.NewMessage("nv_nvlink_replay_errors_sum", device.tags, device.meta, map[string]any{"value": aggregate_replay_errors}, time.Now()) if err == nil { y.AddTag("stype", "nvlink") output <- y @@ -1115,7 +1115,7 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er } if !device.excludeMetrics["nv_nvlink_recovery_errors"] { // Data link transmit recovery error counter - y, err := lp.NewMessage("nv_nvlink_recovery_errors_sum", device.tags, device.meta, map[string]interface{}{"value": aggregate_recovery_errors}, time.Now()) + y, err := lp.NewMessage("nv_nvlink_recovery_errors_sum", device.tags, device.meta, map[string]any{"value": aggregate_recovery_errors}, time.Now()) if err == nil { y.AddTag("stype", "nvlink") output <- y @@ -1123,7 +1123,7 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er } if !device.excludeMetrics["nv_nvlink_crc_flit_errors"] { // Data link receive flow control digit CRC error counter - y, err := lp.NewMessage("nv_nvlink_crc_flit_errors_sum", device.tags, device.meta, map[string]interface{}{"value": aggregate_crc_flit_errors}, time.Now()) + y, err := lp.NewMessage("nv_nvlink_crc_flit_errors_sum", device.tags, device.meta, map[string]any{"value": aggregate_crc_flit_errors}, time.Now()) if err == nil { y.AddTag("stype", "nvlink") output <- y @@ -1263,7 +1263,7 @@ func (m *NvidiaCollector) Read(interval time.Duration, output chan lp.CCMessage) } cclog.ComponentDebug(m.name, "Reading MIG devices for GPU", i) - for j := 0; j < maxMig; j++ { + for j := range maxMig { mdev, ret := nvml.DeviceGetMigDeviceHandleByIndex(m.gpus[i].device, j) if ret != nvml.SUCCESS { continue diff --git a/collectors/raplMetric.go b/collectors/raplMetric.go index f46aadf..e3d07fd 100644 --- a/collectors/raplMetric.go +++ b/collectors/raplMetric.go @@ -249,7 +249,7 @@ func (m *RAPLCollector) Read(interval time.Duration, output chan lp.CCMessage) { "rapl_average_power", p.tags, m.meta, - map[string]interface{}{"value": averagePower}, + map[string]any{"value": averagePower}, energyTimestamp) if err == nil { output <- y diff --git a/collectors/rocmsmiMetric.go b/collectors/rocmsmiMetric.go index 80fe502..c64a726 100644 --- a/collectors/rocmsmiMetric.go +++ b/collectors/rocmsmiMetric.go @@ -11,6 +11,7 @@ import ( "encoding/json" "errors" "fmt" + "slices" "time" cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger" @@ -87,22 +88,11 @@ func (m *RocmSmiCollector) Init(config json.RawMessage) error { return err } - exclDev := func(s string) bool { - skip_device := false - for _, excl := range m.config.ExcludeDevices { - if excl == s { - skip_device = true - break - } - } - return skip_device - } - m.devices = make([]RocmSmiCollectorDevice, 0) - for i := 0; i < numDevs; i++ { + for i := range numDevs { str_i := fmt.Sprintf("%d", i) - if exclDev(str_i) { + if slices.Contains(m.config.ExcludeDevices, str_i) { continue } device, ret := rocm_smi.DeviceGetHandleByIndex(i) @@ -126,7 +116,7 @@ func (m *RocmSmiCollector) Init(config json.RawMessage) error { pciInfo.Device, pciInfo.Function) - if exclDev(pciId) { + if slices.Contains(m.config.ExcludeDevices, pciId) { continue } @@ -184,127 +174,127 @@ func (m *RocmSmiCollector) Read(interval time.Duration, output chan lp.CCMessage if !dev.excludeMetrics["rocm_gfx_util"] { value := metrics.Average_gfx_activity - y, err := lp.NewMessage("rocm_gfx_util", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_gfx_util", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_umc_util"] { value := metrics.Average_umc_activity - y, err := lp.NewMessage("rocm_umc_util", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_umc_util", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_mm_util"] { value := metrics.Average_mm_activity - y, err := lp.NewMessage("rocm_mm_util", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_mm_util", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_avg_power"] { value := metrics.Average_socket_power - y, err := lp.NewMessage("rocm_avg_power", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_avg_power", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_temp_mem"] { value := metrics.Temperature_mem - y, err := lp.NewMessage("rocm_temp_mem", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_temp_mem", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_temp_hotspot"] { value := metrics.Temperature_hotspot - y, err := lp.NewMessage("rocm_temp_hotspot", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_temp_hotspot", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_temp_edge"] { value := metrics.Temperature_edge - y, err := lp.NewMessage("rocm_temp_edge", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_temp_edge", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_temp_vrgfx"] { value := metrics.Temperature_vrgfx - y, err := lp.NewMessage("rocm_temp_vrgfx", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_temp_vrgfx", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_temp_vrsoc"] { value := metrics.Temperature_vrsoc - y, err := lp.NewMessage("rocm_temp_vrsoc", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_temp_vrsoc", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_temp_vrmem"] { value := metrics.Temperature_vrmem - y, err := lp.NewMessage("rocm_temp_vrmem", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_temp_vrmem", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_gfx_clock"] { value := metrics.Average_gfxclk_frequency - y, err := lp.NewMessage("rocm_gfx_clock", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_gfx_clock", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_soc_clock"] { value := metrics.Average_socclk_frequency - y, err := lp.NewMessage("rocm_soc_clock", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_soc_clock", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_u_clock"] { value := metrics.Average_uclk_frequency - y, err := lp.NewMessage("rocm_u_clock", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_u_clock", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_v0_clock"] { value := metrics.Average_vclk0_frequency - y, err := lp.NewMessage("rocm_v0_clock", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_v0_clock", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_v1_clock"] { value := metrics.Average_vclk1_frequency - y, err := lp.NewMessage("rocm_v1_clock", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_v1_clock", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_d0_clock"] { value := metrics.Average_dclk0_frequency - y, err := lp.NewMessage("rocm_d0_clock", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_d0_clock", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_d1_clock"] { value := metrics.Average_dclk1_frequency - y, err := lp.NewMessage("rocm_d1_clock", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_d1_clock", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { output <- y } } if !dev.excludeMetrics["rocm_temp_hbm"] { - for i := 0; i < rocm_smi.NUM_HBM_INSTANCES; i++ { + for i := range rocm_smi.NUM_HBM_INSTANCES { value := metrics.Temperature_hbm[i] - y, err := lp.NewMessage("rocm_temp_hbm", dev.tags, dev.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("rocm_temp_hbm", dev.tags, dev.meta, map[string]any{"value": value}, timestamp) if err == nil { y.AddTag("stype", "device") y.AddTag("stype-id", fmt.Sprintf("%d", i)) diff --git a/collectors/rocmsmiMetric.md b/collectors/rocmsmiMetric.md index ca440ab..0d5440e 100644 --- a/collectors/rocmsmiMetric.md +++ b/collectors/rocmsmiMetric.md @@ -15,7 +15,9 @@ hugo_path: docs/reference/cc-metric-collector/collectors/rocmsmi.md ```json "rocm_smi": { "exclude_devices": [ - "0","1", "0000000:ff:01.0" + "0", + "1", + "0000000:ff:01.0" ], "exclude_metrics": [ "rocm_mm_util", @@ -23,7 +25,7 @@ hugo_path: docs/reference/cc-metric-collector/collectors/rocmsmi.md ], "use_pci_info_as_type_id": true, "add_pci_info_tag": false, - "add_serial_meta": false, + "add_serial_meta": false } ``` diff --git a/collectors/sampleMetric.go b/collectors/sampleMetric.go index 4303107..67dded8 100644 --- a/collectors/sampleMetric.go +++ b/collectors/sampleMetric.go @@ -95,7 +95,7 @@ func (m *SampleCollector) Read(interval time.Duration, output chan lp.CCMessage) // stop := readState() // value = (stop - start) / interval.Seconds() - y, err := lp.NewMessage("sample_metric", m.tags, m.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("sample_metric", m.tags, m.meta, map[string]any{"value": value}, timestamp) if err == nil { // Send it to output channel output <- y diff --git a/collectors/sampleTimerMetric.go b/collectors/sampleTimerMetric.go index cb597bf..0f00f50 100644 --- a/collectors/sampleTimerMetric.go +++ b/collectors/sampleTimerMetric.go @@ -110,7 +110,7 @@ func (m *SampleTimerCollector) ReadMetrics(timestamp time.Time) { // stop := readState() // value = (stop - start) / interval.Seconds() - y, err := lp.NewMessage("sample_metric", m.tags, m.meta, map[string]interface{}{"value": value}, timestamp) + y, err := lp.NewMessage("sample_metric", m.tags, m.meta, map[string]any{"value": value}, timestamp) if err == nil && m.output != nil { // Send it to output channel if we have a valid channel m.output <- y diff --git a/collectors/schedstatMetric.go b/collectors/schedstatMetric.go index d34e5cc..f3dc2ae 100644 --- a/collectors/schedstatMetric.go +++ b/collectors/schedstatMetric.go @@ -123,7 +123,7 @@ func (m *SchedstatCollector) ParseProcLine(linefields []string, tags map[string] m.olddata[linefields[0]]["waiting"] = waiting value := l_running + l_waiting - y, err := lp.NewMessage("cpu_load_core", tags, m.meta, map[string]interface{}{"value": value}, now) + y, err := lp.NewMessage("cpu_load_core", tags, m.meta, map[string]any{"value": value}, now) if err == nil { // Send it to output channel output <- y diff --git a/collectors/selfMetric.go b/collectors/selfMetric.go index 9c77db7..ab29b28 100644 --- a/collectors/selfMetric.go +++ b/collectors/selfMetric.go @@ -59,49 +59,49 @@ func (m *SelfCollector) Read(interval time.Duration, output chan lp.CCMessage) { var memstats runtime.MemStats runtime.ReadMemStats(&memstats) - y, err := lp.NewMessage("total_alloc", m.tags, m.meta, map[string]interface{}{"value": memstats.TotalAlloc}, timestamp) + y, err := lp.NewMessage("total_alloc", m.tags, m.meta, map[string]any{"value": memstats.TotalAlloc}, timestamp) if err == nil { y.AddMeta("unit", "Bytes") output <- y } - y, err = lp.NewMessage("heap_alloc", m.tags, m.meta, map[string]interface{}{"value": memstats.HeapAlloc}, timestamp) + y, err = lp.NewMessage("heap_alloc", m.tags, m.meta, map[string]any{"value": memstats.HeapAlloc}, timestamp) if err == nil { y.AddMeta("unit", "Bytes") output <- y } - y, err = lp.NewMessage("heap_sys", m.tags, m.meta, map[string]interface{}{"value": memstats.HeapSys}, timestamp) + y, err = lp.NewMessage("heap_sys", m.tags, m.meta, map[string]any{"value": memstats.HeapSys}, timestamp) if err == nil { y.AddMeta("unit", "Bytes") output <- y } - y, err = lp.NewMessage("heap_idle", m.tags, m.meta, map[string]interface{}{"value": memstats.HeapIdle}, timestamp) + y, err = lp.NewMessage("heap_idle", m.tags, m.meta, map[string]any{"value": memstats.HeapIdle}, timestamp) if err == nil { y.AddMeta("unit", "Bytes") output <- y } - y, err = lp.NewMessage("heap_inuse", m.tags, m.meta, map[string]interface{}{"value": memstats.HeapInuse}, timestamp) + y, err = lp.NewMessage("heap_inuse", m.tags, m.meta, map[string]any{"value": memstats.HeapInuse}, timestamp) if err == nil { y.AddMeta("unit", "Bytes") output <- y } - y, err = lp.NewMessage("heap_released", m.tags, m.meta, map[string]interface{}{"value": memstats.HeapReleased}, timestamp) + y, err = lp.NewMessage("heap_released", m.tags, m.meta, map[string]any{"value": memstats.HeapReleased}, timestamp) if err == nil { y.AddMeta("unit", "Bytes") output <- y } - y, err = lp.NewMessage("heap_objects", m.tags, m.meta, map[string]interface{}{"value": memstats.HeapObjects}, timestamp) + y, err = lp.NewMessage("heap_objects", m.tags, m.meta, map[string]any{"value": memstats.HeapObjects}, timestamp) if err == nil { output <- y } } if m.config.GoRoutines { - y, err := lp.NewMessage("num_goroutines", m.tags, m.meta, map[string]interface{}{"value": runtime.NumGoroutine()}, timestamp) + y, err := lp.NewMessage("num_goroutines", m.tags, m.meta, map[string]any{"value": runtime.NumGoroutine()}, timestamp) if err == nil { output <- y } } if m.config.CgoCalls { - y, err := lp.NewMessage("num_cgo_calls", m.tags, m.meta, map[string]interface{}{"value": runtime.NumCgoCall()}, timestamp) + y, err := lp.NewMessage("num_cgo_calls", m.tags, m.meta, map[string]any{"value": runtime.NumCgoCall()}, timestamp) if err == nil { output <- y } @@ -112,35 +112,35 @@ func (m *SelfCollector) Read(interval time.Duration, output chan lp.CCMessage) { if err == nil { sec, nsec := rusage.Utime.Unix() t := float64(sec) + (float64(nsec) * 1e-9) - y, err := lp.NewMessage("rusage_user_time", m.tags, m.meta, map[string]interface{}{"value": t}, timestamp) + y, err := lp.NewMessage("rusage_user_time", m.tags, m.meta, map[string]any{"value": t}, timestamp) if err == nil { y.AddMeta("unit", "seconds") output <- y } sec, nsec = rusage.Stime.Unix() t = float64(sec) + (float64(nsec) * 1e-9) - y, err = lp.NewMessage("rusage_system_time", m.tags, m.meta, map[string]interface{}{"value": t}, timestamp) + y, err = lp.NewMessage("rusage_system_time", m.tags, m.meta, map[string]any{"value": t}, timestamp) if err == nil { y.AddMeta("unit", "seconds") output <- y } - y, err = lp.NewMessage("rusage_vol_ctx_switch", m.tags, m.meta, map[string]interface{}{"value": rusage.Nvcsw}, timestamp) + y, err = lp.NewMessage("rusage_vol_ctx_switch", m.tags, m.meta, map[string]any{"value": rusage.Nvcsw}, timestamp) if err == nil { output <- y } - y, err = lp.NewMessage("rusage_invol_ctx_switch", m.tags, m.meta, map[string]interface{}{"value": rusage.Nivcsw}, timestamp) + y, err = lp.NewMessage("rusage_invol_ctx_switch", m.tags, m.meta, map[string]any{"value": rusage.Nivcsw}, timestamp) if err == nil { output <- y } - y, err = lp.NewMessage("rusage_signals", m.tags, m.meta, map[string]interface{}{"value": rusage.Nsignals}, timestamp) + y, err = lp.NewMessage("rusage_signals", m.tags, m.meta, map[string]any{"value": rusage.Nsignals}, timestamp) if err == nil { output <- y } - y, err = lp.NewMessage("rusage_major_pgfaults", m.tags, m.meta, map[string]interface{}{"value": rusage.Majflt}, timestamp) + y, err = lp.NewMessage("rusage_major_pgfaults", m.tags, m.meta, map[string]any{"value": rusage.Majflt}, timestamp) if err == nil { output <- y } - y, err = lp.NewMessage("rusage_minor_pgfaults", m.tags, m.meta, map[string]interface{}{"value": rusage.Minflt}, timestamp) + y, err = lp.NewMessage("rusage_minor_pgfaults", m.tags, m.meta, map[string]any{"value": rusage.Minflt}, timestamp) if err == nil { output <- y } diff --git a/collectors/slurmCgroupMetric.go b/collectors/slurmCgroupMetric.go index 2759709..8a2c492 100644 --- a/collectors/slurmCgroupMetric.go +++ b/collectors/slurmCgroupMetric.go @@ -257,7 +257,7 @@ func (m *SlurmCgroupCollector) Read(interval time.Duration, output chan lp.CCMes if coreCount > 0 && !m.isExcluded("job_mem_used") { memPerCore := jobdata.MemoryUsage / coreCount - if y, err := lp.NewMessage("job_mem_used", coreTags, m.meta, map[string]interface{}{"value": memPerCore}, timestamp); err == nil { + if y, err := lp.NewMessage("job_mem_used", coreTags, m.meta, map[string]any{"value": memPerCore}, timestamp); err == nil { y.AddMeta("unit", "Bytes") output <- y } @@ -265,7 +265,7 @@ func (m *SlurmCgroupCollector) Read(interval time.Duration, output chan lp.CCMes if coreCount > 0 && !m.isExcluded("job_max_mem_used") { maxMemPerCore := jobdata.MaxMemoryUsage / coreCount - if y, err := lp.NewMessage("job_max_mem_used", coreTags, m.meta, map[string]interface{}{"value": maxMemPerCore}, timestamp); err == nil { + if y, err := lp.NewMessage("job_max_mem_used", coreTags, m.meta, map[string]any{"value": maxMemPerCore}, timestamp); err == nil { y.AddMeta("unit", "Bytes") output <- y } @@ -273,7 +273,7 @@ func (m *SlurmCgroupCollector) Read(interval time.Duration, output chan lp.CCMes if coreCount > 0 && !m.isExcluded("job_mem_limit") { limitPerCore := jobdata.LimitMemoryUsage / coreCount - if y, err := lp.NewMessage("job_mem_limit", coreTags, m.meta, map[string]interface{}{"value": limitPerCore}, timestamp); err == nil { + if y, err := lp.NewMessage("job_mem_limit", coreTags, m.meta, map[string]any{"value": limitPerCore}, timestamp); err == nil { y.AddMeta("unit", "Bytes") output <- y } @@ -281,7 +281,7 @@ func (m *SlurmCgroupCollector) Read(interval time.Duration, output chan lp.CCMes if coreCount > 0 && !m.isExcluded("job_user_cpu") { cpuUserPerCore := jobdata.CpuUsageUser / coreCount - if y, err := lp.NewMessage("job_user_cpu", coreTags, m.meta, map[string]interface{}{"value": cpuUserPerCore}, timestamp); err == nil { + if y, err := lp.NewMessage("job_user_cpu", coreTags, m.meta, map[string]any{"value": cpuUserPerCore}, timestamp); err == nil { y.AddMeta("unit", "%") output <- y } @@ -289,7 +289,7 @@ func (m *SlurmCgroupCollector) Read(interval time.Duration, output chan lp.CCMes if coreCount > 0 && !m.isExcluded("job_sys_cpu") { cpuSysPerCore := jobdata.CpuUsageSys / coreCount - if y, err := lp.NewMessage("job_sys_cpu", coreTags, m.meta, map[string]interface{}{"value": cpuSysPerCore}, timestamp); err == nil { + if y, err := lp.NewMessage("job_sys_cpu", coreTags, m.meta, map[string]any{"value": cpuSysPerCore}, timestamp); err == nil { y.AddMeta("unit", "%") output <- y } @@ -308,35 +308,35 @@ func (m *SlurmCgroupCollector) Read(interval time.Duration, output chan lp.CCMes } if !m.isExcluded("job_mem_used") { - if y, err := lp.NewMessage("job_mem_used", coreTags, m.meta, map[string]interface{}{"value": 0}, timestamp); err == nil { + if y, err := lp.NewMessage("job_mem_used", coreTags, m.meta, map[string]any{"value": 0}, timestamp); err == nil { y.AddMeta("unit", "Bytes") output <- y } } if !m.isExcluded("job_max_mem_used") { - if y, err := lp.NewMessage("job_max_mem_used", coreTags, m.meta, map[string]interface{}{"value": 0}, timestamp); err == nil { + if y, err := lp.NewMessage("job_max_mem_used", coreTags, m.meta, map[string]any{"value": 0}, timestamp); err == nil { y.AddMeta("unit", "Bytes") output <- y } } if !m.isExcluded("job_mem_limit") { - if y, err := lp.NewMessage("job_mem_limit", coreTags, m.meta, map[string]interface{}{"value": 0}, timestamp); err == nil { + if y, err := lp.NewMessage("job_mem_limit", coreTags, m.meta, map[string]any{"value": 0}, timestamp); err == nil { y.AddMeta("unit", "Bytes") output <- y } } if !m.isExcluded("job_user_cpu") { - if y, err := lp.NewMessage("job_user_cpu", coreTags, m.meta, map[string]interface{}{"value": 0}, timestamp); err == nil { + if y, err := lp.NewMessage("job_user_cpu", coreTags, m.meta, map[string]any{"value": 0}, timestamp); err == nil { y.AddMeta("unit", "%") output <- y } } if !m.isExcluded("job_sys_cpu") { - if y, err := lp.NewMessage("job_sys_cpu", coreTags, m.meta, map[string]interface{}{"value": 0}, timestamp); err == nil { + if y, err := lp.NewMessage("job_sys_cpu", coreTags, m.meta, map[string]any{"value": 0}, timestamp); err == nil { y.AddMeta("unit", "%") output <- y } diff --git a/collectors/tempMetric.go b/collectors/tempMetric.go index 3471992..26e4573 100644 --- a/collectors/tempMetric.go +++ b/collectors/tempMetric.go @@ -203,7 +203,7 @@ func (m *TempCollector) Read(interval time.Duration, output chan lp.CCMessage) { sensor.metricName, sensor.tags, m.meta, - map[string]interface{}{"value": x}, + map[string]any{"value": x}, time.Now(), ) if err == nil { @@ -216,7 +216,7 @@ func (m *TempCollector) Read(interval time.Duration, output chan lp.CCMessage) { sensor.maxTempName, sensor.tags, m.meta, - map[string]interface{}{"value": sensor.maxTemp}, + map[string]any{"value": sensor.maxTemp}, time.Now(), ) if err == nil { @@ -230,7 +230,7 @@ func (m *TempCollector) Read(interval time.Duration, output chan lp.CCMessage) { sensor.critTempName, sensor.tags, m.meta, - map[string]interface{}{"value": sensor.critTemp}, + map[string]any{"value": sensor.critTemp}, time.Now(), ) if err == nil { diff --git a/collectors/topprocsMetric.go b/collectors/topprocsMetric.go index 923daaa..aa9dcf2 100644 --- a/collectors/topprocsMetric.go +++ b/collectors/topprocsMetric.go @@ -81,7 +81,7 @@ func (m *TopProcsCollector) Read(interval time.Duration, output chan lp.CCMessag lines := strings.Split(string(stdout), "\n") for i := 1; i < m.config.Num_procs+1; i++ { name := fmt.Sprintf("topproc%d", i) - y, err := lp.NewMessage(name, m.tags, m.meta, map[string]interface{}{"value": string(lines[i])}, time.Now()) + y, err := lp.NewMessage(name, m.tags, m.meta, map[string]any{"value": string(lines[i])}, time.Now()) if err == nil { output <- y } diff --git a/internal/metricAggregator/metricAggregator.go b/internal/metricAggregator/metricAggregator.go index ae4d8b5..4c2d6b1 100644 --- a/internal/metricAggregator/metricAggregator.go +++ b/internal/metricAggregator/metricAggregator.go @@ -13,6 +13,7 @@ import ( "maps" "math" "os" + "slices" "strings" "sync" "time" @@ -37,7 +38,7 @@ type MetricAggregatorIntervalConfig struct { type metricAggregator struct { functions []*MetricAggregatorIntervalConfig - constants map[string]interface{} + constants map[string]any language gval.Language output chan lp.CCMessage } @@ -85,7 +86,7 @@ var evaluables = struct { func (c *metricAggregator) Init(output chan lp.CCMessage) error { c.output = output c.functions = make([]*MetricAggregatorIntervalConfig, 0) - c.constants = make(map[string]interface{}) + c.constants = make(map[string]any) // add constants like hostname, numSockets, ... to constants list // Set hostname @@ -121,7 +122,7 @@ func (c *metricAggregator) Init(output chan lp.CCMessage) error { } func (c *metricAggregator) Eval(starttime time.Time, endtime time.Time, metrics []lp.CCMessage) { - vars := make(map[string]interface{}) + vars := make(map[string]any) maps.Copy(vars, c.constants) vars["starttime"] = starttime vars["endtime"] = endtime @@ -262,15 +263,15 @@ func (c *metricAggregator) Eval(starttime time.Time, endtime time.Time, metrics var m lp.CCMessage switch t := value.(type) { case float64: - m, err = lp.NewMessage(f.Name, tags, meta, map[string]interface{}{"value": t}, starttime) + m, err = lp.NewMessage(f.Name, tags, meta, map[string]any{"value": t}, starttime) case float32: - m, err = lp.NewMessage(f.Name, tags, meta, map[string]interface{}{"value": t}, starttime) + m, err = lp.NewMessage(f.Name, tags, meta, map[string]any{"value": t}, starttime) case int: - m, err = lp.NewMessage(f.Name, tags, meta, map[string]interface{}{"value": t}, starttime) + m, err = lp.NewMessage(f.Name, tags, meta, map[string]any{"value": t}, starttime) case int64: - m, err = lp.NewMessage(f.Name, tags, meta, map[string]interface{}{"value": t}, starttime) + m, err = lp.NewMessage(f.Name, tags, meta, map[string]any{"value": t}, starttime) case string: - m, err = lp.NewMessage(f.Name, tags, meta, map[string]interface{}{"value": t}, starttime) + m, err = lp.NewMessage(f.Name, tags, meta, map[string]any{"value": t}, starttime) default: cclog.ComponentError("MetricCache", "Gval returned invalid type", t, "skipping metric", f.Name) } @@ -328,18 +329,19 @@ func (c *metricAggregator) AddAggregation(name, function, condition string, tags } func (c *metricAggregator) DeleteAggregation(name string) error { - for i, agg := range c.functions { - if agg.Name == name { - copy(c.functions[i:], c.functions[i+1:]) - c.functions[len(c.functions)-1] = nil - c.functions = c.functions[:len(c.functions)-1] - return nil - } + i := slices.IndexFunc( + c.functions, + func(agg *MetricAggregatorIntervalConfig) bool { + return agg.Name == name + }) + if i == -1 { + return fmt.Errorf("no aggregation for metric name %s", name) } - return fmt.Errorf("no aggregation for metric name %s", name) + c.functions = slices.Delete(c.functions, i, i) + return nil } -func (c *metricAggregator) AddConstant(name string, value interface{}) { +func (c *metricAggregator) AddConstant(name string, value any) { c.constants[name] = value } @@ -347,11 +349,11 @@ func (c *metricAggregator) DelConstant(name string) { delete(c.constants, name) } -func (c *metricAggregator) AddFunction(name string, function func(args ...interface{}) (interface{}, error)) { +func (c *metricAggregator) AddFunction(name string, function func(args ...any) (any, error)) { c.language = gval.NewLanguage(c.language, gval.Function(name, function)) } -func EvalBoolCondition(condition string, params map[string]interface{}) (bool, error) { +func EvalBoolCondition(condition string, params map[string]any) (bool, error) { evaluables.mutex.Lock() evaluable, ok := evaluables.mapping[condition] evaluables.mutex.Unlock() diff --git a/internal/metricAggregator/metricAggregatorFunctions.go b/internal/metricAggregator/metricAggregatorFunctions.go index 998be5a..d0a72c5 100644 --- a/internal/metricAggregator/metricAggregatorFunctions.go +++ b/internal/metricAggregator/metricAggregatorFunctions.go @@ -33,7 +33,7 @@ func sumAnyType[T float64 | float32 | int | int32 | int64](values []T) (T, error } // Sum up values -func sumfunc(args interface{}) (interface{}, error) { +func sumfunc(args any) (any, error) { var err error switch values := args.(type) { @@ -62,7 +62,7 @@ func minAnyType[T float64 | float32 | int | int32 | int64](values []T) (T, error } // Get the minimum value -func minfunc(args interface{}) (interface{}, error) { +func minfunc(args any) (any, error) { switch values := args.(type) { case []float64: return minAnyType(values) @@ -83,12 +83,12 @@ func avgAnyType[T float64 | float32 | int | int32 | int64](values []T) (float64, if len(values) == 0 { return 0.0, errors.New("average function requires at least one argument") } - sum, err := sumAnyType[T](values) + sum, err := sumAnyType(values) return float64(sum) / float64(len(values)), err } // Get the average or mean value -func avgfunc(args interface{}) (interface{}, error) { +func avgfunc(args any) (any, error) { switch values := args.(type) { case []float64: return avgAnyType(values) @@ -113,7 +113,7 @@ func maxAnyType[T float64 | float32 | int | int32 | int64](values []T) (T, error } // Get the maximum value -func maxfunc(args interface{}) (interface{}, error) { +func maxfunc(args any) (any, error) { switch values := args.(type) { case []float64: return maxAnyType(values) @@ -145,7 +145,7 @@ func medianAnyType[T float64 | float32 | int | int32 | int64](values []T) (T, er } // Get the median value -func medianfunc(args interface{}) (interface{}, error) { +func medianfunc(args any) (any, error) { switch values := args.(type) { case []float64: return medianAnyType(values) @@ -166,7 +166,7 @@ func medianfunc(args interface{}) (interface{}, error) { * Get number of values in list. Returns always an int */ -func lenfunc(args interface{}) (interface{}, error) { +func lenfunc(args any) (any, error) { var err error = nil length := 0 switch values := args.(type) { @@ -180,13 +180,7 @@ func lenfunc(args interface{}) (interface{}, error) { length = len(values) case []int32: length = len(values) - case float64: - err = errors.New("function 'len' can only be applied on arrays and strings") - case float32: - err = errors.New("function 'len' can only be applied on arrays and strings") - case int: - err = errors.New("function 'len' can only be applied on arrays and strings") - case int64: + case float64, float32, int, int64: err = errors.New("function 'len' can only be applied on arrays and strings") case string: length = len(values) @@ -196,13 +190,13 @@ func lenfunc(args interface{}) (interface{}, error) { /* * Check if a values is in a list - * In constrast to most of the other functions, this one is an infix operator for + * In contrast to most of the other functions, this one is an infix operator for * - substring matching: `"abc" in "abcdef"` -> true * - substring matching with int casting: `3 in "abd3"` -> true * - search for an int in an int list: `3 in getCpuList()` -> true (if you have more than 4 CPU hardware threads) */ -func infunc(a interface{}, b interface{}) (interface{}, error) { +func infunc(a any, b any) (any, error) { switch match := a.(type) { case string: switch total := b.(type) { @@ -212,11 +206,7 @@ func infunc(a interface{}, b interface{}) (interface{}, error) { case int: switch total := b.(type) { case []int: - for _, x := range total { - if x == match { - return true, nil - } - } + return slices.Contains(total, match), nil case string: smatch := fmt.Sprintf("%d", match) return strings.Contains(total, smatch), nil @@ -232,7 +222,7 @@ func infunc(a interface{}, b interface{}) (interface{}, error) { * format keys \d = %d, \w = %d, ... Not sure how to fix this */ -func matchfunc(args ...interface{}) (interface{}, error) { +func matchfunc(args ...any) (any, error) { switch match := args[0].(type) { case string: switch total := args[1].(type) { @@ -254,7 +244,7 @@ func matchfunc(args ...interface{}) (interface{}, error) { */ // for a given cpuid, it returns the core id -func getCpuCoreFunc(args interface{}) (interface{}, error) { +func getCpuCoreFunc(args any) (any, error) { switch cpuid := args.(type) { case int: return topo.GetHwthreadCore(cpuid), nil @@ -263,7 +253,7 @@ func getCpuCoreFunc(args interface{}) (interface{}, error) { } // for a given cpuid, it returns the socket id -func getCpuSocketFunc(args interface{}) (interface{}, error) { +func getCpuSocketFunc(args any) (any, error) { switch cpuid := args.(type) { case int: return topo.GetHwthreadSocket(cpuid), nil @@ -272,7 +262,7 @@ func getCpuSocketFunc(args interface{}) (interface{}, error) { } // for a given cpuid, it returns the id of the NUMA node -func getCpuNumaDomainFunc(args interface{}) (interface{}, error) { +func getCpuNumaDomainFunc(args any) (any, error) { switch cpuid := args.(type) { case int: return topo.GetHwthreadNumaDomain(cpuid), nil @@ -281,7 +271,7 @@ func getCpuNumaDomainFunc(args interface{}) (interface{}, error) { } // for a given cpuid, it returns the id of the CPU die -func getCpuDieFunc(args interface{}) (interface{}, error) { +func getCpuDieFunc(args any) (any, error) { switch cpuid := args.(type) { case int: return topo.GetHwthreadDie(cpuid), nil @@ -290,7 +280,7 @@ func getCpuDieFunc(args interface{}) (interface{}, error) { } // for a given core id, it returns the list of cpuids -func getCpuListOfCoreFunc(args interface{}) (interface{}, error) { +func getCpuListOfCoreFunc(args any) (any, error) { cpulist := make([]int, 0) switch in := args.(type) { case int: @@ -304,7 +294,7 @@ func getCpuListOfCoreFunc(args interface{}) (interface{}, error) { } // for a given socket id, it returns the list of cpuids -func getCpuListOfSocketFunc(args interface{}) (interface{}, error) { +func getCpuListOfSocketFunc(args any) (any, error) { cpulist := make([]int, 0) switch in := args.(type) { case int: @@ -318,7 +308,7 @@ func getCpuListOfSocketFunc(args interface{}) (interface{}, error) { } // for a given id of a NUMA domain, it returns the list of cpuids -func getCpuListOfNumaDomainFunc(args interface{}) (interface{}, error) { +func getCpuListOfNumaDomainFunc(args any) (any, error) { cpulist := make([]int, 0) switch in := args.(type) { case int: @@ -332,7 +322,7 @@ func getCpuListOfNumaDomainFunc(args interface{}) (interface{}, error) { } // for a given CPU die id, it returns the list of cpuids -func getCpuListOfDieFunc(args interface{}) (interface{}, error) { +func getCpuListOfDieFunc(args any) (any, error) { cpulist := make([]int, 0) switch in := args.(type) { case int: @@ -346,14 +336,14 @@ func getCpuListOfDieFunc(args interface{}) (interface{}, error) { } // wrapper function to get a list of all cpuids of the node -func getCpuListOfNode() (interface{}, error) { +func getCpuListOfNode() (any, error) { return topo.HwthreadList(), nil } // helper function to get the cpuid list for a CCMetric type tag set (type and type-id) // since there is no access to the metric data in the function, is should be called like // `getCpuListOfType()` -func getCpuListOfType(args ...interface{}) (interface{}, error) { +func getCpuListOfType(args ...any) (any, error) { cpulist := make([]int, 0) switch typ := args[0].(type) { case string: diff --git a/internal/metricRouter/metricRouter.go b/internal/metricRouter/metricRouter.go index 6ecade9..993733a 100644 --- a/internal/metricRouter/metricRouter.go +++ b/internal/metricRouter/metricRouter.go @@ -10,6 +10,7 @@ package metricRouter import ( "encoding/json" "fmt" + "maps" "os" "strings" "sync" @@ -192,8 +193,8 @@ func (r *metricRouter) Init(ticker mct.MultiChanTicker, wg *sync.WaitGroup, rout return nil } -func getParamMap(point lp.CCMessage) map[string]interface{} { - params := make(map[string]interface{}) +func getParamMap(point lp.CCMessage) map[string]any { + params := make(map[string]any) params["metric"] = point params["name"] = point.Name() for key, value := range point.Tags() { @@ -202,9 +203,7 @@ func getParamMap(point lp.CCMessage) map[string]interface{} { for key, value := range point.Meta() { params[key] = value } - for key, value := range point.Fields() { - params[key] = value - } + maps.Copy(params, point.Fields()) params["timestamp"] = point.Time() return params }