collectorManager: Make markers opt-in

These markers are sent out at the beginning and end of a collection run.
This can be used to reconstruct, which metrics belong together and were
obtained during the same tick.

.github/workflows/Release.yml

@@ -5,10 +5,10 @@ name: Release
 
 # Run on tag push
 on:
- push:
+  push:
-  tags:
+    tags:
-  - '**'
+    - '**'
- workflow_dispatch:
+  workflow_dispatch:
 
 jobs:
 
@@ -36,22 +36,14 @@ jobs:
     # fetch-depth must be 0 to use git describe
     # See: https://github.com/marketplace/actions/checkout
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
         fetch-depth: 0
 
-    # - name: Setup Golang
-    #   uses: actions/setup-go@v5
-    #   with:
-    #     go-version: 'stable'
     - name: Setup Golang
       run: |
-          dnf --assumeyes --disableplugin=subscription-manager install \
+          dnf --assumeyes --disableplugin=subscription-manager --enablerepo appstream install go-toolset
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/go-toolset-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/golang-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/golang-bin-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/golang-src-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.noarch.rpm
 
     - name: RPM build MetricCollector
       id: rpmbuild
@@ -78,13 +70,13 @@ jobs:
 
     # See: https://github.com/actions/upload-artifact
     - name: Save RPM as artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
         name: cc-metric-collector RPM for AlmaLinux 8
         path: ${{ steps.rpmrename.outputs.RPM }}
         overwrite: true
     - name: Save SRPM as artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
         name: cc-metric-collector SRPM for AlmaLinux 8
         path: ${{ steps.rpmrename.outputs.SRPM }}
@@ -114,23 +106,14 @@ jobs:
     # fetch-depth must be 0 to use git describe
     # See: https://github.com/marketplace/actions/checkout
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
         fetch-depth: 0
 
-    # - name: Setup Golang
-    #   uses: actions/setup-go@v5
-    #   with:
-    #     go-version: 'stable'
     - name: Setup Golang
       run: |
-          dnf --assumeyes --disableplugin=subscription-manager install \
+          dnf --assumeyes --disableplugin=subscription-manager --enablerepo appstream install go-toolset
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/go-toolset-1.23.9-1.el9_6.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-1.23.9-1.el9_6.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-bin-1.23.9-1.el9_6.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-src-1.23.9-1.el9_6.noarch.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-race-1.23.9-1.el9_6.x86_64.rpm
 
     - name: RPM build MetricCollector
       id: rpmbuild
@@ -157,25 +140,26 @@ jobs:
 
     # See: https://github.com/actions/upload-artifact
     - name: Save RPM as artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
         name: cc-metric-collector RPM for AlmaLinux 9
         path: ${{ steps.rpmrename.outputs.RPM }}
         overwrite: true
     - name: Save SRPM as artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
         name: cc-metric-collector SRPM for AlmaLinux 9
         path: ${{ steps.rpmrename.outputs.SRPM }}
         overwrite: true
 
   #
-  # Build on UBI 8 using go-toolset
+  # Build on Red Hat Universal Base Image (UBI 8) using go-toolset
   #
   UBI-8-RPM-build:
     runs-on: ubuntu-latest
-    # See: https://catalog.redhat.com/software/containers/ubi8/ubi/5c35984d70cc534b3a3784e?container-tabs=gti
+    # See: https://catalog.redhat.com/en/search?searchType=Containers&q=Red+Hat+Universal+Base+Image+8
-    container: registry.access.redhat.com/ubi8/ubi:8.8-1032.1692772289
+    #      https://hub.docker.com/r/redhat/ubi8
+    container: redhat/ubi8
     # The job outputs link to the outputs of the 'rpmbuild' step
     outputs:
       rpm : ${{steps.rpmbuild.outputs.RPM}}
@@ -190,22 +174,14 @@ jobs:
     # fetch-depth must be 0 to use git describe
     # See: https://github.com/marketplace/actions/checkout
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
         fetch-depth: 0
 
-    # - name: Setup Golang
-    #   uses: actions/setup-go@v5
-    #   with:
-    #     go-version: 'stable'
     - name: Setup Golang
       run: |
-          dnf --assumeyes --disableplugin=subscription-manager install \
+          dnf --assumeyes --disableplugin=subscription-manager --enablerepo ubi-8-appstream-rpms install go-toolset
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/go-toolset-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/golang-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/golang-bin-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/golang-src-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.noarch.rpm
 
     - name: RPM build MetricCollector
       id: rpmbuild
@@ -215,24 +191,25 @@ jobs:
 
     # See: https://github.com/actions/upload-artifact
     - name: Save RPM as artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
         name: cc-metric-collector RPM for UBI 8
         path: ${{ steps.rpmbuild.outputs.RPM }}
         overwrite: true
     - name: Save SRPM as artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
         name: cc-metric-collector SRPM for UBI 8
         path: ${{ steps.rpmbuild.outputs.SRPM }}
         overwrite: true
 
   #
-  # Build on UBI 9 using go-toolset
+  # Build on Red Hat Universal Base Image (UBI 9) using go-toolset
   #
   UBI-9-RPM-build:
     runs-on: ubuntu-latest
-    # See: https://catalog.redhat.com/software/containers/ubi8/ubi/5c359854d70cc534b3a3784e?container-tabs=gti
+    # See: https://catalog.redhat.com/en/search?searchType=Containers&q=Red+Hat+Universal+Base+Image+9
+    #      https://hub.docker.com/r/redhat/ubi9
     container: redhat/ubi9
     # The job outputs link to the outputs of the 'rpmbuild' step
     # The job outputs link to the outputs of the 'rpmbuild' step
@@ -243,30 +220,20 @@ jobs:
 
     # Use dnf to install development packages
     - name: Install development packages
-      run: dnf --assumeyes --disableplugin=subscription-manager install rpm-build go-srpm-macros gcc make python39 git wget openssl-devel diffutils delve 
+      run: dnf --assumeyes --disableplugin=subscription-manager install rpm-build go-srpm-macros gcc make python39 git wget openssl-devel diffutils delve
 
     # Checkout git repository and submodules
     # fetch-depth must be 0 to use git describe
     # See: https://github.com/marketplace/actions/checkout
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
         fetch-depth: 0
 
-    # See: https://github.com/marketplace/actions/setup-go-environment
-    # - name: Setup Golang
-    #   uses: actions/setup-go@v5
-    #   with:
-    #     go-version: 'stable'
     - name: Setup Golang
       run: |
-          dnf --assumeyes --disableplugin=subscription-manager install \
+          dnf --assumeyes --disableplugin=subscription-manager --enablerepo ubi-9-appstream-rpms install go-toolset
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/go-toolset-1.23.9-1.el9_6.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-1.23.9-1.el9_6.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-bin-1.23.9-1.el9_6.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-src-1.23.9-1.el9_6.noarch.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-race-1.23.9-1.el9_6.x86_64.rpm
 
     - name: RPM build MetricCollector
       id: rpmbuild
@@ -276,13 +243,13 @@ jobs:
 
     # See: https://github.com/actions/upload-artifact
     - name: Save RPM as artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
         name: cc-metric-collector RPM for UBI 9
         path: ${{ steps.rpmbuild.outputs.RPM }}
         overwrite: true
     - name: Save SRPM as artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
         name: cc-metric-collector SRPM for UBI 9
         path: ${{ steps.rpmbuild.outputs.SRPM }}
@@ -303,18 +270,19 @@ jobs:
     - name: Install development packages
       run: |
           apt update && apt --assume-yes upgrade
-          apt --assume-yes install build-essential sed git wget bash
+          apt --assume-yes install build-essential sed git wget bash libdrm-dev
     # Checkout git repository and submodules
     # fetch-depth must be 0 to use git describe
     # See: https://github.com/marketplace/actions/checkout
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
         fetch-depth: 0
-
+    # Use official golang package
+    # See: https://github.com/marketplace/actions/setup-go-environment
     - name: Setup Golang
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v6
       with:
         go-version: 'stable'
 
@@ -332,13 +300,13 @@ jobs:
         echo "DEB=${NEW_DEB_FILE}" >> $GITHUB_OUTPUT
     # See: https://github.com/actions/upload-artifact
     - name: Save DEB as artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
         name: cc-metric-collector DEB for Ubuntu 22.04
         path: ${{ steps.debrename.outputs.DEB }}
         overwrite: true
 
- #
+  #
   # Build on Ubuntu 24.04 using official go package
   #
   Ubuntu-noblenumbat-build:
@@ -353,18 +321,19 @@ jobs:
     - name: Install development packages
       run: |
           apt update && apt --assume-yes upgrade
-          apt --assume-yes install build-essential sed git wget bash
+          apt --assume-yes install build-essential sed git wget bash libdrm-dev
     # Checkout git repository and submodules
     # fetch-depth must be 0 to use git describe
     # See: https://github.com/marketplace/actions/checkout
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
         fetch-depth: 0
-
+    # Use official golang package
+    # See: https://github.com/marketplace/actions/setup-go-environment
     - name: Setup Golang
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v6
       with:
         go-version: 'stable'
 
@@ -382,7 +351,7 @@ jobs:
         echo "DEB=${NEW_DEB_FILE}" >> $GITHUB_OUTPUT
     # See: https://github.com/actions/upload-artifact
     - name: Save DEB as artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
         name: cc-metric-collector DEB for Ubuntu 24.04
         path: ${{ steps.debrename.outputs.DEB }}
@@ -400,48 +369,48 @@ jobs:
     steps:
     # See: https://github.com/actions/download-artifact
     - name: Download AlmaLinux 8 RPM
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v7
       with:
         name: cc-metric-collector RPM for AlmaLinux 8
     - name: Download AlmaLinux 8 SRPM
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v7
       with:
         name: cc-metric-collector SRPM for AlmaLinux 8
 
     - name: Download AlmaLinux 9 RPM
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v7
       with:
         name: cc-metric-collector RPM for AlmaLinux 9
     - name: Download AlmaLinux 9 SRPM
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v7
       with:
         name: cc-metric-collector SRPM for AlmaLinux 9
 
     - name: Download UBI 8 RPM
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v7
       with:
         name: cc-metric-collector RPM for UBI 8
     - name: Download UBI 8 SRPM
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v7
       with:
         name: cc-metric-collector SRPM for UBI 8
 
     - name: Download UBI 9 RPM
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v7
       with:
         name: cc-metric-collector RPM for UBI 9
     - name: Download UBI 9 SRPM
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v7
       with:
         name: cc-metric-collector SRPM for UBI 9
 
     - name: Download Ubuntu 22.04 DEB
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v7
       with:
         name: cc-metric-collector DEB for Ubuntu 22.04
 
     - name: Download Ubuntu 24.04 DEB
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v7
       with:
         name: cc-metric-collector DEB for Ubuntu 24.04
 

.github/workflows/runonce.yml

@@ -20,25 +20,41 @@ jobs:
     # See: https://github.com/marketplace/actions/checkout
     # Checkout git repository and submodules
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
 
     # See: https://github.com/marketplace/actions/setup-go-environment
     - name: Setup Golang
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v6
       with:
-        go-version: '1.21'
+        go-version: 'stable'
         check-latest: true
 
+    - name: Install reviewdog
+      run: |
+        go install github.com/reviewdog/reviewdog/cmd/reviewdog@latest
+
+    # See: https://golangci-lint.run
+    - name: Install GolangCI-Lint
+      run: |
+        go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest
+
     - name: Build MetricCollector
       run: make
 
     - name: Run MetricCollector once
       run: ./cc-metric-collector --once --config .github/ci-config.json
 
+    # 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 --enable errorlint,govet,misspell,modernize,prealloc,staticcheck,unconvert,wastedassign | 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 }}
+
   #
-  # Build on AlmaLinux 8
+  # Build on AlmaLinux 8 using go-toolset
   #
   AlmaLinux8-RPM-build:
     runs-on: ubuntu-latest
@@ -58,23 +74,14 @@ jobs:
     # fetch-depth must be 0 to use git describe
     # See: https://github.com/marketplace/actions/checkout
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
         fetch-depth: 0
 
-    # See: https://github.com/marketplace/actions/setup-go-environment
-    # - name: Setup Golang
-    #   uses: actions/setup-go@v5
-    #   with:
-    #     go-version: 'stable'
     - name: Setup Golang
       run: |
-          dnf --assumeyes --disableplugin=subscription-manager install \
+          dnf --assumeyes --disableplugin=subscription-manager --enablerepo appstream install go-toolset
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/go-toolset-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/golang-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/golang-bin-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/golang-src-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.noarch.rpm
 
     - name: RPM build MetricCollector
       id: rpmbuild
@@ -83,7 +90,7 @@ jobs:
           make RPM
 
   #
-  # Build on AlmaLinux 9
+  # Build on AlmaLinux 9 using go-toolset
   #
   AlmaLinux9-RPM-build:
     runs-on: ubuntu-latest
@@ -103,24 +110,14 @@ jobs:
     # fetch-depth must be 0 to use git describe
     # See: https://github.com/marketplace/actions/checkout
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
         fetch-depth: 0
 
-    # See: https://github.com/marketplace/actions/setup-go-environment
-    # - name: Setup Golang
-    #   uses: actions/setup-go@v5
-    #   with:
-    #     go-version: 'stable'
     - name: Setup Golang
       run: |
-          dnf --assumeyes --disableplugin=subscription-manager install \
+          dnf --assumeyes --disableplugin=subscription-manager --enablerepo appstream install go-toolset
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/go-toolset-1.23.9-1.el9_6.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-1.23.9-1.el9_6.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-bin-1.23.9-1.el9_6.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-src-1.23.9-1.el9_6.noarch.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-race-1.23.9-1.el9_6.x86_64.rpm
 
     - name: RPM build MetricCollector
       id: rpmbuild
@@ -128,13 +125,49 @@ jobs:
           git config --global --add safe.directory /__w/cc-metric-collector/cc-metric-collector
           make RPM
 
+  #
+  # Build on AlmaLinux 10 using go-toolset
+  #
+  AlmaLinux10-RPM-build:
+    runs-on: ubuntu-latest
+    # See: https://hub.docker.com/_/almalinux
+    container: almalinux:10
+    # The job outputs link to the outputs of the 'rpmrename' step
+    # Only job outputs can be used in child jobs
+    steps:
+
+    # Use dnf to install development packages
+    - name: Install development packages
+      run: |
+          dnf --assumeyes group install "Development Tools" "RPM Development Tools"
+          dnf --assumeyes install wget openssl-devel diffutils delve which
+
+    # Checkout git repository and submodules
+    # fetch-depth must be 0 to use git describe
+    # See: https://github.com/marketplace/actions/checkout
+    - name: Checkout
+      uses: actions/checkout@v6
+      with:
+        submodules: recursive
+        fetch-depth: 0
+
+    - name: Setup Golang
+      run: |
+          dnf --assumeyes --disableplugin=subscription-manager --enablerepo appstream install go-toolset
+
+    - name: RPM build MetricCollector
+      id: rpmbuild
+      run: |
+          git config --global --add safe.directory /__w/cc-metric-collector/cc-metric-collector
+          make RPM
 
   #
-  # Build on UBI 8 using go-toolset
+  # Build on Red Hat Universal Base Image (UBI 8) using go-toolset
   #
   UBI-8-RPM-build:
     runs-on: ubuntu-latest
-    # See: https://catalog.redhat.com/software/containers/ubi8/ubi/5c359854d70cc534b3a3784e?container-tabs=gti
+    # See: https://catalog.redhat.com/en/search?searchType=Containers&q=Red+Hat+Universal+Base+Image+8
+    #      https://hub.docker.com/r/redhat/ubi8
     container: redhat/ubi8
     # The job outputs link to the outputs of the 'rpmbuild' step
     steps:
@@ -147,23 +180,14 @@ jobs:
     # fetch-depth must be 0 to use git describe
     # See: https://github.com/marketplace/actions/checkout
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
         fetch-depth: 0
 
-    # See: https://github.com/marketplace/actions/setup-go-environment
-    # - name: Setup Golang
-    #   uses: actions/setup-go@v5
-    #   with:
-    #     go-version: 'stable'
     - name: Setup Golang
       run: |
-          dnf --assumeyes --disableplugin=subscription-manager install \
+          dnf --assumeyes --disableplugin=subscription-manager --enablerepo ubi-8-appstream-rpms install go-toolset
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/go-toolset-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/golang-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/golang-bin-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/8/AppStream/x86_64/os/Packages/golang-src-1.23.9-1.module_el8.10.0+4000+1ad1b2cc.noarch.rpm
 
     - name: RPM build MetricCollector
       id: rpmbuild
@@ -172,11 +196,12 @@ jobs:
           make RPM
 
   #
-  # Build on UBI 9 using go-toolset
+  # Build on Red Hat Universal Base Image (UBI 9) using go-toolset
   #
   UBI-9-RPM-build:
     runs-on: ubuntu-latest
-    # See: https://catalog.redhat.com/software/containers/ubi8/ubi/5c359854d70cc534b3a3784e?container-tabs=gti
+    # See: https://catalog.redhat.com/en/search?searchType=Containers&q=Red+Hat+Universal+Base+Image+9
+    #      https://hub.docker.com/r/redhat/ubi9
     container: redhat/ubi9
     # The job outputs link to the outputs of the 'rpmbuild' step
     steps:
@@ -189,24 +214,48 @@ jobs:
     # fetch-depth must be 0 to use git describe
     # See: https://github.com/marketplace/actions/checkout
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
         fetch-depth: 0
 
-    # See: https://github.com/marketplace/actions/setup-go-environment
-    # - name: Setup Golang
-    #   uses: actions/setup-go@v5
-    #   with:
-    #     go-version: 'stable'
     - name: Setup Golang
       run: |
-          dnf --assumeyes --disableplugin=subscription-manager install \
+          dnf --assumeyes --disableplugin=subscription-manager --enablerepo ubi-9-appstream-rpms install go-toolset
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/go-toolset-1.23.9-1.el9_6.x86_64.rpm \
+
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-1.23.9-1.el9_6.x86_64.rpm \
+    - name: RPM build MetricCollector
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-bin-1.23.9-1.el9_6.x86_64.rpm \
+      id: rpmbuild
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-src-1.23.9-1.el9_6.noarch.rpm \
+      run: |
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-race-1.23.9-1.el9_6.x86_64.rpm
+          git config --global --add safe.directory /__w/cc-metric-collector/cc-metric-collector
+          make RPM
+
+  #
+  # Build on Red Hat Universal Base Image (UBI 10) using go-toolset
+  #
+  UBI-10-RPM-build:
+    runs-on: ubuntu-latest
+    # See: https://catalog.redhat.com/en/search?searchType=Containers&q=Red+Hat+Universal+Base+Image+10
+    #      https://hub.docker.com/r/redhat/ubi10
+    container: redhat/ubi10
+    # The job outputs link to the outputs of the 'rpmbuild' step
+    steps:
+
+    # Use dnf to install development packages
+    - name: Install development packages
+      run: dnf --assumeyes --disableplugin=subscription-manager install rpm-build go-srpm-macros gcc make python3 git wget openssl-devel diffutils delve
+
+    # Checkout git repository and submodules
+    # fetch-depth must be 0 to use git describe
+    # See: https://github.com/marketplace/actions/checkout
+    - name: Checkout
+      uses: actions/checkout@v6
+      with:
+        submodules: recursive
+        fetch-depth: 0
+
+    - name: Setup Golang
+      run: |
+          dnf --assumeyes --disableplugin=subscription-manager --enablerepo ubi-10-for-x86_64-appstream-rpms install go-toolset
 
     - name: RPM build MetricCollector
       id: rpmbuild
@@ -231,14 +280,14 @@ jobs:
     # fetch-depth must be 0 to use git describe
     # See: https://github.com/marketplace/actions/checkout
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
         fetch-depth: 0
     # Use official golang package
     # See: https://github.com/marketplace/actions/setup-go-environment
     - name: Setup Golang
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v6
       with:
         go-version: 'stable'
 
@@ -265,14 +314,14 @@ jobs:
     # fetch-depth must be 0 to use git describe
     # See: https://github.com/marketplace/actions/checkout
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
         fetch-depth: 0
     # Use official golang package
     # See: https://github.com/marketplace/actions/setup-go-environment
     - name: Setup Golang
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v6
       with:
         go-version: 'stable'
 

.gitignore

@@ -1,4 +1,5 @@
 # Binaries for programs and plugins
+/cc-metric-collector
 *.exe
 *.exe~
 *.dll
@@ -13,3 +14,6 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+
+# Local copy of LIKWID headers
+/collectors/likwid

Makefile

@@ -27,6 +27,17 @@ $(APP): $(GOSRC) go.mod
 	$(GOBIN) get
 	$(GOBIN) build -o $(APP) $(GOSRC_APP)
 
+# -ldflags:
+#   -s : drops the OS symbol table 
+#   -w : drops DWARF
+#   -> Panic stack traces still show function names and file:line
+.PHONY: build-stripped
+build-stripped:
+	make -C collectors
+	$(GOBIN) get
+	$(GOBIN) build -ldflags "-s -w" -trimpath -o $(APP) $(GOSRC_APP)
+
+.PHONY: install
 install: $(APP)
 	@WORKSPACE=$(PREFIX)
 	@if [ -z "$${WORKSPACE}" ]; then exit 1; fi
@@ -58,12 +69,26 @@ fmt:
 	$(GOBIN) fmt $(GOSRC_APP)
 	@for F in $(GOSRC_INTERNAL); do $(GOBIN) fmt $$F; done
 
+# gofumpt <https://github.com/mvdan/gofumpt>:
+# Enforce a stricter format than gofmt
+.PHONY: gofumpt
+gofumpt:
+	$(GOBIN) install mvdan.cc/gofumpt@latest
+	gofumpt -w $(GOSRC_COLLECTORS)
+	gofumpt -w $(GOSRC_SINKS)
+	gofumpt -w $(GOSRC_RECEIVERS)
+	gofumpt -w $(GOSRC_APP)
+	@for F in $(GOSRC_INTERNAL); do gofumpt -w $$F; done
+
 
 # Examine Go source code and reports suspicious constructs
 .PHONY: vet
 vet:
 	$(GOBIN) vet ./...
 
+.PHONY: modernize
+modernize:
+	$(GOBIN) run golang.org/x/tools/go/analysis/passes/modernize/cmd/modernize@latest ./...
 
 # Run linter for the Go programming language.
 # Using static analysis, it finds bugs and performance issues, offers simplifications, and enforces style rules
@@ -72,6 +97,11 @@ staticcheck:
 	$(GOBIN) install honnef.co/go/tools/cmd/staticcheck@latest
 	$$($(GOBIN) env GOPATH)/bin/staticcheck ./...
 
+.PHONY: golangci-lint
+golangci-lint:
+	$(GOBIN) install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest
+	$$($(GOBIN) env GOPATH)/bin/golangci-lint run --enable errorlint,govet,misspell,modernize,prealloc,staticcheck,unconvert,wastedassign
+
 .ONESHELL:
 .PHONY: RPM
 RPM: scripts/cc-metric-collector.spec

README.md

@@ -11,13 +11,9 @@ hugo_path: docs/reference/cc-metric-collector/_index.md
 
 # cc-metric-collector
 
-A node agent for measuring, processing and forwarding node level metrics. It is part of the [ClusterCockpit ecosystem](https://clustercockpit.org/docs/overview/).
+A node agent for measuring, processing and forwarding node level metrics. It is part of the [ClusterCockpit ecosystem](https://clustercockpit.org/docs/overview/). 
 
-The metric collector sends (and receives) metric in the [InfluxDB line protocol](https://docs.influxdata.com/influxdb/cloud/reference/syntax/line-protocol/) as it provides flexibility while providing a separation between tags (like index columns in relational databases) and fields (like data columns).
+The `cc-metric-collector` sends (and maybe receives) metrics in the [InfluxDB line protocol](https://docs.influxdata.com/influxdb/cloud/reference/syntax/line-protocol/) as it provides flexibility while providing a separation between tags (like index columns in relational databases) and fields (like data columns). The `cc-metric-collector` consists of 4 components: collectors, router, sinks and receivers. The collectors read data from the current system and submit metrics to the router. The router can be configured to manipulate the metrics before forwarding them to the sinks. The receivers are also attached to the router like the collectors but they receive data from external source like other `cc-metric-collector` instances.
-
-There is a single timer loop that triggers all collectors serially, collects the collectors' data and sends the metrics to the sink. This is done as all data is submitted with a single time stamp. The sinks currently use mostly blocking APIs.
-
-The receiver runs as a go routine side-by-side with the timer loop and asynchronously forwards received metrics to the sink.
 
 
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7438287.svg)](https://doi.org/10.5281/zenodo.7438287)
@@ -43,7 +39,7 @@ There is a main configuration file with basic settings that point to the other c
 }
 ```
 
-The `interval` defines how often the metrics should be read and send to the sink. The `duration` tells collectors how long one measurement has to take. This is important for some collectors, like the `likwid` collector. For more information, see [here](./docs/configuration.md).
+The `interval` defines how often the metrics should be read and send to the sink(s). The `duration` tells the collectors how long one measurement has to take. This is important for some collectors, like the `likwid` collector. For more information, see [here](./docs/configuration.md).
 
 See the component READMEs for their configuration:
 
@@ -57,7 +53,7 @@ See the component READMEs for their configuration:
 ```
 $ git clone git@github.com:ClusterCockpit/cc-metric-collector.git
 $ make (downloads LIKWID, builds it as static library with 'direct' accessmode and copies all required files for the collector)
-$ go get (requires at least golang 1.16)
+$ go get
 $ make
 ```
 
@@ -67,11 +63,13 @@ For more information, see [here](./docs/building.md).
 
 ```
 $ ./cc-metric-collector --help
-Usage of metric-collector:
+Usage of ./cc-metric-collector:
   -config string
     	Path to configuration file (default "./config.json")
   -log string
     	Path for logfile (default "stderr")
+  -loglevel string
+    	Set log level (default "info")
   -once
     	Run all collectors only once
 ```
@@ -114,7 +112,7 @@ flowchart TD
 
 # Contributing
 
-The ClusterCockpit ecosystem is designed to be used by different HPC computing centers. Since configurations and setups differ between the centers, the centers likely have to put some work into the cc-metric-collector to gather all desired metrics.
+The ClusterCockpit ecosystem is designed to be used by different HPC computing centers. Since configurations and setups differ between the centers, the centers likely have to put some work into `cc-metric-collector` to gather all desired metrics.
 
 You are free to open an issue to request a collector but we would also be happy about PRs.
 

cc-metric-collector.go

@@ -8,37 +8,38 @@
 package main
 
 import (
+	"bytes"
 	"encoding/json"
 	"flag"
 	"os"
 	"os/signal"
-	"syscall"
-
-	"github.com/ClusterCockpit/cc-lib/receivers"
-	"github.com/ClusterCockpit/cc-lib/sinks"
-	"github.com/ClusterCockpit/cc-metric-collector/collectors"
-
-	//	"strings"
 	"sync"
+	"syscall"
 	"time"
 
-	ccconf "github.com/ClusterCockpit/cc-lib/ccConfig"
+	"github.com/ClusterCockpit/cc-lib/v2/receivers"
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	"github.com/ClusterCockpit/cc-lib/v2/sinks"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	"github.com/ClusterCockpit/cc-metric-collector/collectors"
+
+	ccconf "github.com/ClusterCockpit/cc-lib/v2/ccConfig"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 	mr "github.com/ClusterCockpit/cc-metric-collector/internal/metricRouter"
 	mct "github.com/ClusterCockpit/cc-metric-collector/pkg/multiChanTicker"
 )
 
 type CentralConfigFile struct {
-	Interval string `json:"interval"`
+	Interval      string `json:"interval"`
-	Duration string `json:"duration"`
+	Duration      string `json:"duration"`
+	EnableMarkers bool   `json:"enable-markers"`
 }
 
 type RuntimeConfig struct {
-	Interval   time.Duration
+	Interval      time.Duration
-	Duration   time.Duration
+	Duration      time.Duration
-	CliArgs    map[string]string
+	EnableMarkers bool
-	ConfigFile CentralConfigFile
+	CliArgs       map[string]string
+	ConfigFile    CentralConfigFile
 
 	MetricRouter    mr.MetricRouter
 	CollectManager  collectors.CollectorManager
@@ -50,65 +51,25 @@ type RuntimeConfig struct {
 	Sync     sync.WaitGroup
 }
 
-//// Structure of the configuration file
+// ReadCli reads the command line arguments
-//type GlobalConfig struct {
-//	Sink           sinks.SinkConfig           `json:"sink"`
-//	Interval       int                        `json:"interval"`
-//	Duration       int                        `json:"duration"`
-//	Collectors     []string                   `json:"collectors"`
-//	Receiver       receivers.ReceiverConfig   `json:"receiver"`
-//	DefTags        map[string]string          `json:"default_tags"`
-//	CollectConfigs map[string]json.RawMessage `json:"collect_config"`
-//}
-
-//// Load JSON configuration file
-//func LoadConfiguration(file string, config *GlobalConfig) error {
-//	configFile, err := os.Open(file)
-//	defer configFile.Close()
-//	if err != nil {
-//		fmt.Println(err.Error())
-//		return err
-//	}
-//	jsonParser := json.NewDecoder(configFile)
-//	err = jsonParser.Decode(config)
-//	return err
-//}
-
 func ReadCli() map[string]string {
-	var m map[string]string
 	cfg := flag.String("config", "./config.json", "Path to configuration file")
 	logfile := flag.String("log", "stderr", "Path for logfile")
 	once := flag.Bool("once", false, "Run all collectors only once")
 	loglevel := flag.String("loglevel", "info", "Set log level")
 	flag.Parse()
-	m = make(map[string]string)
+	m := map[string]string{
-	m["configfile"] = *cfg
+		"configfile": *cfg,
-	m["logfile"] = *logfile
+		"logfile":    *logfile,
+		"once":       "false",
+		"loglevel":   *loglevel,
+	}
 	if *once {
 		m["once"] = "true"
-	} else {
-		m["once"] = "false"
 	}
-	m["loglevel"] = *loglevel
 	return m
 }
 
-//func SetLogging(logfile string) error {
-//	var file *os.File
-//	var err error
-//	if logfile != "stderr" {
-//		file, err = os.OpenFile(logfile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0600)
-//		if err != nil {
-//			log.Fatal(err)
-//			return err
-//		}
-//	} else {
-//		file = os.Stderr
-//	}
-//	log.SetOutput(file)
-//	return nil
-//}
-
 // General shutdownHandler function that gets executed in case of interrupt or graceful shutdownHandler
 func shutdownHandler(config *RuntimeConfig, shutdownSignal chan os.Signal) {
 	defer config.Sync.Done()
@@ -162,9 +123,10 @@ func mainFunc() int {
 
 	// Load and check configuration
 	main := ccconf.GetPackageConfig("main")
-	err = json.Unmarshal(main, &rcfg.ConfigFile)
+	d := json.NewDecoder(bytes.NewReader(main))
-	if err != nil {
+	d.DisallowUnknownFields()
-		cclog.Error("Error reading configuration file ", rcfg.CliArgs["configfile"], ": ", err.Error())
+	if err := d.Decode(&rcfg.ConfigFile); err != nil {
+		cclog.Errorf("Error reading configuration file %s: %v", rcfg.CliArgs["configfile"], err)
 		return 1
 	}
 
@@ -197,6 +159,7 @@ func mainFunc() int {
 		cclog.Error("The interval should be greater than duration")
 		return 1
 	}
+	rcfg.EnableMarkers = rcfg.ConfigFile.EnableMarkers
 
 	routerConf := ccconf.GetPackageConfig("router")
 	if len(routerConf) == 0 {
@@ -216,11 +179,6 @@ func mainFunc() int {
 		return 1
 	}
 
-	// Set log file
-	// if logfile := rcfg.CliArgs["logfile"]; logfile != "stderr" {
-	// 	cclog.SetOutput(logfile)
-	// }
-
 	// Creat new multi channel ticker
 	rcfg.MultiChanTicker = mct.NewTicker(rcfg.Interval)
 
@@ -244,7 +202,7 @@ func mainFunc() int {
 	rcfg.MetricRouter.AddOutput(RouterToSinksChannel)
 
 	// Create new collector manager
-	rcfg.CollectManager, err = collectors.New(rcfg.MultiChanTicker, rcfg.Duration, &rcfg.Sync, collectorConf)
+	rcfg.CollectManager, err = collectors.New(rcfg.MultiChanTicker, rcfg.Duration, rcfg.EnableMarkers, &rcfg.Sync, collectorConf)
 	if err != nil {
 		cclog.Error(err.Error())
 		return 1

collectors/Makefile

@@ -1,5 +1,5 @@
 # LIKWID version
-LIKWID_VERSION := 5.4.1
+LIKWID_VERSION := 5.5.1
 LIKWID_INSTALLED_FOLDER := $(shell dirname $$(which likwid-topology 2>/dev/null) 2>/dev/null)
 
 LIKWID_FOLDER := $(CURDIR)/likwid

collectors/README.md

@@ -59,6 +59,7 @@ In contrast to the configuration files for sinks and receivers, the collectors c
 * [ ] Aggreate metrics to higher topology entity (sum hwthread metrics to socket metric, ...). Needs to be configurable
 
 # Contributing own collectors
+
 A collector reads data from any source, parses it to metrics and submits these metrics to the `metric-collector`. A collector provides three function:
 
 * `Name() string`: Return the name of the collector
@@ -67,7 +68,7 @@ A collector reads data from any source, parses it to metrics and submits these m
 * `Read(duration time.Duration, output chan ccMessage.CCMessage)`: Read, parse and submit data to the `output` channel as [`CCMessage`](https://github.com/ClusterCockpit/cc-lib/blob/main/ccMessage/README.md). If the collector has to measure anything for some duration, use the provided function argument `duration`.
 * `Close()`: Closes down the collector.
 
-It is recommanded to call `setup()` in the `Init()` function.
+It is recommended to call `setup()` in the `Init()` function.
 
 Finally, the collector needs to be registered in the `collectorManager.go`. There is a list of collectors called `AvailableCollectors` which is a map (`collector_type_string` -> `pointer to MetricCollector interface`). Add a new entry with a descriptive name and the new collector.
 
@@ -100,11 +101,14 @@ func (m *SampleCollector) Init(config json.RawMessage) error {
     }
 
     m.name = "SampleCollector"
-    m.setup()
+    if err := m.setup(); err != nil {
+        return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+    }
     if len(config) > 0 {
-        err := json.Unmarshal(config, &m.config)
+        d := json.NewDecoder(bytes.NewReader(config))
-        if err != nil {
+        d.DisallowUnknownFields()
-            return err
+        if err := d.Decode(&m.config); err != nil {
+            return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
         }
     }
     m.meta = map[string]string{"source": m.name, "group": "Sample"}

collectors/beegfsmetaMetric.go

@@ -17,25 +17,27 @@ import (
 	"os/exec"
 	"os/user"
 	"regexp"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 const DEFAULT_BEEGFS_CMD = "beegfs-ctl"
 
 // Struct for the collector-specific JSON config
 type BeegfsMetaCollectorConfig struct {
-	Beegfs            string   `json:"beegfs_path"`
+	Beegfs             string   `json:"beegfs_path"`
-	ExcludeMetrics    []string `json:"exclude_metrics,omitempty"`
+	ExcludeMetrics     []string `json:"exclude_metrics,omitempty"`
-	ExcludeFilesystem []string `json:"exclude_filesystem"`
+	ExcludeFilesystems []string `json:"exclude_filesystem"`
 }
 
 type BeegfsMetaCollector struct {
 	metricCollector
+
 	tags    map[string]string
 	matches map[string]string
 	config  BeegfsMetaCollectorConfig
@@ -48,7 +50,7 @@ func (m *BeegfsMetaCollector) Init(config json.RawMessage) error {
 		return nil
 	}
 	// Metrics
-	var nodeMdstat_array = [39]string{
+	nodeMdstat_array := [39]string{
 		"sum", "ack", "close", "entInf",
 		"fndOwn", "mkdir", "create", "rddir",
 		"refrEn", "mdsInf", "rmdir", "rmLnk",
@@ -58,10 +60,13 @@ func (m *BeegfsMetaCollector) Init(config json.RawMessage) error {
 		"lookLI", "statLI", "revalLI", "openLI",
 		"createLI", "hardlnk", "flckAp", "flckEn",
 		"flckRg", "dirparent", "listXA", "getXA",
-		"rmXA", "setXA", "mirror"}
+		"rmXA", "setXA", "mirror",
+	}
 
 	m.name = "BeegfsMetaCollector"
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	m.parallel = true
 	// Set default beegfs-ctl binary
 
@@ -69,17 +74,17 @@ func (m *BeegfsMetaCollector) Init(config json.RawMessage) error {
 
 	// Read JSON configuration
 	if len(config) > 0 {
-		err := json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Failed to decode JSON config: %w", m.name, err)
 		}
 	}
 
-	//create map with possible variables
+	// Create map with possible variables
 	m.matches = make(map[string]string)
 	for _, value := range nodeMdstat_array {
-		_, skip := stringArrayContains(m.config.ExcludeMetrics, value)
+		if slices.Contains(m.config.ExcludeMetrics, value) {
-		if skip {
 			m.matches["other"] = "0"
 		} else {
 			m.matches["beegfs_cmeta_"+value] = "0"
@@ -95,23 +100,23 @@ func (m *BeegfsMetaCollector) Init(config json.RawMessage) error {
 		"filesystem": "",
 	}
 	m.skipFS = make(map[string]struct{})
-	for _, fs := range m.config.ExcludeFilesystem {
+	for _, fs := range m.config.ExcludeFilesystems {
 		m.skipFS[fs] = struct{}{}
 	}
 
 	// Beegfs file system statistics can only be queried by user root
 	user, err := user.Current()
 	if err != nil {
-		return fmt.Errorf("BeegfsMetaCollector.Init(): Failed to get current user: %v", err)
+		return fmt.Errorf("%s Init(): Failed to get current user: %w", m.name, err)
 	}
 	if user.Uid != "0" {
-		return fmt.Errorf("BeegfsMetaCollector.Init(): BeeGFS file system statistics can only be queried by user root")
+		return fmt.Errorf("%s Init(): BeeGFS file system statistics can only be queried by user root", m.name)
 	}
 
 	// Check if beegfs-ctl is in executable search path
 	_, err = exec.LookPath(m.config.Beegfs)
 	if err != nil {
-		return fmt.Errorf("BeegfsMetaCollector.Init(): Failed to find beegfs-ctl binary '%s': %v", m.config.Beegfs, err)
+		return fmt.Errorf("%s Init(): Failed to find beegfs-ctl binary '%s': %w", m.name, m.config.Beegfs, err)
 	}
 	m.init = true
 	return nil
@@ -121,7 +126,7 @@ func (m *BeegfsMetaCollector) Read(interval time.Duration, output chan lp.CCMess
 	if !m.init {
 		return
 	}
-	//get mounpoint
+	// Get mounpoint
 	buffer, _ := os.ReadFile(string("/proc/mounts"))
 	mounts := strings.Split(string(buffer), "\n")
 	var mountpoints []string
@@ -151,7 +156,6 @@ func (m *BeegfsMetaCollector) Read(interval time.Duration, output chan lp.CCMess
 		// --nodetype=meta: The node type to query (meta, storage).
 		// --interval:
 		// --mount=/mnt/beeond/: Which mount point
-		//cmd := exec.Command(m.config.Beegfs, "/root/mc/test.txt")
 		mountoption := "--mount=" + mountpoint
 		cmd := exec.Command(m.config.Beegfs, "--clientstats",
 			"--nodetype=meta", mountoption, "--allstats")
@@ -162,26 +166,27 @@ func (m *BeegfsMetaCollector) Read(interval time.Duration, output chan lp.CCMess
 		cmd.Stderr = cmdStderr
 		err := cmd.Run()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "BeegfsMetaCollector.Read(): Failed to execute command \"%s\": %s\n", cmd.String(), err.Error())
+			dataStdErr, _ := io.ReadAll(cmdStderr)
-			fmt.Fprintf(os.Stderr, "BeegfsMetaCollector.Read(): command exit code: \"%d\"\n", cmd.ProcessState.ExitCode())
+			dataStdOut, _ := io.ReadAll(cmdStdout)
-			data, _ := io.ReadAll(cmdStderr)
+			cclog.ComponentError(
-			fmt.Fprintf(os.Stderr, "BeegfsMetaCollector.Read(): command stderr: \"%s\"\n", string(data))
+				m.name,
-			data, _ = io.ReadAll(cmdStdout)
+				fmt.Sprintf("Read(): Failed to execute command \"%s\": %v\n", cmd.String(), err),
-			fmt.Fprintf(os.Stderr, "BeegfsMetaCollector.Read(): command stdout: \"%s\"\n", string(data))
+				fmt.Sprintf("Read(): command exit code: \"%d\"\n", cmd.ProcessState.ExitCode()),
+				fmt.Sprintf("Read(): command stderr: \"%s\"\n", string(dataStdErr)),
+				fmt.Sprintf("Read(): command stdout: \"%s\"\n", string(dataStdOut)),
+			)
 			return
 		}
 		// Read I/O statistics
 		scanner := bufio.NewScanner(cmdStdout)
 
 		sumLine := regexp.MustCompile(`^Sum:\s+\d+\s+\[[a-zA-Z]+\]+`)
-		//Line := regexp.MustCompile(`^(.*)\s+(\d)+\s+\[([a-zA-Z]+)\]+`)
 		statsLine := regexp.MustCompile(`^(.*?)\s+?(\d.*?)$`)
 		singleSpacePattern := regexp.MustCompile(`\s+`)
 		removePattern := regexp.MustCompile(`[\[|\]]`)
 
 		for scanner.Scan() {
 			readLine := scanner.Text()
-			//fmt.Println(readLine)
 			// Jump few lines, we only want the I/O stats from nodes
 			if !sumLine.MatchString(readLine) {
 				continue
@@ -190,7 +195,7 @@ func (m *BeegfsMetaCollector) Read(interval time.Duration, output chan lp.CCMess
 			match := statsLine.FindStringSubmatch(readLine)
 			// nodeName = "Sum:" or would be nodes
 			// nodeName := match[1]
-			//Remove multiple whitespaces
+			// Remove multiple whitespaces
 			dummy := removePattern.ReplaceAllString(match[2], " ")
 			metaStats := strings.TrimSpace(singleSpacePattern.ReplaceAllString(dummy, " "))
 			split := strings.Split(metaStats, " ")
@@ -216,15 +221,13 @@ func (m *BeegfsMetaCollector) Read(interval time.Duration, output chan lp.CCMess
 							fmt.Sprintf("Metric (other): Failed to convert str written '%s' to float: %v", m.matches["other"], err))
 						continue
 					}
-					//mdStat["other"] = fmt.Sprintf("%f", f1+f2)
 					m.matches["beegfs_cstorage_other"] = fmt.Sprintf("%f", f1+f2)
 				}
 			}
 
 			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())
+				if y, err := lp.NewMetric(key, m.tags, m.meta, value, time.Now()); err == nil {
-				if err == nil {
 					output <- y
 				}
 			}

collectors/beegfsstorageMetric.go

@@ -17,23 +17,25 @@ import (
 	"os/exec"
 	"os/user"
 	"regexp"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 // Struct for the collector-specific JSON config
 type BeegfsStorageCollectorConfig struct {
-	Beegfs            string   `json:"beegfs_path"`
+	Beegfs             string   `json:"beegfs_path"`
-	ExcludeMetrics    []string `json:"exclude_metrics,omitempty"`
+	ExcludeMetrics     []string `json:"exclude_metrics,omitempty"`
-	ExcludeFilesystem []string `json:"exclude_filesystem"`
+	ExcludeFilesystems []string `json:"exclude_filesystem"`
 }
 
 type BeegfsStorageCollector struct {
 	metricCollector
+
 	tags    map[string]string
 	matches map[string]string
 	config  BeegfsStorageCollectorConfig
@@ -46,15 +48,18 @@ func (m *BeegfsStorageCollector) Init(config json.RawMessage) error {
 		return nil
 	}
 	// Metrics
-	var storageStat_array = [18]string{
+	storageStat_array := [18]string{
 		"sum", "ack", "sChDrct", "getFSize",
 		"sAttr", "statfs", "trunc", "close",
 		"fsync", "ops-rd", "MiB-rd/s", "ops-wr",
 		"MiB-wr/s", "gendbg", "hrtbeat", "remNode",
-		"storInf", "unlnk"}
+		"storInf", "unlnk",
+	}
 
 	m.name = "BeegfsStorageCollector"
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	m.parallel = true
 	// Set default beegfs-ctl binary
 
@@ -62,17 +67,17 @@ func (m *BeegfsStorageCollector) Init(config json.RawMessage) error {
 
 	// Read JSON configuration
 	if len(config) > 0 {
-		err := json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): failed to decode JSON config: %w", m.name, err)
 		}
 	}
-	println(m.config.Beegfs)
+
-	//create map with possible variables
+	// Create map with possible variables
 	m.matches = make(map[string]string)
 	for _, value := range storageStat_array {
-		_, skip := stringArrayContains(m.config.ExcludeMetrics, value)
+		if slices.Contains(m.config.ExcludeMetrics, value) {
-		if skip {
 			m.matches["other"] = "0"
 		} else {
 			m.matches["beegfs_cstorage_"+value] = "0"
@@ -88,23 +93,23 @@ func (m *BeegfsStorageCollector) Init(config json.RawMessage) error {
 		"filesystem": "",
 	}
 	m.skipFS = make(map[string]struct{})
-	for _, fs := range m.config.ExcludeFilesystem {
+	for _, fs := range m.config.ExcludeFilesystems {
 		m.skipFS[fs] = struct{}{}
 	}
 
 	// Beegfs file system statistics can only be queried by user root
 	user, err := user.Current()
 	if err != nil {
-		return fmt.Errorf("BeegfsStorageCollector.Init(): Failed to get current user: %v", err)
+		return fmt.Errorf("%s Init(): Failed to get current user: %w", m.name, err)
 	}
 	if user.Uid != "0" {
-		return fmt.Errorf("BeegfsStorageCollector.Init(): BeeGFS file system statistics can only be queried by user root")
+		return fmt.Errorf("%s Init(): BeeGFS file system statistics can only be queried by user root", m.name)
 	}
 
 	// Check if beegfs-ctl is in executable search path
 	_, err = exec.LookPath(m.config.Beegfs)
 	if err != nil {
-		return fmt.Errorf("BeegfsStorageCollector.Init(): Failed to find beegfs-ctl binary '%s': %v", m.config.Beegfs, err)
+		return fmt.Errorf("%s Init(): Failed to find beegfs-ctl binary '%s': %w", m.name, m.config.Beegfs, err)
 	}
 	m.init = true
 	return nil
@@ -114,11 +119,10 @@ func (m *BeegfsStorageCollector) Read(interval time.Duration, output chan lp.CCM
 	if !m.init {
 		return
 	}
-	//get mounpoint
+	// Get mounpoint
-	buffer, _ := os.ReadFile(string("/proc/mounts"))
+	buffer, _ := os.ReadFile("/proc/mounts")
-	mounts := strings.Split(string(buffer), "\n")
 	var mountpoints []string
-	for _, line := range mounts {
+	for line := range strings.Lines(string(buffer)) {
 		if len(line) == 0 {
 			continue
 		}
@@ -143,7 +147,6 @@ func (m *BeegfsStorageCollector) Read(interval time.Duration, output chan lp.CCM
 		// --nodetype=meta: The node type to query (meta, storage).
 		// --interval:
 		// --mount=/mnt/beeond/: Which mount point
-		//cmd := exec.Command(m.config.Beegfs, "/root/mc/test.txt")
 		mountoption := "--mount=" + mountpoint
 		cmd := exec.Command(m.config.Beegfs, "--clientstats",
 			"--nodetype=storage", mountoption, "--allstats")
@@ -154,26 +157,27 @@ func (m *BeegfsStorageCollector) Read(interval time.Duration, output chan lp.CCM
 		cmd.Stderr = cmdStderr
 		err := cmd.Run()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "BeegfsStorageCollector.Read(): Failed to execute command \"%s\": %s\n", cmd.String(), err.Error())
+			dataStdErr, _ := io.ReadAll(cmdStderr)
-			fmt.Fprintf(os.Stderr, "BeegfsStorageCollector.Read(): command exit code: \"%d\"\n", cmd.ProcessState.ExitCode())
+			dataStdOut, _ := io.ReadAll(cmdStdout)
-			data, _ := io.ReadAll(cmdStderr)
+			cclog.ComponentError(
-			fmt.Fprintf(os.Stderr, "BeegfsStorageCollector.Read(): command stderr: \"%s\"\n", string(data))
+				m.name,
-			data, _ = io.ReadAll(cmdStdout)
+				fmt.Sprintf("Read(): Failed to execute command \"%s\": %v\n", cmd.String(), err),
-			fmt.Fprintf(os.Stderr, "BeegfsStorageCollector.Read(): command stdout: \"%s\"\n", string(data))
+				fmt.Sprintf("Read(): command exit code: \"%d\"\n", cmd.ProcessState.ExitCode()),
+				fmt.Sprintf("Read(): command stderr: \"%s\"\n", string(dataStdErr)),
+				fmt.Sprintf("Read(): command stdout: \"%s\"\n", string(dataStdOut)),
+			)
 			return
 		}
 		// Read I/O statistics
 		scanner := bufio.NewScanner(cmdStdout)
 
 		sumLine := regexp.MustCompile(`^Sum:\s+\d+\s+\[[a-zA-Z]+\]+`)
-		//Line := regexp.MustCompile(`^(.*)\s+(\d)+\s+\[([a-zA-Z]+)\]+`)
 		statsLine := regexp.MustCompile(`^(.*?)\s+?(\d.*?)$`)
 		singleSpacePattern := regexp.MustCompile(`\s+`)
 		removePattern := regexp.MustCompile(`[\[|\]]`)
 
 		for scanner.Scan() {
 			readLine := scanner.Text()
-			//fmt.Println(readLine)
 			// Jump few lines, we only want the I/O stats from nodes
 			if !sumLine.MatchString(readLine) {
 				continue
@@ -182,7 +186,7 @@ func (m *BeegfsStorageCollector) Read(interval time.Duration, output chan lp.CCM
 			match := statsLine.FindStringSubmatch(readLine)
 			// nodeName = "Sum:" or would be nodes
 			// nodeName := match[1]
-			//Remove multiple whitespaces
+			// Remove multiple whitespaces
 			dummy := removePattern.ReplaceAllString(match[2], " ")
 			metaStats := strings.TrimSpace(singleSpacePattern.ReplaceAllString(dummy, " "))
 			split := strings.Split(metaStats, " ")
@@ -193,7 +197,6 @@ func (m *BeegfsStorageCollector) Read(interval time.Duration, output chan lp.CCM
 			for i := 0; i <= len(split)-1; i += 2 {
 				if _, ok := m.matches[split[i+1]]; ok {
 					m.matches["beegfs_cstorage_"+split[i+1]] = split[i]
-					//m.matches[split[i+1]] = split[i]
 				} else {
 					f1, err := strconv.ParseFloat(m.matches["other"], 32)
 					if err != nil {
@@ -215,8 +218,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())
+				if y, err := lp.NewMetric(key, m.tags, m.meta, value, time.Now()); err == nil {
-				if err == nil {
 					output <- y
 				}
 			}

collectors/beegfsstorageMetric.md

@@ -14,14 +14,14 @@ This Collector is to collect BeeGFS on Demand (BeeOND) storage stats.
 
 ```json
   "beegfs_storage": {
-	"beegfs_path": "/usr/bin/beegfs-ctl",
+    "beegfs_path": "/usr/bin/beegfs-ctl",
     "exclude_filesystem": [
       "/mnt/ignore_me"
     ],
     "exclude_metrics": [     
-          "ack",
+      "ack",
-		  "storInf",
+      "storInf",
-		  "unlnk"
+      "unlnk"
     ]
   }
 ```

collectors/collectorManager.go

@@ -8,65 +8,70 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
+	"fmt"
 	"sync"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 	mct "github.com/ClusterCockpit/cc-metric-collector/pkg/multiChanTicker"
 )
 
 // Map of all available metric collectors
 var AvailableCollectors = map[string]MetricCollector{
-
+	"likwid":             new(LikwidCollector),
-	"likwid":          new(LikwidCollector),
+	"loadavg":            new(LoadavgCollector),
-	"loadavg":         new(LoadavgCollector),
+	"memstat":            new(MemstatCollector),
-	"memstat":         new(MemstatCollector),
+	"netstat":            new(NetstatCollector),
-	"netstat":         new(NetstatCollector),
+	"ibstat":             new(InfinibandCollector),
-	"ibstat":          new(InfinibandCollector),
+	"lustrestat":         new(LustreCollector),
-	"lustrestat":      new(LustreCollector),
+	"cpustat":            new(CpustatCollector),
-	"cpustat":         new(CpustatCollector),
+	"topprocs":           new(TopProcsCollector),
-	"topprocs":        new(TopProcsCollector),
+	"nvidia":             new(NvidiaCollector),
-	"nvidia":          new(NvidiaCollector),
+	"customcmd":          new(CustomCmdCollector),
-	"customcmd":       new(CustomCmdCollector),
+	"iostat":             new(IOstatCollector),
-	"iostat":          new(IOstatCollector),
+	"diskstat":           new(DiskstatCollector),
-	"diskstat":        new(DiskstatCollector),
+	"tempstat":           new(TempCollector),
-	"tempstat":        new(TempCollector),
+	"ipmistat":           new(IpmiCollector),
-	"ipmistat":        new(IpmiCollector),
+	"gpfs":               new(GpfsCollector),
-	"gpfs":            new(GpfsCollector),
+	"cpufreq":            new(CPUFreqCollector),
-	"cpufreq":         new(CPUFreqCollector),
+	"cpufreq_cpuinfo":    new(CPUFreqCpuInfoCollector),
-	"cpufreq_cpuinfo": new(CPUFreqCpuInfoCollector),
+	"nfs3stat":           new(Nfs3Collector),
-	"nfs3stat":        new(Nfs3Collector),
+	"nfs4stat":           new(Nfs4Collector),
-	"nfs4stat":        new(Nfs4Collector),
+	"numastats":          new(NUMAStatsCollector),
-	"numastats":       new(NUMAStatsCollector),
+	"beegfs_meta":        new(BeegfsMetaCollector),
-	"beegfs_meta":     new(BeegfsMetaCollector),
+	"beegfs_storage":     new(BeegfsStorageCollector),
-	"beegfs_storage":  new(BeegfsStorageCollector),
+	"rapl":               new(RAPLCollector),
-	"rapl":            new(RAPLCollector),
+	"rocm_smi":           new(RocmSmiCollector),
-	"rocm_smi":        new(RocmSmiCollector),
+	"self":               new(SelfCollector),
-	"self":            new(SelfCollector),
+	"schedstat":          new(SchedstatCollector),
-	"schedstat":       new(SchedstatCollector),
+	"nfsiostat":          new(NfsIOStatCollector),
-	"nfsiostat":       new(NfsIOStatCollector),
+	"slurm_cgroup":       new(SlurmCgroupCollector),
-	"slurm_cgroup":    new(SlurmCgroupCollector),
+	"smartmon":           new(SmartMonCollector),
+	"lenovo_dense_power": new(LenovoDensePowerCollector),
+	"megware_eureka":     new(MegwareEurekaCollector),
 }
 
 // Metric collector manager data structure
 type collectorManager struct {
-	collectors   []MetricCollector          // List of metric collectors to read in parallel
+	collectors    []MetricCollector          // List of metric collectors to read in parallel
-	serial       []MetricCollector          // List of metric collectors to read serially
+	serial        []MetricCollector          // List of metric collectors to read serially
-	output       chan lp.CCMessage          // Output channels
+	output        chan lp.CCMessage          // Output channels
-	done         chan bool                  // channel to finish / stop metric collector manager
+	done          chan bool                  // channel to finish / stop metric collector manager
-	ticker       mct.MultiChanTicker        // periodically ticking once each interval
+	ticker        mct.MultiChanTicker        // periodically ticking once each interval
-	duration     time.Duration              // duration (for metrics that measure over a given duration)
+	duration      time.Duration              // duration (for metrics that measure over a given duration)
-	wg           *sync.WaitGroup            // wait group for all goroutines in cc-metric-collector
+	wg            *sync.WaitGroup            // wait group for all goroutines in cc-metric-collector
-	config       map[string]json.RawMessage // json encoded config for collector manager
+	config        map[string]json.RawMessage // json encoded config for collector manager
-	collector_wg sync.WaitGroup             // internally used wait group for the parallel reading of collector
+	collector_wg  sync.WaitGroup             // internally used wait group for the parallel reading of collector
-	parallel_run bool                       // Flag whether the collectors are currently read in parallel
+	parallel_run  bool                       // Flag whether the collectors are currently read in parallel
+	enableMarkers bool                       // Send ccmc-{begin,end} metrics
 }
 
 // Metric collector manager access functions
 type CollectorManager interface {
-	Init(ticker mct.MultiChanTicker, duration time.Duration, wg *sync.WaitGroup, collectConfig json.RawMessage) error
+	Init(ticker mct.MultiChanTicker, duration time.Duration, enableMarkers bool, wg *sync.WaitGroup, collectConfig json.RawMessage) error
 	AddOutput(output chan lp.CCMessage)
 	Start()
 	Close()
@@ -79,7 +84,7 @@ type CollectorManager interface {
 // * ticker (from variable ticker)
 // * configuration (read from config file in variable collectConfigFile)
 // Initialization is done for all configured collectors
-func (cm *collectorManager) Init(ticker mct.MultiChanTicker, duration time.Duration, wg *sync.WaitGroup, collectConfig json.RawMessage) error {
+func (cm *collectorManager) Init(ticker mct.MultiChanTicker, duration time.Duration, enableMarkers bool, wg *sync.WaitGroup, collectConfig json.RawMessage) error {
 	cm.collectors = make([]MetricCollector, 0)
 	cm.serial = make([]MetricCollector, 0)
 	cm.output = nil
@@ -87,11 +92,12 @@ func (cm *collectorManager) Init(ticker mct.MultiChanTicker, duration time.Durat
 	cm.wg = wg
 	cm.ticker = ticker
 	cm.duration = duration
+	cm.enableMarkers = enableMarkers
 
-	err := json.Unmarshal(collectConfig, &cm.config)
+	d := json.NewDecoder(bytes.NewReader(collectConfig))
-	if err != nil {
+	d.DisallowUnknownFields()
-		cclog.Error(err.Error())
+	if err := d.Decode(&cm.config); err != nil {
-		return err
+		return fmt.Errorf("%s Init(): Error decoding collector manager config: %w", "CollectorManager", err)
 	}
 
 	// Initialize configured collectors
@@ -102,9 +108,9 @@ func (cm *collectorManager) Init(ticker mct.MultiChanTicker, duration time.Durat
 		}
 		collector := AvailableCollectors[collectorName]
 
-		err = collector.Init(collectorCfg)
+		err := collector.Init(collectorCfg)
 		if err != nil {
-			cclog.ComponentError("CollectorManager", "Collector", collectorName, "initialization failed:", err.Error())
+			cclog.ComponentError("CollectorManager", fmt.Sprintf("Collector %s initialization failed: %v", collectorName, err))
 			continue
 		}
 		cclog.ComponentDebug("CollectorManager", "ADD COLLECTOR", collector.Name())
@@ -122,9 +128,7 @@ func (cm *collectorManager) Start() {
 	tick := make(chan time.Time)
 	cm.ticker.AddChannel(tick)
 
-	cm.wg.Add(1)
+	cm.wg.Go(func() {
-	go func() {
-		defer cm.wg.Done()
 		// Collector manager is done
 		done := func() {
 			// close all metric collectors
@@ -146,6 +150,9 @@ func (cm *collectorManager) Start() {
 				done()
 				return
 			case t := <-tick:
+				if cm.enableMarkers {
+					lp.NewMetric("ccmc-begin", map[string]string{"type": "node"}, nil, map[string]interface{}{"value": 0}, time.Now())
+				}
 				cm.parallel_run = true
 				for _, c := range cm.collectors {
 					// Wait for done signal or execute the collector
@@ -177,9 +184,12 @@ func (cm *collectorManager) Start() {
 						c.Read(cm.duration, cm.output)
 					}
 				}
+				if cm.enableMarkers {
+					lp.NewMetric("ccmc-end", map[string]string{"type": "node"}, nil, map[string]interface{}{"value": 0}, time.Now())
+				}
 			}
 		}
-	}()
+	})
 
 	// Collector manager is started
 	cclog.ComponentDebug("CollectorManager", "STARTED")
@@ -199,9 +209,9 @@ func (cm *collectorManager) Close() {
 }
 
 // New creates a new initialized metric collector manager
-func New(ticker mct.MultiChanTicker, duration time.Duration, wg *sync.WaitGroup, collectConfig json.RawMessage) (CollectorManager, error) {
+func New(ticker mct.MultiChanTicker, duration time.Duration, enableMarkers bool, wg *sync.WaitGroup, collectConfig json.RawMessage) (CollectorManager, error) {
 	cm := new(collectorManager)
-	err := cm.Init(ticker, duration, wg, collectConfig)
+	err := cm.Init(ticker, duration, enableMarkers, wg, collectConfig)
 	if err != nil {
 		return nil, err
 	}

collectors/cpufreqCpuinfoMetric.go

@@ -10,15 +10,14 @@ package collectors
 import (
 	"bufio"
 	"encoding/json"
-
 	"fmt"
 	"os"
 	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 // CPUFreqCollector
@@ -32,18 +31,20 @@ type CPUFreqCpuInfoCollectorTopology struct {
 
 type CPUFreqCpuInfoCollector struct {
 	metricCollector
+
 	topology []CPUFreqCpuInfoCollectorTopology
 }
 
-func (m *CPUFreqCpuInfoCollector) Init(config json.RawMessage) error {
+func (m *CPUFreqCpuInfoCollector) Init(_ json.RawMessage) error {
 	// Check if already initialized
 	if m.init {
 		return nil
 	}
 
-	m.setup()
-
 	m.name = "CPUFreqCpuInfoCollector"
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	m.parallel = true
 	m.meta = map[string]string{
 		"source": m.name,
@@ -54,9 +55,8 @@ func (m *CPUFreqCpuInfoCollector) Init(config json.RawMessage) error {
 	const cpuInfoFile = "/proc/cpuinfo"
 	file, err := os.Open(cpuInfoFile)
 	if err != nil {
-		return fmt.Errorf("failed to open file '%s': %v", cpuInfoFile, err)
+		return fmt.Errorf("%s Init(): failed to open file '%s': %w", m.name, cpuInfoFile, err)
 	}
-	defer file.Close()
 
 	// Collect topology information from file cpuinfo
 	foundFreq := false
@@ -116,10 +116,17 @@ func (m *CPUFreqCpuInfoCollector) Init(config json.RawMessage) error {
 			physicalPackageID = ""
 		}
 	}
+	if err := scanner.Err(); err != nil {
+		return fmt.Errorf("%s Init(): Call to scanner.Err failed: %w", m.name, err)
+	}
+
+	if err := file.Close(); err != nil {
+		return fmt.Errorf("%s Init(): Call to file.Close() failed: %w", m.name, err)
+	}
 
 	// Check if at least one CPU with frequency information was detected
 	if len(m.topology) == 0 {
-		return fmt.Errorf("no CPU frequency info found in %s", cpuInfoFile)
+		return fmt.Errorf("%s Init(): no CPU frequency info found in %s", m.name, cpuInfoFile)
 	}
 
 	m.init = true
@@ -140,7 +147,13 @@ func (m *CPUFreqCpuInfoCollector) Read(interval time.Duration, output chan lp.CC
 			fmt.Sprintf("Read(): Failed to open file '%s': %v", cpuInfoFile, err))
 		return
 	}
-	defer file.Close()
+	defer func() {
+		if err := file.Close(); err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to close file '%s': %v", cpuInfoFile, err))
+		}
+	}()
 
 	processorCounter := 0
 	now := time.Now()
@@ -161,7 +174,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.NewMetric("cpufreq", t.tagSet, m.meta, value, now); err == nil {
 						output <- y
 					}
 				}
@@ -169,6 +182,9 @@ func (m *CPUFreqCpuInfoCollector) Read(interval time.Duration, output chan lp.CC
 			}
 		}
 	}
+	if err := scanner.Err(); err != nil {
+		cclog.ComponentErrorf(m.name, "Read(): Call to scanner.Err failed: %s", err.Error())
+	}
 }
 
 func (m *CPUFreqCpuInfoCollector) Close() {

collectors/cpufreqCpuinfoMetric.md

@@ -12,7 +12,9 @@ hugo_path: docs/reference/cc-metric-collector/collectors/cpufreq_cpuinfo.md
 ## `cpufreq_cpuinfo` collector
 
 ```json
-  "cpufreq_cpuinfo": {}
+  "cpufreq_cpuinfo": {
+    "exclude_metrics": []
+  }
 ```
 
 The `cpufreq_cpuinfo` collector reads the clock frequency from `/proc/cpuinfo` and outputs a handful **hwthread** metrics.

collectors/cpufreqMetric.go

@@ -8,6 +8,7 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"os"
@@ -16,8 +17,8 @@ import (
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 	"github.com/ClusterCockpit/cc-metric-collector/pkg/ccTopology"
 	"golang.org/x/sys/unix"
 )
@@ -35,6 +36,7 @@ type CPUFreqCollectorTopology struct {
 // See: https://www.kernel.org/doc/html/latest/admin-guide/pm/cpufreq.html
 type CPUFreqCollector struct {
 	metricCollector
+
 	topology []CPUFreqCollectorTopology
 	config   struct {
 		ExcludeMetrics []string `json:"exclude_metrics,omitempty"`
@@ -48,12 +50,15 @@ func (m *CPUFreqCollector) Init(config json.RawMessage) error {
 	}
 
 	m.name = "CPUFreqCollector"
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	m.parallel = true
 	if len(config) > 0 {
-		err := json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): failed to decode JSON config: %w", m.name, err)
 		}
 	}
 	m.meta = map[string]string{
@@ -74,15 +79,15 @@ func (m *CPUFreqCollector) Init(config json.RawMessage) error {
 		scalingCurFreqFile := filepath.Join("/sys/devices/system/cpu", fmt.Sprintf("cpu%d", c.CpuID), "cpufreq/scaling_cur_freq")
 		err := unix.Access(scalingCurFreqFile, unix.R_OK)
 		if err != nil {
-			return fmt.Errorf("unable to access file '%s': %v", scalingCurFreqFile, err)
+			return fmt.Errorf("%s Init(): unable to access file '%s': %w", m.name, scalingCurFreqFile, err)
 		}
 
 		m.topology = append(m.topology,
 			CPUFreqCollectorTopology{
 				tagSet: map[string]string{
 					"type":       "hwthread",
-					"type-id":    fmt.Sprint(c.CpuID),
+					"type-id":    strconv.Itoa(c.CpuID),
-					"package_id": fmt.Sprint(c.Socket),
+					"package_id": strconv.Itoa(c.Socket),
 				},
 				scalingCurFreqFile: scalingCurFreqFile,
 			},
@@ -124,7 +129,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.NewMetric("cpufreq", t.tagSet, m.meta, cpuFreq, now); err == nil {
 			output <- y
 		}
 	}

collectors/cpustatMetric.go

@@ -9,15 +9,17 @@ package collectors
 
 import (
 	"bufio"
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"os"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 	sysconf "github.com/tklauser/go-sysconf"
 )
 
@@ -25,10 +27,12 @@ const CPUSTATFILE = `/proc/stat`
 
 type CpustatCollectorConfig struct {
 	ExcludeMetrics []string `json:"exclude_metrics,omitempty"`
+	excludeNumCPUs bool
 }
 
 type CpustatCollector struct {
 	metricCollector
+
 	config        CpustatCollectorConfig
 	lastTimestamp time.Time // Store time stamp of last tick to derive values
 	matches       map[string]int
@@ -39,14 +43,22 @@ type CpustatCollector struct {
 
 func (m *CpustatCollector) Init(config json.RawMessage) error {
 	m.name = "CpustatCollector"
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %s", m.name, err.Error())
+	}
 	m.parallel = true
-	m.meta = map[string]string{"source": m.name, "group": "CPU"}
+	m.meta = map[string]string{
-	m.nodetags = map[string]string{"type": "node"}
+		"source": m.name,
+		"group":  "CPU",
+	}
+	m.nodetags = map[string]string{
+		"type": "node",
+	}
 	if len(config) > 0 {
-		err := json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %s", m.name, err.Error())
 		}
 	}
 	matches := map[string]int{
@@ -64,24 +76,17 @@ func (m *CpustatCollector) Init(config json.RawMessage) error {
 
 	m.matches = make(map[string]int)
 	for match, index := range matches {
-		doExclude := false
+		if !slices.Contains(m.config.ExcludeMetrics, match) {
-		for _, exclude := range m.config.ExcludeMetrics {
-			if match == exclude {
-				doExclude = true
-				break
-			}
-		}
-		if !doExclude {
 			m.matches[match] = index
 		}
 	}
+	m.config.excludeNumCPUs = slices.Contains(m.config.ExcludeMetrics, "num_cpus")
 
 	// Check input file
-	file, err := os.Open(string(CPUSTATFILE))
+	file, err := os.Open(CPUSTATFILE)
 	if err != nil {
-		cclog.ComponentError(m.name, err.Error())
+		return fmt.Errorf("%s Init(): Failed to open file '%s': %s", m.name, CPUSTATFILE, err.Error())
 	}
-	defer file.Close()
 
 	// Pre-generate tags for all CPUs
 	num_cpus := 0
@@ -92,14 +97,19 @@ func (m *CpustatCollector) Init(config json.RawMessage) error {
 		line := scanner.Text()
 		linefields := strings.Fields(line)
 		if strings.Compare(linefields[0], "cpu") == 0 {
+			// Kernel system statistics for all CPUs
 			m.olddata["cpu"] = make(map[string]int64)
 			for k, v := range m.matches {
 				m.olddata["cpu"][k], _ = strconv.ParseInt(linefields[v], 0, 64)
 			}
 		} else if strings.HasPrefix(linefields[0], "cpu") && strings.Compare(linefields[0], "cpu") != 0 {
+			// Kernel system statistics per CPU
 			cpustr := strings.TrimLeft(linefields[0], "cpu")
 			cpu, _ := strconv.Atoi(cpustr)
-			m.cputags[linefields[0]] = map[string]string{"type": "hwthread", "type-id": fmt.Sprintf("%d", cpu)}
+			m.cputags[linefields[0]] = map[string]string{
+				"type":    "hwthread",
+				"type-id": strconv.Itoa(cpu),
+			}
 			m.olddata[linefields[0]] = make(map[string]int64)
 			for k, v := range m.matches {
 				m.olddata[linefields[0]][k], _ = strconv.ParseInt(linefields[v], 0, 64)
@@ -107,6 +117,15 @@ func (m *CpustatCollector) Init(config json.RawMessage) error {
 			num_cpus++
 		}
 	}
+	if err := scanner.Err(); err != nil {
+		return fmt.Errorf("%s Init(): Call to scanner.Err failed: %s", m.name, err.Error())
+	}
+
+	// Close file
+	if err := file.Close(); err != nil {
+		return fmt.Errorf("%s Init(): Failed to close file '%s': %s", m.name, CPUSTATFILE, err.Error())
+	}
+
 	m.lastTimestamp = time.Now()
 	m.init = true
 	return nil
@@ -129,7 +148,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.NewMetric(name, tags, m.meta, value*100, now)
 		if err == nil {
 			y.AddTag("unit", "Percent")
 			output <- y
@@ -137,7 +156,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.NewMetric("cpu_used", tags, m.meta, sum*100, now)
 		if err == nil {
 			y.AddTag("unit", "Percent")
 			output <- y
@@ -153,11 +172,19 @@ func (m *CpustatCollector) Read(interval time.Duration, output chan lp.CCMessage
 	now := time.Now()
 	tsdelta := now.Sub(m.lastTimestamp)
 
-	file, err := os.Open(string(CPUSTATFILE))
+	file, err := os.Open(CPUSTATFILE)
 	if err != nil {
-		cclog.ComponentError(m.name, err.Error())
+		cclog.ComponentError(
+			m.name,
+			fmt.Sprintf("Read(): Failed to open file '%s': %v", CPUSTATFILE, err.Error()))
 	}
-	defer file.Close()
+	defer func() {
+		if err := file.Close(); err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to close file '%s': %v", string(CPUSTATFILE), err.Error()))
+		}
+	}()
 
 	scanner := bufio.NewScanner(file)
 	for scanner.Scan() {
@@ -170,15 +197,14 @@ func (m *CpustatCollector) Read(interval time.Duration, output chan lp.CCMessage
 			num_cpus++
 		}
 	}
+	if err := scanner.Err(); err != nil {
+		cclog.ComponentErrorf(m.name, "Init(): Call to scanner.Err failed: %s", err.Error())
+	}
 
-	num_cpus_metric, err := lp.NewMessage("num_cpus",
+	if !m.config.excludeNumCPUs {
-		m.nodetags,
+		if num_cpus_metric, err := lp.NewMetric("num_cpus", m.nodetags, m.meta, num_cpus, now); err == nil {
-		m.meta,
+			output <- num_cpus_metric
-		map[string]interface{}{"value": int(num_cpus)},
+		}
-		now,
-	)
-	if err == nil {
-		output <- num_cpus_metric
 	}
 
 	m.lastTimestamp = now

collectors/customCmdMetric.go

@@ -8,16 +8,17 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
-	"errors"
+	"fmt"
-	"log"
 	"os"
 	"os/exec"
+	"slices"
 	"strings"
 	"time"
 
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	influx "github.com/influxdata/line-protocol"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 const CUSTOMCMDPATH = `/home/unrz139/Work/cc-metric-collector/collectors/custom`
@@ -30,102 +31,124 @@ type CustomCmdCollectorConfig struct {
 
 type CustomCmdCollector struct {
 	metricCollector
-	handler  *influx.MetricHandler
+
-	parser   *influx.Parser
+	config         CustomCmdCollectorConfig
-	config   CustomCmdCollectorConfig
+	cmdFieldsSlice [][]string
-	commands []string
+	files          []string
-	files    []string
 }
 
 func (m *CustomCmdCollector) Init(config json.RawMessage) error {
-	var err error
 	m.name = "CustomCmdCollector"
 	m.parallel = true
-	m.meta = map[string]string{"source": m.name, "group": "Custom"}
+	m.meta = map[string]string{
+		"source": m.name,
+		"group":  "Custom",
+	}
+
+	// Read configuration
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			log.Print(err.Error())
+		if err := d.Decode(&m.config); err != nil {
-			return err
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
-	m.setup()
+
+	// Setup
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
+
+	// Check if command can be executed
 	for _, c := range m.config.Commands {
-		cmdfields := strings.Fields(c)
+		cmdFields := strings.Fields(c)
-		command := exec.Command(cmdfields[0], strings.Join(cmdfields[1:], " "))
+		command := exec.Command(cmdFields[0], cmdFields[1:]...)
-		command.Wait()
+		if _, err := command.Output(); err != nil {
-		_, err = command.Output()
+			cclog.ComponentWarn(
-		if err == nil {
+				m.name,
-			m.commands = append(m.commands, c)
+				fmt.Sprintf("%s Init(): Execution of command \"%s\" failed: %v", m.name, command.String(), err))
-		}
-	}
-	for _, f := range m.config.Files {
-		_, err = os.ReadFile(f)
-		if err == nil {
-			m.files = append(m.files, f)
-		} else {
-			log.Print(err.Error())
 			continue
 		}
+		m.cmdFieldsSlice = append(m.cmdFieldsSlice, cmdFields)
 	}
-	if len(m.files) == 0 && len(m.commands) == 0 {
+
-		return errors.New("no metrics to collect")
+	// Check if file can be read
+	for _, fileName := range m.config.Files {
+		if _, err := os.ReadFile(fileName); err != nil {
+			cclog.ComponentWarn(
+				m.name,
+				fmt.Sprintf("%s Init(): Reading of file \"%s\" failed: %v", m.name, fileName, err))
+			continue
+		}
+		m.files = append(m.files, fileName)
+	}
+
+	if len(m.files) == 0 && len(m.cmdFieldsSlice) == 0 {
+		return fmt.Errorf("%s Init(): no metrics to collect", m.name)
 	}
-	m.handler = influx.NewMetricHandler()
-	m.parser = influx.NewParser(m.handler)
-	m.parser.SetTimeFunc(DefaultTime)
 	m.init = true
 	return nil
 }
 
-var DefaultTime = func() time.Time {
-	return time.Unix(42, 0)
-}
-
 func (m *CustomCmdCollector) Read(interval time.Duration, output chan lp.CCMessage) {
 	if !m.init {
 		return
 	}
-	for _, cmd := range m.commands {
+
-		cmdfields := strings.Fields(cmd)
+	// Execute configured commands
-		command := exec.Command(cmdfields[0], strings.Join(cmdfields[1:], " "))
+	for _, cmdFields := range m.cmdFieldsSlice {
-		command.Wait()
+		command := exec.Command(cmdFields[0], cmdFields[1:]...)
 		stdout, err := command.Output()
 		if err != nil {
-			log.Print(err)
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to read command output for command \"%s\": %v", command.String(), err),
+			)
 			continue
 		}
-		cmdmetrics, err := m.parser.Parse(stdout)
+
+		// Read and decode influxDB line-protocol from command output
+		metrics, err := lp.FromBytes(stdout)
 		if err != nil {
-			log.Print(err)
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to decode influx Message: %v", err),
+			)
 			continue
 		}
-		for _, c := range cmdmetrics {
+		for _, metric := range metrics {
-			_, skip := stringArrayContains(m.config.ExcludeMetrics, c.Name())
+			if slices.Contains(m.config.ExcludeMetrics, metric.Name()) {
-			if skip {
 				continue
 			}
-
+			output <- metric
-			output <- lp.FromInfluxMetric(c)
 		}
 	}
-	for _, file := range m.files {
+
-		buffer, err := os.ReadFile(file)
+	// Read configured files
+	for _, filename := range m.files {
+		input, err := os.ReadFile(filename)
 		if err != nil {
-			log.Print(err)
+			cclog.ComponentError(
-			return
+				m.name,
-		}
+				fmt.Sprintf("Read(): Failed to read file \"%s\": %v\n", filename, err),
-		fmetrics, err := m.parser.Parse(buffer)
+			)
-		if err != nil {
-			log.Print(err)
 			continue
 		}
-		for _, f := range fmetrics {
+
-			_, skip := stringArrayContains(m.config.ExcludeMetrics, f.Name())
+		// Read and decode influxDB line-protocol from file
-			if skip {
+		metrics, err := lp.FromBytes(input)
+		if err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to decode influx Message: %v", err),
+			)
+			continue
+		}
+		for _, metric := range metrics {
+			if slices.Contains(m.config.ExcludeMetrics, metric.Name()) {
 				continue
 			}
-			output <- lp.FromInfluxMetric(f)
+			output <- metric
 		}
 	}
 }

collectors/diskstatMetric.go

@@ -9,14 +9,16 @@ package collectors
 
 import (
 	"bufio"
+	"bytes"
 	"encoding/json"
+	"fmt"
 	"os"
 	"strings"
 	"syscall"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 const MOUNTFILE = `/proc/self/mounts`
@@ -28,6 +30,7 @@ type DiskstatCollectorConfig struct {
 
 type DiskstatCollector struct {
 	metricCollector
+
 	config         DiskstatCollectorConfig
 	allowedMetrics map[string]bool
 }
@@ -36,10 +39,14 @@ func (m *DiskstatCollector) Init(config json.RawMessage) error {
 	m.name = "DiskstatCollector"
 	m.parallel = true
 	m.meta = map[string]string{"source": m.name, "group": "Disk"}
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	if len(config) > 0 {
-		if err := json.Unmarshal(config, &m.config); err != nil {
+		d := json.NewDecoder(bytes.NewReader(config))
-			return err
+		d.DisallowUnknownFields()
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
 	m.allowedMetrics = map[string]bool{
@@ -54,10 +61,11 @@ func (m *DiskstatCollector) Init(config json.RawMessage) error {
 	}
 	file, err := os.Open(MOUNTFILE)
 	if err != nil {
-		cclog.ComponentError(m.name, err.Error())
+		return fmt.Errorf("%s Init(): file open for file \"%s\" failed: %w", m.name, MOUNTFILE, err)
-		return err
+	}
+	if err := file.Close(); err != nil {
+		return fmt.Errorf("%s Init(): file close for file \"%s\" failed: %w", m.name, MOUNTFILE, err)
 	}
-	defer file.Close()
 	m.init = true
 	return nil
 }
@@ -69,10 +77,18 @@ func (m *DiskstatCollector) Read(interval time.Duration, output chan lp.CCMessag
 
 	file, err := os.Open(MOUNTFILE)
 	if err != nil {
-		cclog.ComponentError(m.name, err.Error())
+		cclog.ComponentError(
+			m.name,
+			fmt.Sprintf("Read(): Failed to open file '%s': %v", MOUNTFILE, err))
 		return
 	}
-	defer file.Close()
+	defer func() {
+		if err := file.Close(); err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to close file '%s': %v", MOUNTFILE, err))
+		}
+	}()
 
 	part_max_used := uint64(0)
 	scanner := bufio.NewScanner(file)
@@ -93,7 +109,7 @@ mountLoop:
 			continue
 		}
 
-		mountPath := strings.Replace(linefields[1], `\040`, " ", -1)
+		mountPath := strings.ReplaceAll(linefields[1], `\040`, " ")
 
 		for _, excl := range m.config.ExcludeMounts {
 			if strings.Contains(mountPath, excl) {
@@ -110,18 +126,16 @@ mountLoop:
 			continue
 		}
 		tags := map[string]string{"type": "node", "device": linefields[0]}
-		total := (stat.Blocks * uint64(stat.Bsize)) / uint64(1000000000)
+		total := (stat.Blocks * uint64(stat.Bsize)) / uint64(1000_000_000)
 		if m.allowedMetrics["disk_total"] {
-			y, err := lp.NewMessage("disk_total", tags, m.meta, map[string]interface{}{"value": total}, time.Now())
+			if y, err := lp.NewMetric("disk_total", tags, m.meta, total, time.Now()); err == nil {
-			if err == nil {
 				y.AddMeta("unit", "GBytes")
 				output <- y
 			}
 		}
-		free := (stat.Bfree * uint64(stat.Bsize)) / uint64(1000000000)
+		free := (stat.Bfree * uint64(stat.Bsize)) / uint64(1000_000_000)
 		if m.allowedMetrics["disk_free"] {
-			y, err := lp.NewMessage("disk_free", tags, m.meta, map[string]interface{}{"value": free}, time.Now())
+			if y, err := lp.NewMetric("disk_free", tags, m.meta, free, time.Now()); err == nil {
-			if err == nil {
 				y.AddMeta("unit", "GBytes")
 				output <- y
 			}
@@ -133,8 +147,13 @@ mountLoop:
 			}
 		}
 	}
+	if err := scanner.Err(); err != nil {
+		cclog.ComponentErrorf(
+			m.name,
+			"Read(): Call to scanner.Err failed: %s", err.Error())
+	}
 	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.NewMetric("part_max_used", map[string]string{"type": "node"}, m.meta, int(part_max_used), time.Now())
 		if err == nil {
 			y.AddMeta("unit", "percent")
 			output <- y

collectors/gpfsMetric.md

@@ -14,13 +14,18 @@ hugo_path: docs/reference/cc-metric-collector/collectors/gpfs.md
 ```json
   "gpfs": {
     "mmpmon_path": "/path/to/mmpmon",
-    "use_sudo": "true",
+    "use_sudo": true,
     "exclude_filesystem": [
       "fs1"
     ],
-    "send_bandwidths": true,
+    "exclude_metrics": [
+      "gpfs_bytes_written"
+    ],
+    "send_abs_values": true,
+    "send_diff_values": true,
+    "send_derived_values": true,
     "send_total_values": true,
-    "send_derived_values": true
+    "send_bandwidths": true
   }
 ```
 
@@ -29,38 +34,63 @@ GPFS / IBM Spectrum Scale filesystems.
 
 The reported filesystems can be filtered with the `exclude_filesystem` option
 in the configuration.
+Individual metrics can be disabled for reporting using option `exclude_metrics`.
 
 The path to the `mmpmon` command can be configured with the `mmpmon_path` option
 in the configuration. If nothing is set, the collector searches in `$PATH` for `mmpmon`.
 
-If cc-metric-collector is run as non-root, `sudo` can be enabled with `use_sudo`. 
+If cc-metric-collector is run as non-root, password-less `sudo` can be enabled with `use_sudo`. 
 Because `mmpmon` is by default only executable as root, the Go procedure to
 search for it in `$PATH` will fail. If you use `sudo`, you must specify the
 complete path for `mmpmon` using the parameter `mmpmon_path`.
 
 
 Metrics:
-* `gpfs_bytes_read`
+* `gpfs_bytes_read` (if `send_abs_values == true`)
-* `gpfs_bytes_written`
+* `gpfs_bytes_written` (if `send_abs_values == true`)
-* `gpfs_num_opens`
+* `gpfs_num_opens` (if `send_abs_values == true`)
-* `gpfs_num_closes`
+* `gpfs_num_closes` (if `send_abs_values == true`)
-* `gpfs_num_reads`
+* `gpfs_num_reads` (if `send_abs_values == true`)
-* `gpfs_num_writes`
+* `gpfs_num_writes` (if `send_abs_values == true`)
-* `gpfs_num_readdirs`
+* `gpfs_num_readdirs` (if `send_abs_values == true`)
-* `gpfs_num_inode_updates`
+* `gpfs_num_inode_updates` (if `send_abs_values == true`)
+* `gpfs_bytes_read_diff` (if `send_diff_values == true`)
+* `gpfs_bytes_written_diff` (if `send_diff_values == true`)
+* `gpfs_num_opens_diff` (if `send_diff_values == true`)
+* `gpfs_num_closes_diff` (if `send_diff_values == true`)
+* `gpfs_num_reads_diff` (if `send_diff_values == true`)
+* `gpfs_num_writes_diff` (if `send_diff_values == true`)
+* `gpfs_num_readdirs_diff` (if `send_diff_values == true`)
+* `gpfs_num_inode_updates_diff` (if `send_diff_values == true`)
+* `gpfs_bw_read` (if `send_derived_values == true` or `send_bandwidths == true`)
+* `gpfs_bw_write` (if `send_derived_values == true` or `send_bandwidths == true`)
 * `gpfs_opens_rate` (if `send_derived_values == true`)
 * `gpfs_closes_rate` (if `send_derived_values == true`)
 * `gpfs_reads_rate` (if `send_derived_values == true`)
 * `gpfs_writes_rate` (if `send_derived_values == true`)
 * `gpfs_readdirs_rate` (if `send_derived_values == true`)
 * `gpfs_inode_updates_rate` (if `send_derived_values == true`)
-* `gpfs_bytes_total = gpfs_bytes_read + gpfs_bytes_written` (if `send_total_values == true`)
+* `gpfs_bytes_total = gpfs_bytes_read + gpfs_bytes_written` (if `send_total_values == true` and `send_abs_values == true`)
-* `gpfs_iops = gpfs_num_reads + gpfs_num_writes` (if `send_total_values == true`)
+* `gpfs_bytes_total_diff` (if `send_total_values == true` and `send_diff_values == true`)
+* `gpfs_bw_total` ((if `send_total_values == true` and `send_derived_values == true`) or `send_bandwidths == true`)
+* `gpfs_iops = gpfs_num_reads + gpfs_num_writes` (if `send_total_values == true` and `send_abs_values == true`)
+* `gpfs_iops_diff` (if `send_total_values == true` and `send_diff_values == true`)
 * `gpfs_iops_rate` (if `send_total_values == true` and `send_derived_values == true`)
-* `gpfs_metaops = gpfs_num_inode_updates + gpfs_num_closes + gpfs_num_opens + gpfs_num_readdirs` (if `send_total_values == true`)
+* `gpfs_metaops = gpfs_num_inode_updates + gpfs_num_closes + gpfs_num_opens + gpfs_num_readdirs` (if `send_total_values == true` and `send_abs_values == true`)
+* `gpfs_metaops_diff` (if `send_total_values == true` and `send_diff_values == true`)
 * `gpfs_metaops_rate` (if `send_total_values == true` and `send_derived_values == true`)
-* `gpfs_bw_read` (if `send_bandwidths == true`)
-* `gpfs_bw_write` (if `send_bandwidths == true`)
-* `gpfs_bw_total` (if `send_bandwidths == true` and `send_total_values == true`)
 
 The collector adds a `filesystem` tag to all metrics
+
+`mmpmon` typically require root to run.
+In order to run `cc-metric-collector` without root priviliges, you can enable `use_sudo`.
+Add a file like this in `/etc/sudoers.d/` to allow `cc-metric-collector` to run the required command:
+
+```
+# Do not log the following sudo commands from monitoring, since this causes a lot of log spam.
+# However keep log_denied enabled, to detect failures
+Defaults: monitoring !log_allowed, !pam_session
+
+# Allow to use mmpmon
+monitoring ALL = (root) NOPASSWD:/absolute/path/to/mmpmon -p -s
+```

collectors/infinibandMetric.go

@@ -8,35 +8,44 @@
 package collectors
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"os"
-
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
-	"golang.org/x/sys/unix"
-
-	"encoding/json"
 	"path/filepath"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
+
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
+	"golang.org/x/sys/unix"
 )
 
-const IB_BASEPATH = "/sys/class/infiniband/"
+// See: https://www.kernel.org/doc/Documentation/ABI/stable/sysfs-class-infiniband
+const (
+	ibBasePath     = "/sys/class/infiniband/"
+	ibDataUnit     = "bytes"
+	ibDataRateUnit = ibDataUnit + "/sec"
+	ibPkgUnit      = "packets"
+	ibPkgRateUnit  = ibPkgUnit + "/sec"
+)
 
 type InfinibandCollectorMetric struct {
-	name             string
+	name               string
-	path             string
+	path               string
-	unit             string
+	unit               string
-	scale            int64
+	unitRates          string
-	addToIBTotal     bool
+	scaleByFourLanes   bool
-	addToIBTotalPkgs bool
+	addToIBTotal       bool
-	currentState     int64
+	addToIBTotalPkgs   bool
-	lastState        int64
+	lastState          uint64
+	lastStateAvailable bool
 }
 
 type InfinibandCollectorInfo struct {
-	LID              string                      // IB local Identifier (LID)
+	lid              string                      // IB local Identifier (LID)
 	device           string                      // IB device
 	port             string                      // IB device port
 	portCounterFiles []InfinibandCollectorMetric // mapping counter name -> InfinibandCollectorMetric
@@ -45,6 +54,7 @@ type InfinibandCollectorInfo struct {
 
 type InfinibandCollector struct {
 	metricCollector
+
 	config struct {
 		ExcludeDevices     []string `json:"exclude_devices,omitempty"` // IB device to exclude e.g. mlx5_0
 		SendAbsoluteValues bool     `json:"send_abs_values"`           // Send absolut values as read from sys filesystem
@@ -55,9 +65,8 @@ type InfinibandCollector struct {
 	lastTimestamp time.Time // Store time stamp of last tick to derive bandwidths
 }
 
-// Init initializes the Infiniband collector by walking through files below IB_BASEPATH
+// Init initializes the Infiniband collector by walking through files below ibBasePath
 func (m *InfinibandCollector) Init(config json.RawMessage) error {
-
 	// Check if already initialized
 	if m.init {
 		return nil
@@ -65,7 +74,9 @@ func (m *InfinibandCollector) Init(config json.RawMessage) error {
 
 	var err error
 	m.name = "InfinibandCollector"
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	m.parallel = true
 	m.meta = map[string]string{
 		"source": m.name,
@@ -77,20 +88,21 @@ func (m *InfinibandCollector) Init(config json.RawMessage) error {
 	m.config.SendDerivedValues = false
 	// Read configuration file, allow overwriting default config
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): failed to decode JSON config: %w", m.name, err)
 		}
 	}
 
 	// Loop for all InfiniBand directories
-	globPattern := filepath.Join(IB_BASEPATH, "*", "ports", "*")
+	globPattern := filepath.Join(ibBasePath, "*", "ports", "*")
 	ibDirs, err := filepath.Glob(globPattern)
 	if err != nil {
-		return fmt.Errorf("unable to glob files with pattern %s: %v", globPattern, err)
+		return fmt.Errorf("%s Init(): unable to glob files with pattern %s: %w", m.name, globPattern, err)
 	}
 	if ibDirs == nil {
-		return fmt.Errorf("unable to find any directories with pattern %s", globPattern)
+		return fmt.Errorf("%s Init(): unable to find any directories with pattern %s", m.name, globPattern)
 	}
 
 	for _, path := range ibDirs {
@@ -111,14 +123,7 @@ func (m *InfinibandCollector) Init(config json.RawMessage) error {
 		port := pathSplit[6]
 
 		// Skip excluded devices
-		skip := false
+		if slices.Contains(m.config.ExcludeDevices, device) {
-		for _, excludedDevice := range m.config.ExcludeDevices {
-			if excludedDevice == device {
-				skip = true
-				break
-			}
-		}
-		if skip {
 			continue
 		}
 
@@ -126,48 +131,54 @@ func (m *InfinibandCollector) Init(config json.RawMessage) error {
 		countersDir := filepath.Join(path, "counters")
 		portCounterFiles := []InfinibandCollectorMetric{
 			{
-				name:         "ib_recv",
+				// Total number of data octets, divided by 4 (lanes), received on all VLs.
-				path:         filepath.Join(countersDir, "port_rcv_data"),
+				// This is 64 bit counter
-				unit:         "bytes",
+				name:             "ib_recv",
-				scale:        4,
+				path:             filepath.Join(countersDir, "port_rcv_data"),
-				addToIBTotal: true,
+				unit:             ibDataUnit,
-				lastState:    -1,
+				unitRates:        ibDataRateUnit,
+				scaleByFourLanes: true,
+				addToIBTotal:     true,
 			},
 			{
-				name:         "ib_xmit",
+				// Total number of data octets, divided by 4 (lanes), transmitted on all VLs.
-				path:         filepath.Join(countersDir, "port_xmit_data"),
+				// This is 64 bit counter
-				unit:         "bytes",
+				name:             "ib_xmit",
-				scale:        4,
+				path:             filepath.Join(countersDir, "port_xmit_data"),
-				addToIBTotal: true,
+				unit:             ibDataUnit,
-				lastState:    -1,
+				unitRates:        ibDataRateUnit,
+				scaleByFourLanes: true,
+				addToIBTotal:     true,
 			},
 			{
+				// Total number of packets received on all VLs from this port (this may include packets containing Errors.
+				// This is 64 bit counter.
 				name:             "ib_recv_pkts",
 				path:             filepath.Join(countersDir, "port_rcv_packets"),
-				unit:             "packets",
+				unit:             ibPkgUnit,
-				scale:            1,
+				unitRates:        ibPkgRateUnit,
 				addToIBTotalPkgs: true,
-				lastState:        -1,
 			},
 			{
+				// Total number of packets transmitted on all VLs from this port. This may include packets with errors.
+				// This is 64 bit counter.
 				name:             "ib_xmit_pkts",
 				path:             filepath.Join(countersDir, "port_xmit_packets"),
-				unit:             "packets",
+				unit:             ibPkgUnit,
-				scale:            1,
+				unitRates:        ibPkgRateUnit,
 				addToIBTotalPkgs: true,
-				lastState:        -1,
 			},
 		}
 		for _, counter := range portCounterFiles {
 			err := unix.Access(counter.path, unix.R_OK)
 			if err != nil {
-				return fmt.Errorf("unable to access %s: %v", counter.path, err)
+				return fmt.Errorf("%s Init(): unable to access %s: %w", m.name, counter.path, err)
 			}
 		}
 
 		m.info = append(m.info,
 			InfinibandCollectorInfo{
-				LID:              LID,
+				lid:              LID,
 				device:           device,
 				port:             port,
 				portCounterFiles: portCounterFiles,
@@ -181,16 +192,15 @@ func (m *InfinibandCollector) Init(config json.RawMessage) error {
 	}
 
 	if len(m.info) == 0 {
-		return fmt.Errorf("found no IB devices")
+		return fmt.Errorf("%s Init(): found no IB devices", m.name)
 	}
 
 	m.init = true
 	return nil
 }
 
-// Read reads Infiniband counter files below IB_BASEPATH
+// Read reads Infiniband counter files below ibBasePath
 func (m *InfinibandCollector) Read(interval time.Duration, output chan lp.CCMessage) {
-
 	// Check if already initialized
 	if !m.init {
 		return
@@ -206,7 +216,9 @@ func (m *InfinibandCollector) Read(interval time.Duration, output chan lp.CCMess
 	for i := range m.info {
 		info := &m.info[i]
 
-		var ib_total, ib_total_pkts int64
+		var ibTotal, ibTotalPkts uint64      // sum of xmit and recv counters
+		var ibTotalBw, ibTotalPktsBw float64 // sum of xmit and recv rates
+		var ibTotalBwAvailable, ibTotalPktsBwAvailable bool
 		for i := range info.portCounterFiles {
 			counterDef := &info.portCounterFiles[i]
 
@@ -216,35 +228,30 @@ func (m *InfinibandCollector) Read(interval time.Duration, output chan lp.CCMess
 				cclog.ComponentError(
 					m.name,
 					fmt.Sprintf("Read(): Failed to read from file '%s': %v", counterDef.path, err))
+				// Current counter can not be saved as last state
+				counterDef.lastStateAvailable = false
 				continue
 			}
 			data := strings.TrimSpace(string(line))
 
-			// convert counter to int64
+			// convert counter to uint64
-			v, err := strconv.ParseInt(data, 10, 64)
+			vRawCounter, err := strconv.ParseUint(data, 10, 64)
 			if err != nil {
 				cclog.ComponentError(
 					m.name,
-					fmt.Sprintf("Read(): Failed to convert Infininiband metrice %s='%s' to int64: %v", counterDef.name, data, err))
+					fmt.Sprintf("Read(): Failed to convert Infininiband metrice %s='%s' to uint64: %v", counterDef.name, data, err))
+				// Current counter can not be saved as last state
+				counterDef.lastStateAvailable = false
 				continue
 			}
-			// Scale raw value
+			vScaledCounter := vRawCounter
-			v *= counterDef.scale
+			if counterDef.scaleByFourLanes {
-
+				vScaledCounter *= uint64(4)
-			// Save current state
+			}
-			counterDef.currentState = v
 
 			// Send absolut values
 			if m.config.SendAbsoluteValues {
-				if y, err :=
+				if y, err := lp.NewMetric(counterDef.name, info.tagSet, m.meta, vScaledCounter, now); err == nil {
-					lp.NewMessage(
-						counterDef.name,
-						info.tagSet,
-						m.meta,
-						map[string]interface{}{
-							"value": counterDef.currentState,
-						},
-						now); err == nil {
 					y.AddMeta("unit", counterDef.unit)
 					output <- y
 				}
@@ -252,63 +259,75 @@ func (m *InfinibandCollector) Read(interval time.Duration, output chan lp.CCMess
 
 			// Send derived values
 			if m.config.SendDerivedValues {
-				if counterDef.lastState >= 0 {
+				if counterDef.lastStateAvailable {
-					rate := float64((counterDef.currentState - counterDef.lastState)) / timeDiff
+					var rate float64
-					if y, err :=
+					// uint64 subtraction handles wraparound automatically
-						lp.NewMessage(
+					// in case vRawCounter < counterDef.lastState we would compute:
-							counterDef.name+"_bw",
+					// math.MaxUint64 - lastState + vRawCounter + 1
-							info.tagSet,
+					// = (2^64 - 1) - lastState + vRawCounter + 1
-							m.meta,
+					// = 2^64 - lastState + vRawCounter
-							map[string]interface{}{
+					// ≡ vRawCounter - lastState (mod 2^64)
-								"value": rate,
+					rate = float64(vRawCounter-counterDef.lastState) / timeDiff
-							},
+					if counterDef.scaleByFourLanes {
-							now); err == nil {
+						rate *= float64(4)
-						y.AddMeta("unit", counterDef.unit+"/sec")
+					}
+					if y, err := lp.NewMetric(counterDef.name+"_bw", info.tagSet, m.meta, rate, now); err == nil {
+						y.AddMeta("unit", counterDef.unitRates)
 						output <- y
+					}
 
+					// Sum up rates for total rates
+					if m.config.SendTotalValues {
+						switch {
+						case counterDef.addToIBTotal:
+							ibTotalBw += rate
+							ibTotalBwAvailable = true
+						case counterDef.addToIBTotalPkgs:
+							ibTotalPktsBw += rate
+							ibTotalPktsBwAvailable = true
+						}
 					}
 				}
-				counterDef.lastState = counterDef.currentState
+				counterDef.lastState = vRawCounter
+				counterDef.lastStateAvailable = true
 			}
 
 			// Sum up total values
 			if m.config.SendTotalValues {
 				switch {
 				case counterDef.addToIBTotal:
-					ib_total += counterDef.currentState
+					ibTotal += vScaledCounter
 				case counterDef.addToIBTotalPkgs:
-					ib_total_pkts += counterDef.currentState
+					ibTotalPkts += vScaledCounter
 				}
 			}
 		}
 
 		// Send total values
 		if m.config.SendTotalValues {
-			if y, err :=
+			if y, err := lp.NewMetric("ib_total", info.tagSet, m.meta, ibTotal, now); err == nil {
-				lp.NewMessage(
+				y.AddMeta("unit", ibDataUnit)
-					"ib_total",
-					info.tagSet,
-					m.meta,
-					map[string]interface{}{
-						"value": ib_total,
-					},
-					now); err == nil {
-				y.AddMeta("unit", "bytes")
 				output <- y
 			}
 
-			if y, err :=
+			if y, err := lp.NewMetric("ib_total_pkts", info.tagSet, m.meta, ibTotalPkts, now); err == nil {
-				lp.NewMessage(
+				y.AddMeta("unit", ibPkgUnit)
-					"ib_total_pkts",
-					info.tagSet,
-					m.meta,
-					map[string]interface{}{
-						"value": ib_total_pkts,
-					},
-					now); err == nil {
-				y.AddMeta("unit", "packets")
 				output <- y
 			}
+
+			if m.config.SendDerivedValues && ibTotalBwAvailable {
+				if y, err := lp.NewMetric("ib_total_bw", info.tagSet, m.meta, ibTotalBw, now); err == nil {
+					y.AddMeta("unit", ibDataRateUnit)
+					output <- y
+				}
+			}
+
+			if m.config.SendDerivedValues && ibTotalPktsBwAvailable {
+				if y, err := lp.NewMetric("ib_total_pkts_bw", info.tagSet, m.meta, ibTotalPktsBw, now); err == nil {
+					y.AddMeta("unit", ibPkgRateUnit)
+					output <- y
+				}
+			}
 		}
 	}
 }

collectors/infinibandMetric.md

@@ -41,5 +41,7 @@ Metrics:
 * `ib_xmit_bw` (if `send_derived_values == true`)
 * `ib_recv_pkts_bw` (if `send_derived_values == true`)
 * `ib_xmit_pkts_bw` (if `send_derived_values == true`)
+* `ib_total_bw` (if `send_total_values == true` and `send_derived_values == true`)
+* `ib_total_pkts_bw` (if `send_total_values == true` and `send_derived_values == true`)
 
 The collector adds a `device` tag to all metrics

collectors/iostatMetric.go

@@ -9,48 +9,52 @@ package collectors
 
 import (
 	"bufio"
+	"bytes"
 	"encoding/json"
-	"errors"
+	"fmt"
 	"os"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
-// Konstante für den Pfad zu /proc/diskstats
 const IOSTATFILE = `/proc/diskstats`
 
 type IOstatCollectorConfig struct {
 	ExcludeMetrics []string `json:"exclude_metrics,omitempty"`
-	// Neues Feld zum Ausschließen von Devices per JSON-Konfiguration
 	ExcludeDevices []string `json:"exclude_devices,omitempty"`
 }
 
 type IOstatCollectorEntry struct {
-	lastValues map[string]int64
+	currentValues map[string]int64
-	tags       map[string]string
+	lastValues    map[string]int64
+	tags          map[string]string
 }
 
 type IOstatCollector struct {
 	metricCollector
+
 	matches map[string]int
 	config  IOstatCollectorConfig
 	devices map[string]IOstatCollectorEntry
 }
 
 func (m *IOstatCollector) Init(config json.RawMessage) error {
-	var err error
 	m.name = "IOstatCollector"
 	m.parallel = true
 	m.meta = map[string]string{"source": m.name, "group": "Disk"}
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %s", m.name, err.Error())
+	}
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %s", m.name, err.Error())
 		}
 	}
 	// https://www.kernel.org/doc/html/latest/admin-guide/iostats.html
@@ -76,19 +80,17 @@ func (m *IOstatCollector) Init(config json.RawMessage) error {
 	m.devices = make(map[string]IOstatCollectorEntry)
 	m.matches = make(map[string]int)
 	for k, v := range matches {
-		if _, skip := stringArrayContains(m.config.ExcludeMetrics, k); !skip {
+		if !slices.Contains(m.config.ExcludeMetrics, k) {
 			m.matches[k] = v
 		}
 	}
 	if len(m.matches) == 0 {
-		return errors.New("no metrics to collect")
+		return fmt.Errorf("%s Init(): no metrics to collect", m.name)
 	}
 	file, err := os.Open(IOSTATFILE)
 	if err != nil {
-		cclog.ComponentError(m.name, err.Error())
+		return fmt.Errorf("%s Init(): Failed to open file \"%s\": %s", m.name, IOSTATFILE, err.Error())
-		return err
 	}
-	defer file.Close()
 
 	scanner := bufio.NewScanner(file)
 	for scanner.Scan() {
@@ -102,23 +104,41 @@ func (m *IOstatCollector) Init(config json.RawMessage) error {
 		if strings.Contains(device, "loop") {
 			continue
 		}
-		if _, skip := stringArrayContains(m.config.ExcludeDevices, device); skip {
+		if slices.Contains(m.config.ExcludeDevices, device) {
 			continue
 		}
-		values := make(map[string]int64)
+		currentValues := make(map[string]int64)
+		lastValues := make(map[string]int64)
 		for m := range m.matches {
-			values[m] = 0
+			currentValues[m] = 0
+			lastValues[m] = 0
+		}
+		for name, idx := range m.matches {
+			if idx < len(linefields) {
+				if value, err := strconv.ParseInt(linefields[idx], 0, 64); err == nil {
+					currentValues[name] = value
+					lastValues[name] = value // Set last to current for first read
+				}
+			}
 		}
 		m.devices[device] = IOstatCollectorEntry{
 			tags: map[string]string{
 				"device": device,
 				"type":   "node",
 			},
-			lastValues: values,
+			currentValues: currentValues,
+			lastValues:    lastValues,
 		}
 	}
+	if err := scanner.Err(); err != nil {
+		return fmt.Errorf("%s Init(): Failed to scan content of file %q: %s", m.name, IOSTATFILE, err.Error())
+	}
+	if err := file.Close(); err != nil {
+		return fmt.Errorf("%s Init(): Failed to close file \"%s\": %s", m.name, IOSTATFILE, err.Error())
+	}
+
 	m.init = true
-	return err
+	return nil
 }
 
 func (m *IOstatCollector) Read(interval time.Duration, output chan lp.CCMessage) {
@@ -128,10 +148,18 @@ func (m *IOstatCollector) Read(interval time.Duration, output chan lp.CCMessage)
 
 	file, err := os.Open(IOSTATFILE)
 	if err != nil {
-		cclog.ComponentError(m.name, err.Error())
+		cclog.ComponentError(
+			m.name,
+			fmt.Sprintf("Read(): Failed to open file '%s': %s", IOSTATFILE, err.Error()))
 		return
 	}
-	defer file.Close()
+	defer func() {
+		if err := file.Close(); err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to close file '%s': %s", IOSTATFILE, err.Error()))
+		}
+	}()
 
 	scanner := bufio.NewScanner(file)
 	for scanner.Scan() {
@@ -147,28 +175,37 @@ func (m *IOstatCollector) Read(interval time.Duration, output chan lp.CCMessage)
 		if strings.Contains(device, "loop") {
 			continue
 		}
-		if _, skip := stringArrayContains(m.config.ExcludeDevices, device); skip {
+		if slices.Contains(m.config.ExcludeDevices, device) {
 			continue
 		}
 		if _, ok := m.devices[device]; !ok {
 			continue
 		}
+		// Update current and last values
 		entry := m.devices[device]
 		for name, idx := range m.matches {
 			if idx < len(linefields) {
 				x, err := strconv.ParseInt(linefields[idx], 0, 64)
 				if err == nil {
-					diff := x - entry.lastValues[name]
+					// Calculate difference using previous current and new value
-					y, err := lp.NewMessage(name, entry.tags, m.meta, map[string]interface{}{"value": int(diff)}, time.Now())
+					diff := x - entry.currentValues[name]
+					y, err := lp.NewMetric(name, entry.tags, m.meta, int(diff), time.Now())
 					if err == nil {
 						output <- y
 					}
+					// Update last to previous current, and current to new value
+					entry.lastValues[name] = entry.currentValues[name]
+					entry.currentValues[name] = x
 				}
-				entry.lastValues[name] = x
 			}
 		}
 		m.devices[device] = entry
 	}
+	if err := scanner.Err(); err != nil {
+		cclog.ComponentErrorf(
+			m.name,
+			"Read(): Failed to scan content of file %q: %s", IOSTATFILE, err.Error())
+	}
 }
 
 func (m *IOstatCollector) Close() {

collectors/ipmiMetric.go

@@ -11,30 +11,32 @@ import (
 	"bufio"
 	"bytes"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
-	"log"
 	"os/exec"
 	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 const IPMISENSORS_PATH = `ipmi-sensors`
 
 type IpmiCollector struct {
 	metricCollector
+
 	config struct {
-		ExcludeDevices  []string `json:"exclude_devices"`
 		IpmitoolPath    string   `json:"ipmitool_path"`
 		IpmisensorsPath string   `json:"ipmisensors_path"`
+		Sudo            bool     `json:"use_sudo"`
+		IncludeMetrics  []string `json:"include_metrics"`
 	}
-	ipmitool    string
+
-	ipmisensors string
+	ipmitool       string
+	ipmisensors    string
+	includeMetrics map[string]bool
 }
 
 func (m *IpmiCollector) Init(config json.RawMessage) error {
@@ -44,7 +46,9 @@ func (m *IpmiCollector) Init(config json.RawMessage) error {
 	}
 
 	m.name = "IpmiCollector"
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	m.parallel = true
 	m.meta = map[string]string{
 		"source": m.name,
@@ -53,58 +57,84 @@ func (m *IpmiCollector) Init(config json.RawMessage) error {
 	// default path to IPMI tools
 	m.config.IpmitoolPath = "ipmitool"
 	m.config.IpmisensorsPath = "ipmi-sensors"
+
 	if len(config) > 0 {
-		err := json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
-	// Check if executables ipmitool or ipmisensors are found
-	p, err := exec.LookPath(m.config.IpmitoolPath)
-	if err == nil {
-		command := exec.Command(p)
-		err := command.Run()
-		if err != nil {
-			cclog.ComponentError(m.name, fmt.Sprintf("Failed to execute %s: %v", p, err.Error()))
-			m.ipmitool = ""
-		} else {
-			m.ipmitool = p
-		}
-	}
-	p, err = exec.LookPath(m.config.IpmisensorsPath)
-	if err == nil {
-		command := exec.Command(p)
-		err := command.Run()
-		if err != nil {
-			cclog.ComponentError(m.name, fmt.Sprintf("Failed to execute %s: %v", p, err.Error()))
-			m.ipmisensors = ""
-		} else {
-			m.ipmisensors = p
-		}
-	}
-	if len(m.ipmitool) == 0 && len(m.ipmisensors) == 0 {
-		return errors.New("no usable IPMI reader found")
-	}
 
-	m.init = true
+	// Read metrics to include
-	return nil
+	m.includeMetrics = make(map[string]bool)
+	for _, metric := range m.config.IncludeMetrics {
+		metric = strings.ToLower(strings.TrimSpace(metric))
+		if metric != "" {
+			m.includeMetrics[metric] = true
+		}
+	}
+
+	m.ipmitool = m.config.IpmitoolPath
+	m.ipmisensors = m.config.IpmisensorsPath
+
+	// Test if any of the supported backends work
+	var dummyChan chan lp.CCMessage
+	dummyConsumer := func() {
+		for range dummyChan {
+		}
+	}
+
+	// Test if ipmi-sensors works (preferred over ipmitool, because it's faster)
+	var ipmiSensorsErr error
+	if _, ipmiSensorsErr = exec.LookPath(m.ipmisensors); ipmiSensorsErr == nil {
+		dummyChan = make(chan lp.CCMessage)
+		go dummyConsumer()
+		ipmiSensorsErr = m.readIpmiSensors(dummyChan)
+		close(dummyChan)
+		if ipmiSensorsErr == nil {
+			cclog.ComponentDebugf(m.name, "Using ipmi-sensors for ipmistat collector")
+			m.init = true
+			return nil
+		}
+	}
+	cclog.ComponentDebugf(m.name, "Unable to use ipmi-sensors for ipmistat collector: %v", ipmiSensorsErr)
+	m.ipmisensors = ""
+
+	// Test if ipmitool works (may be very slow)
+	var ipmiToolErr error
+	if _, ipmiToolErr = exec.LookPath(m.ipmitool); ipmiToolErr == nil {
+		dummyChan = make(chan lp.CCMessage)
+		go dummyConsumer()
+		ipmiToolErr = m.readIpmiTool(dummyChan)
+		close(dummyChan)
+		if ipmiToolErr == nil {
+			cclog.ComponentDebugf(m.name, "Using ipmitool for ipmistat collector")
+			m.init = true
+			return nil
+		}
+	}
+	m.ipmitool = ""
+	cclog.ComponentDebugf(m.name, "Unable to use ipmitool for ipmistat collector: %v", ipmiToolErr)
+
+	return fmt.Errorf("unable to init neither ipmitool (%w) nor ipmi-sensors (%w)", ipmiToolErr, ipmiSensorsErr)
 }
 
-func (m *IpmiCollector) readIpmiTool(cmd string, output chan lp.CCMessage) {
+func (m *IpmiCollector) readIpmiTool(output chan lp.CCMessage) error {
-
 	// Setup ipmitool command
-	command := exec.Command(cmd, "sensor")
+	argv := make([]string, 0)
+	if m.config.Sudo {
+		argv = append(argv, "sudo", "-n")
+	}
+	argv = append(argv, m.ipmitool, "sensor")
+	command := exec.Command(argv[0], argv[1:]...)
 	stdout, _ := command.StdoutPipe()
 	errBuf := new(bytes.Buffer)
 	command.Stderr = errBuf
 
 	// start command
 	if err := command.Start(); err != nil {
-		cclog.ComponentError(
+		return fmt.Errorf("failed to start command '%s': %w", command.String(), err)
-			m.name,
-			fmt.Sprintf("readIpmiTool(): Failed to start command \"%s\": %v", command.String(), err),
-		)
-		return
 	}
 
 	// Read command output
@@ -114,81 +144,131 @@ func (m *IpmiCollector) readIpmiTool(cmd string, output chan lp.CCMessage) {
 		if len(lv) < 3 {
 			continue
 		}
-		v, err := strconv.ParseFloat(strings.TrimSpace(lv[1]), 64)
-		if err == nil {
-			name := strings.ToLower(strings.Replace(strings.TrimSpace(lv[0]), " ", "_", -1))
-			unit := strings.TrimSpace(lv[2])
-			if unit == "Volts" {
-				unit = "Volts"
-			} else if unit == "degrees C" {
-				unit = "degC"
-			} else if unit == "degrees F" {
-				unit = "degF"
-			} else if unit == "Watts" {
-				unit = "Watts"
-			}
 
-			y, err := lp.NewMessage(name, map[string]string{"type": "node"}, m.meta, map[string]interface{}{"value": v}, time.Now())
+		if strings.TrimSpace(lv[1]) == "0x0" || strings.TrimSpace(lv[1]) == "na" {
-			if err == nil {
+			// Ignore known non-float values
-				y.AddMeta("unit", unit)
+			continue
-				output <- y
-			}
 		}
+
+		v, err := strconv.ParseFloat(strings.TrimSpace(lv[1]), 64)
+		if err != nil {
+			cclog.ComponentErrorf(m.name, "Failed to parse float '%s': %v", lv[1], err)
+			continue
+		}
+		name := strings.ToLower(strings.ReplaceAll(strings.TrimSpace(lv[0]), " ", "_"))
+
+		if len(m.includeMetrics) > 0 && !m.includeMetrics[name] {
+			continue
+		}
+
+		unit := strings.TrimSpace(lv[2])
+		switch unit {
+		case "Volts":
+			unit = "Volts"
+		case "degrees C":
+			unit = "degC"
+		case "degrees F":
+			unit = "degF"
+		case "Watts":
+			unit = "Watts"
+		}
+
+		y, err := lp.NewMetric(name, map[string]string{"type": "node"}, m.meta, v, time.Now())
+		if err != nil {
+			cclog.ComponentErrorf(m.name, "Failed to create message: %v", err)
+			continue
+		}
+		y.AddMeta("unit", unit)
+		output <- y
+	}
+	if err := scanner.Err(); err != nil {
+		return fmt.Errorf("failed to scan output of command: %s", err.Error())
 	}
 
 	// Wait for command end
 	if err := command.Wait(); err != nil {
 		errMsg, _ := io.ReadAll(errBuf)
-		cclog.ComponentError(
+		return fmt.Errorf("failed to complete command '%s': %w (stderr: %s)", command.String(), err, strings.TrimSpace(string(errMsg)))
-			m.name,
-			fmt.Sprintf("readIpmiTool(): Failed to wait for the end of command \"%s\": %v\n", command.String(), err),
-		)
-		cclog.ComponentError(m.name, fmt.Sprintf("readIpmiTool(): command stderr: \"%s\"\n", strings.TrimSpace(string(errMsg))))
-		return
 	}
+
+	return nil
 }
 
-func (m *IpmiCollector) readIpmiSensors(cmd string, output chan lp.CCMessage) {
+func (m *IpmiCollector) readIpmiSensors(output chan lp.CCMessage) error {
+	// Setup ipmisensors command
+	argv := make([]string, 0)
+	if m.config.Sudo {
+		argv = append(argv, "sudo", "-n")
+	}
+	argv = append(argv, m.ipmisensors, "--comma-separated-output", "--sdr-cache-recreate")
+	command := exec.Command(argv[0], argv[1:]...)
+	stdout, _ := command.StdoutPipe()
+	errBuf := new(bytes.Buffer)
+	command.Stderr = errBuf
 
-	command := exec.Command(cmd, "--comma-separated-output", "--sdr-cache-recreate")
+	// start command
-	command.Wait()
+	if err := command.Start(); err != nil {
-	stdout, err := command.Output()
+		return fmt.Errorf("failed to start command '%s': %w", command.String(), err)
-	if err != nil {
-		log.Print(err)
-		return
 	}
 
-	ll := strings.Split(string(stdout), "\n")
+	// Read command output
-
+	scanner := bufio.NewScanner(stdout)
-	for _, line := range ll {
+	for scanner.Scan() {
-		lv := strings.Split(line, ",")
+		lv := strings.Split(scanner.Text(), ",")
-		if len(lv) > 3 {
+		if len(lv) <= 3 {
-			v, err := strconv.ParseFloat(lv[3], 64)
+			continue
-			if err == nil {
-				name := strings.ToLower(strings.Replace(lv[1], " ", "_", -1))
-				y, err := lp.NewMessage(name, map[string]string{"type": "node"}, m.meta, map[string]interface{}{"value": v}, time.Now())
-				if err == nil {
-					if len(lv) > 4 {
-						y.AddMeta("unit", lv[4])
-					}
-					output <- y
-				}
-			}
 		}
+		if lv[3] == "N/A" || lv[3] == "Reading" {
+			// Ignore known non-float values
+			continue
+		}
+		v, err := strconv.ParseFloat(strings.TrimSpace(lv[3]), 64)
+		if err != nil {
+			cclog.ComponentErrorf(m.name, "Failed to parse float '%s': %v", lv[3], err)
+			continue
+		}
+		name := strings.ToLower(strings.ReplaceAll(lv[1], " ", "_"))
+
+		if len(m.includeMetrics) > 0 && !m.includeMetrics[name] {
+			continue
+		}
+
+		y, err := lp.NewMetric(name, map[string]string{"type": "node"}, m.meta, v, time.Now())
+		if err != nil {
+			cclog.ComponentErrorf(m.name, "Failed to create message: %v", err)
+			continue
+		}
+		if len(lv) > 4 {
+			y.AddMeta("unit", lv[4])
+		}
+		output <- y
 	}
+
+	// Wait for command end
+	if err := command.Wait(); err != nil {
+		errMsg, _ := io.ReadAll(errBuf)
+		return fmt.Errorf("failed to complete command '%s': %w (stderr: %s)", command.String(), err, strings.TrimSpace(string(errMsg)))
+	}
+
+	return nil
 }
 
 func (m *IpmiCollector) Read(interval time.Duration, output chan lp.CCMessage) {
-
 	// Check if already initialized
 	if !m.init {
 		return
 	}
 
-	if len(m.config.IpmitoolPath) > 0 {
+	if len(m.ipmisensors) > 0 {
-		m.readIpmiTool(m.config.IpmitoolPath, output)
+		err := m.readIpmiSensors(output)
-	} else if len(m.config.IpmisensorsPath) > 0 {
+		if err != nil {
-		m.readIpmiSensors(m.config.IpmisensorsPath, output)
+			cclog.ComponentErrorf(m.name, "readIpmiSensors() failed: %v", err)
+		}
+	} else if len(m.ipmitool) > 0 {
+		err := m.readIpmiTool(output)
+		if err != nil {
+			cclog.ComponentErrorf(m.name, "readIpmiTool() failed: %v", err)
+		}
 	}
 }
 

collectors/ipmiMetric.md

@@ -15,9 +15,27 @@ hugo_path: docs/reference/cc-metric-collector/collectors/ipmi.md
   "ipmistat": {
     "ipmitool_path": "/path/to/ipmitool",
     "ipmisensors_path": "/path/to/ipmi-sensors",
+    "use_sudo": true,
+    "include_metrics" : []
   }
 ```
 
 The `ipmistat` collector reads data from `ipmitool` (`ipmitool sensor`) or `ipmi-sensors` (`ipmi-sensors --sdr-cache-recreate --comma-separated-output`).
 
 The metrics depend on the output of the underlying tools but contain temperature, power and energy metrics.
+
+`ipmitool` and `ipmi-sensors` typically require root to run.
+In order to run `cc-metric-collector` without root priviliges, you can enable `use_sudo`.
+Add a file like this in `/etc/sudoers.d/` to allow `cc-metric-collector` to run the required commands:
+
+```
+# Do not log the following sudo commands from monitoring, since this causes a lot of log spam.
+# However keep log_denied enabled, to detect failures
+Defaults: monitoring !log_allowed, !pam_session
+
+# Allow to use ipmitool and ipmi-sensors
+monitoring ALL = (root) NOPASSWD:/usr/bin/ipmitool sensor
+monitoring ALL = (root) NOPASSWD:/usr/sbin/ipmi-sensors --comma-separated-output --sdr-cache-recreate
+```
+
+If `include_ipmi_metrics` contains any entry, ipmistat collector will only submit these metrics. Any other values will get discarded. 

collectors/lenovoDensePower.go

@@ -0,0 +1,170 @@
+// Copyright (C) NHR@FAU, University Erlangen-Nuremberg.
+// All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+// additional authors:
+// Michael Panzlaff (NHR@FAU)
+
+package collectors
+
+import (
+	"bytes"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+	"time"
+
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
+)
+
+type LenovoDensePowerCollector struct {
+	metricCollector
+
+	config struct {
+		IpmitoolPath string `json:"ipmitool_path"`
+		Sudo         bool   `json:"use_sudo"`
+	}
+
+	ipmitool string
+
+	energyValLast  float64
+	energyTimeLast time.Time
+}
+
+func (m *LenovoDensePowerCollector) Init(config json.RawMessage) error {
+	// Check if already initialized
+	if m.init {
+		return nil
+	}
+
+	m.name = "LenovoDensePowerCollector"
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
+	m.meta = map[string]string{
+		"source": m.name,
+		"group":  "IPMI",
+	}
+
+	m.config.IpmitoolPath = "ipmitool"
+
+	if len(config) > 0 {
+		d := json.NewDecoder(bytes.NewReader(config))
+		d.DisallowUnknownFields()
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
+		}
+	}
+
+	m.ipmitool = m.config.IpmitoolPath
+
+	energyVal, energyTime, err := m.readEnergy()
+	if err != nil {
+		return fmt.Errorf("energy reading test failed: %w", err)
+	}
+
+	m.energyValLast = energyVal
+	m.energyTimeLast = energyTime
+	m.init = true
+
+	return nil
+}
+
+func (m *LenovoDensePowerCollector) readEnergy() (float64, time.Time, error) {
+	argv := make([]string, 0)
+	if m.config.Sudo {
+		argv = append(argv, "sudo", "-n")
+	}
+
+	// The Lenovo hardware wants this magic byte string
+	lenovoRequestEnergyMsg := []uint8{0x3a, 0x32, 4, 2, 0, 0, 0}
+
+	argv = append(argv, m.ipmitool, "raw")
+
+	for _, val := range lenovoRequestEnergyMsg {
+		argv = append(argv, strconv.Itoa(int(val)))
+	}
+
+	cmd := exec.Command(argv[0], argv[1:]...)
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	err := cmd.Run()
+	if err != nil {
+		return 0, time.Unix(0, 0), fmt.Errorf("failed to run ipmitool: %w (stdout=%s stderr=%s)", err, stdout.String(), stderr.String())
+	}
+
+	data, err := hex.DecodeString(strings.ReplaceAll(strings.TrimSpace(stdout.String()), " ", ""))
+	if err != nil {
+		return 0, time.Unix(0, 0), fmt.Errorf("unable to decode ipmitool hex output: %w (stdout=%s)", err, stdout.String())
+	}
+
+	if len(data) != 14 {
+		return 0, time.Unix(0, 0), fmt.Errorf("result must be 14 bytes as specified in the documentation")
+	}
+
+	// data is laid out like this:
+	// data[0 to 1]: FIFO index of value (for debug only)
+	// data[2 to 5]: Integer part of energy in J (little endian)
+	// data[6 to 7]: Fraction part of energy in mJ (little endian)
+	// data[8 to 11]: Integer part of Unix time of measurement in seconds (little endian)
+	// data[12 to 13]: Fraction part of Unix time of measurement in milliseconds (little endian)
+	wholeJoules := (uint32(data[2]) << 0) | (uint32(data[3]) << 8) | (uint32(data[4]) << 16) | (uint32(data[5]) << 24)
+	milliJoules := uint16(data[6]) | (uint16(data[7]) << 8)
+	finalJoules := float64(wholeJoules) + float64(milliJoules)*1e-3
+
+	wholeSeconds := (uint32(data[8]) << 0) | (uint32(data[9]) << 8) | (uint32(data[10]) << 16) | (uint32(data[11]) << 24)
+	milliSeconds := uint16(data[12]) | (uint16(data[13]) << 8)
+	finalTime := time.Unix(int64(wholeSeconds), (int64(milliSeconds) * 1000000))
+
+	return finalJoules, finalTime, nil
+}
+
+func (m *LenovoDensePowerCollector) Read(interval time.Duration, output chan lp.CCMessage) {
+	// Check if already initialized
+	if !m.init {
+		return
+	}
+
+	energyVal, energyTime, err := m.readEnergy()
+	if err != nil {
+		cclog.ComponentErrorf(m.name, "readEnergy failed: %v", err)
+		return
+	}
+
+	powerVal := 0.0
+	if energyTime.Compare(m.energyTimeLast) != 0 {
+		// Check for overflow
+		energyValDiff := int64(energyVal) - int64(m.energyValLast)
+		if energyVal < m.energyValLast {
+			energyValDiff += int64(0x100000000)
+		}
+		energyTimeDiff := energyTime.Sub(m.energyTimeLast)
+		if energyTime.Before(m.energyTimeLast) {
+			energyTimeDiff = energyTimeDiff + 0x100000000*time.Second
+		}
+		powerVal = float64(energyValDiff) / energyTimeDiff.Seconds()
+
+		m.energyValLast = energyVal
+		m.energyTimeLast = energyTime
+	}
+
+	metric, err := lp.NewMetric("lenovo_node_power", map[string]string{"type": "node"}, m.meta, powerVal, energyTime)
+	if err != nil {
+		cclog.ComponentErrorf(m.name, "lp.NewMetric failed: %v", err)
+		return
+	}
+	metric.AddMeta("unit", "Watts")
+	output <- metric
+}
+
+func (m *LenovoDensePowerCollector) Close() {
+	m.init = false
+}

collectors/lenovoDensePower.md

@@ -0,0 +1,51 @@
+<!--
+---
+title: Lenovo Dense Power collector
+description: Collect power of Lenovo Dense machines using ipmitool raw
+categories: [cc-metric-collector]
+tags: ['Admin']
+weight: 2
+hugo_path: docs/reference/cc-metric-collector/collectors/lenovoDensePower.md
+---
+-->
+
+## `lenovo_dense_power` collector
+
+```json
+  "lenovo_dense_power": {
+    "ipmitool_path": "/path/to/ipmitool",
+    "use_sudo": true,
+    "include_metrics" : []
+  }
+```
+
+The `lenovo_dense_power` collector reads power from Lenovo Dense machines via `ipmitool` (`ipmitool raw ...`). This collector is known to only work on the following machines. Others are not supported, so use at your *OWN* risk:
+
+System                                    | Compatibility             | Power measured
+---                                       | ---                       | ---
+Lenovo ThinkSystem SD650 V2/V3            | untested, but should work | node + riser1 + riser2
+Lenovo ThinkSystem SD650-N V2/ SD650-I V3 | untested, but should work | node + riser1 + riser2 + gpus
+Lenovo ThinkSystem SD665-N V3             | tested, known to work     | node + riser1 + riser2 + gpus
+
+To test if your system *may* be supported, you can run the following command *at your own risk*:
+
+```
+$ ipmitool raw 58 50 4 2 0 0 0
+ c4 00 83 a9 cb d3 a2 03 df db 47 6a d8 01
+```
+
+Exactly 14 bytes should be returned.
+In case not or another error occurs your hardware is likely not supported.
+
+In addition, `ipmitool` typically require root to run.
+In order to run `cc-metric-collector` without root priviliges, you can enable `use_sudo`.
+Add a file like this in `/etc/sudoers.d/` to allow `cc-metric-collector` to run the required commands:
+
+```
+# Do not log the following sudo commands from monitoring, since this causes a lot of log spam.
+# However keep log_denied enabled, to detect failures
+Defaults: monitoring !log_allowed, !pam_session
+
+# Allow to use ipmitool for Lenovo power readings
+monitoring ALL = (root) NOPASSWD:/usr/bin/ipmitool raw 58 50 4 2 0 0 0
+```

collectors/likwidMetric.go

@@ -16,14 +16,15 @@ package collectors
 import "C"
 
 import (
+	"bytes"
 	"encoding/json"
-	"errors"
 	"fmt"
+	"maps"
 	"math"
 	"os"
 	"os/signal"
 	"os/user"
-	"sort"
+	"slices"
 	"strconv"
 	"strings"
 	"sync"
@@ -31,13 +32,13 @@ import (
 	"time"
 	"unsafe"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 	agg "github.com/ClusterCockpit/cc-metric-collector/internal/metricAggregator"
 	topo "github.com/ClusterCockpit/cc-metric-collector/pkg/ccTopology"
 	"github.com/NVIDIA/go-nvml/pkg/dl"
 	"github.com/fsnotify/fsnotify"
-	"golang.design/x/thread"
+	"golang.design/x/runtime/thread"
 )
 
 const (
@@ -124,22 +125,14 @@ func checkMetricType(t string) bool {
 	return ok
 }
 
-func eventsToEventStr(events map[string]string) string {
-	elist := make([]string, 0)
-	for k, v := range events {
-		elist = append(elist, fmt.Sprintf("%s:%s", v, k))
-	}
-	return strings.Join(elist, ",")
-}
-
 func genLikwidEventSet(input LikwidCollectorEventsetConfig) LikwidEventsetConfig {
-	tmplist := make([]string, 0)
+	clist := make([]string, 0, len(input.Events))
-	clist := make([]string, 0)
 	for k := range input.Events {
 		clist = append(clist, k)
 	}
-	sort.Strings(clist)
+	slices.Sort(clist)
-	elist := make([]*C.char, 0)
+	tmplist := make([]string, 0, len(clist))
+	elist := make([]*C.char, 0, len(clist))
 	for _, k := range clist {
 		v := input.Events[k]
 		tmplist = append(tmplist, fmt.Sprintf("%s:%s", v, k))
@@ -149,7 +142,7 @@ func genLikwidEventSet(input LikwidCollectorEventsetConfig) LikwidEventsetConfig
 	estr := strings.Join(tmplist, ",")
 	res := make(map[int]map[string]float64)
 	met := make(map[int]map[string]float64)
-	for _, i := range topo.CpuList() {
+	for _, i := range topo.HwthreadList() {
 		res[i] = make(map[string]float64)
 		for k := range input.Events {
 			res[i][k] = 0.0
@@ -187,7 +180,7 @@ func getBaseFreq() float64 {
 	for _, f := range files {
 		buffer, err := os.ReadFile(f)
 		if err == nil {
-			data := strings.Replace(string(buffer), "\n", "", -1)
+			data := strings.ReplaceAll(string(buffer), "\n", "")
 			x, err := strconv.ParseInt(data, 0, 64)
 			if err == nil {
 				freq = float64(x)
@@ -214,25 +207,30 @@ func (m *LikwidCollector) Init(config json.RawMessage) error {
 	m.config.LibraryPath = LIKWID_LIB_NAME
 	m.config.LockfilePath = LIKWID_DEF_LOCKFILE
 	if len(config) > 0 {
-		err := json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
 	lib := dl.New(m.config.LibraryPath, LIKWID_LIB_DL_FLAGS)
 	if lib == nil {
-		return fmt.Errorf("error instantiating DynamicLibrary for %s", m.config.LibraryPath)
+		return fmt.Errorf("%s Init(): error instantiating DynamicLibrary for %s", m.name, m.config.LibraryPath)
 	}
 	err := lib.Open()
 	if err != nil {
-		return fmt.Errorf("error opening %s: %v", m.config.LibraryPath, err)
+		return fmt.Errorf("%s Init(): error opening %s: %w", m.name, m.config.LibraryPath, err)
 	}
 
 	if m.config.ForceOverwrite {
 		cclog.ComponentDebug(m.name, "Set LIKWID_FORCE=1")
-		os.Setenv("LIKWID_FORCE", "1")
+		if err := os.Setenv("LIKWID_FORCE", "1"); err != nil {
+			return fmt.Errorf("%s Init(): error setting environment variable LIKWID_FORCE=1: %w", m.name, err)
+		}
+	}
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
 	}
-	m.setup()
 
 	m.meta = map[string]string{"group": "PerfCounter"}
 	cclog.ComponentDebug(m.name, "Get cpulist and init maps and lists")
@@ -298,16 +296,12 @@ func (m *LikwidCollector) Init(config json.RawMessage) error {
 
 	// If no event set could be added, shut down LikwidCollector
 	if totalMetrics == 0 {
-		err := errors.New("no LIKWID eventset or metric usable")
+		return fmt.Errorf("%s Init(): no LIKWID eventset or metric usable", m.name)
-		cclog.ComponentError(m.name, err.Error())
-		return err
 	}
 
 	ret := C.topology_init()
 	if ret != 0 {
-		err := errors.New("failed to initialize topology module")
+		return fmt.Errorf("%s Init(): failed to initialize topology module", m.name)
-		cclog.ComponentError(m.name, err.Error())
-		return err
 	}
 	m.measureThread = thread.New()
 	switch m.config.AccessMode {
@@ -316,7 +310,14 @@ func (m *LikwidCollector) Init(config json.RawMessage) error {
 	case "accessdaemon":
 		if len(m.config.DaemonPath) > 0 {
 			p := os.Getenv("PATH")
-			os.Setenv("PATH", m.config.DaemonPath+":"+p)
+			if len(p) > 0 {
+				p = m.config.DaemonPath + ":" + p
+			} else {
+				p = m.config.DaemonPath
+			}
+			if err := os.Setenv("PATH", p); err != nil {
+				return fmt.Errorf("%s Init(): error setting environment variable PATH=%s: %w", m.name, p, err)
+			}
 		}
 		C.HPMmode(1)
 		retCode := C.HPMinit()
@@ -327,7 +328,7 @@ func (m *LikwidCollector) Init(config json.RawMessage) error {
 		for _, c := range m.cpulist {
 			m.measureThread.Call(
 				func() {
-					retCode := C.HPMaddThread(c)
+					retCode := C.HPMaddThread(C.uint32_t(c))
 					if retCode != 0 {
 						err := fmt.Errorf("C.HPMaddThread(%v) failed with return code %v", c, retCode)
 						cclog.ComponentError(m.name, err.Error())
@@ -369,16 +370,23 @@ func (m *LikwidCollector) Init(config json.RawMessage) error {
 // take a measurement for 'interval' seconds of event set index 'group'
 func (m *LikwidCollector) takeMeasurement(evidx int, evset LikwidEventsetConfig, interval time.Duration) (bool, error) {
 	var ret C.int
-	var gid C.int = -1
 	sigchan := make(chan os.Signal, 1)
 
 	// Watch changes for the lock file ()
 	watcher, err := fsnotify.NewWatcher()
 	if err != nil {
-		cclog.ComponentError(m.name, err.Error())
+		cclog.ComponentError(
+			m.name,
+			fmt.Sprintf("takeMeasurement(): Failed to create a new fsnotify.Watcher: %v", err))
 		return true, err
 	}
-	defer watcher.Close()
+	defer func() {
+		if err := watcher.Close(); err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("takeMeasurement(): Failed to close fsnotify.Watcher: %v", err))
+		}
+	}()
 	if len(m.config.LockfilePath) > 0 {
 		// Check if the lock file exists
 		info, err := os.Stat(m.config.LockfilePath)
@@ -386,9 +394,11 @@ func (m *LikwidCollector) takeMeasurement(evidx int, evset LikwidEventsetConfig,
 			// Create the lock file if it does not exist
 			file, createErr := os.Create(m.config.LockfilePath)
 			if createErr != nil {
-				return true, fmt.Errorf("failed to create lock file: %v", createErr)
+				return true, fmt.Errorf("failed to create lock file: %w", createErr)
+			}
+			if err := file.Close(); err != nil {
+				return true, fmt.Errorf("failed to close lock file: %w", err)
 			}
-			file.Close()
 			info, err = os.Stat(m.config.LockfilePath) // Recheck the file after creation
 		}
 		if err != nil {
@@ -440,6 +450,7 @@ func (m *LikwidCollector) takeMeasurement(evidx int, evset LikwidEventsetConfig,
 	signal.Notify(sigchan, syscall.SIGCHLD)
 
 	// Add an event string to LIKWID
+	var gid C.int
 	select {
 	case <-sigchan:
 		gid = -1
@@ -595,20 +606,20 @@ 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(
-					y, err :=
+						metric.Name,
-						lp.NewMessage(
+						map[string]string{
-							metric.Name,
+							"type": metric.Type,
-							map[string]string{
+						},
-								"type": metric.Type,
+						m.meta,
-							},
+						map[string]any{
-							m.meta,
+							"value": value,
-							fields,
+						},
-							now,
+						now,
-						)
+					)
 					if err == nil {
 						if metric.Type != "node" {
-							y.AddTag("type-id", fmt.Sprintf("%d", domain))
+							y.AddTag("type-id", strconv.Itoa(domain))
 						}
 						if len(metric.Unit) > 0 {
 							y.AddMeta("unit", metric.Unit)
@@ -633,19 +644,18 @@ func (m *LikwidCollector) calcEventsetMetrics(evset LikwidEventsetConfig, interv
 			}
 
 			for coreID, value := range totalCoreValues {
-				y, err :=
+				y, err := lp.NewMessage(
-					lp.NewMessage(
+					metric.Name,
-						metric.Name,
+					map[string]string{
-						map[string]string{
+						"type":    "core",
-							"type":    "core",
+						"type-id": strconv.Itoa(coreID),
-							"type-id": fmt.Sprintf("%d", coreID),
+					},
-						},
+					m.meta,
-						m.meta,
+					map[string]any{
-						map[string]interface{}{
+						"value": value,
-							"value": value,
+					},
-						},
+					now,
-						now,
+				)
-					)
 				if err != nil {
 					continue
 				}
@@ -670,19 +680,18 @@ func (m *LikwidCollector) calcEventsetMetrics(evset LikwidEventsetConfig, interv
 			}
 
 			for socketID, value := range totalSocketValues {
-				y, err :=
+				y, err := lp.NewMessage(
-					lp.NewMessage(
+					metric.Name,
-						metric.Name,
+					map[string]string{
-						map[string]string{
+						"type":    "socket",
-							"type":    "socket",
+						"type-id": strconv.Itoa(socketID),
-							"type-id": fmt.Sprintf("%d", socketID),
+					},
-						},
+					m.meta,
-						m.meta,
+					map[string]any{
-						map[string]interface{}{
+						"value": value,
-							"value": value,
+					},
-						},
+					now,
-						now,
+				)
-					)
 				if err != nil {
 					continue
 				}
@@ -705,18 +714,17 @@ func (m *LikwidCollector) calcEventsetMetrics(evset LikwidEventsetConfig, interv
 				}
 			}
 
-			y, err :=
+			y, err := lp.NewMessage(
-				lp.NewMessage(
+				metric.Name,
-					metric.Name,
+				map[string]string{
-					map[string]string{
+					"type": "node",
-						"type": "node",
+				},
-					},
+				m.meta,
-					m.meta,
+				map[string]any{
-					map[string]interface{}{
+					"value": totalNodeValue,
-						"value": totalNodeValue,
+				},
-					},
+				now,
-					now,
+			)
-				)
 			if err != nil {
 				continue
 			}
@@ -748,9 +756,7 @@ func (m *LikwidCollector) calcGlobalMetrics(groups []LikwidEventsetConfig, inter
 				// Here we generate parameter list
 				params := make(map[string]float64)
 				for _, evset := range groups {
-					for mname, mres := range evset.metrics[tid] {
+					maps.Copy(params, evset.metrics[tid])
-						params[mname] = mres
-					}
 				}
 				params["gotime"] = interval.Seconds()
 				// Evaluate the metric
@@ -765,21 +771,20 @@ func (m *LikwidCollector) calcGlobalMetrics(groups []LikwidEventsetConfig, inter
 				// Now we have the result, send it with the proper tags
 				if !math.IsNaN(value) {
 					if metric.Publish {
-						y, err :=
+						y, err := lp.NewMessage(
-							lp.NewMessage(
+							metric.Name,
-								metric.Name,
+							map[string]string{
-								map[string]string{
+								"type": metric.Type,
-									"type": metric.Type,
+							},
-								},
+							m.meta,
-								m.meta,
+							map[string]any{
-								map[string]interface{}{
+								"value": value,
-									"value": value,
+							},
-								},
+							now,
-								now,
+						)
-							)
 						if err == nil {
 							if metric.Type != "node" {
-								y.AddTag("type-id", fmt.Sprintf("%d", domain))
+								y.AddTag("type-id", strconv.Itoa(domain))
 							}
 							if len(metric.Unit) > 0 {
 								y.AddMeta("unit", metric.Unit)
@@ -795,7 +800,7 @@ func (m *LikwidCollector) calcGlobalMetrics(groups []LikwidEventsetConfig, inter
 }
 
 func (m *LikwidCollector) ReadThread(interval time.Duration, output chan lp.CCMessage) {
-	var err error = nil
+	var err error
 	groups := make([]LikwidEventsetConfig, 0)
 
 	for evidx, evset := range m.config.Eventsets {
@@ -813,13 +818,21 @@ func (m *LikwidCollector) ReadThread(interval time.Duration, output chan lp.CCMe
 
 		if !skip {
 			// read measurements and derive event set metrics
-			m.calcEventsetMetrics(e, interval, output)
+			err = m.calcEventsetMetrics(e, interval, output)
+			if err != nil {
+				cclog.ComponentError(m.name, err.Error())
+				return
+			}
 			groups = append(groups, e)
 		}
 	}
 	if len(groups) > 0 {
 		// calculate global metrics
-		m.calcGlobalMetrics(groups, interval, output)
+		err = m.calcGlobalMetrics(groups, interval, output)
+		if err != nil {
+			cclog.ComponentError(m.name, err.Error())
+			return
+		}
 	}
 }
 

collectors/loadavgMetric.go

@@ -8,15 +8,17 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"os"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 // LoadavgCollector collects:
@@ -29,6 +31,7 @@ const LOADAVGFILE = "/proc/loadavg"
 
 type LoadavgCollector struct {
 	metricCollector
+
 	tags         map[string]string
 	load_matches []string
 	load_skips   []bool
@@ -42,32 +45,39 @@ type LoadavgCollector struct {
 func (m *LoadavgCollector) Init(config json.RawMessage) error {
 	m.name = "LoadavgCollector"
 	m.parallel = true
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	if len(config) > 0 {
-		err := json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
 	m.meta = map[string]string{
 		"source": m.name,
-		"group":  "LOAD"}
+		"group":  "LOAD",
+	}
 	m.tags = map[string]string{"type": "node"}
 	m.load_matches = []string{
 		"load_one",
 		"load_five",
-		"load_fifteen"}
+		"load_fifteen",
-	m.load_skips = make([]bool, len(m.load_matches))
+	}
 	m.proc_matches = []string{
 		"proc_run",
-		"proc_total"}
+		"proc_total",
-	m.proc_skips = make([]bool, len(m.proc_matches))
-
-	for i, name := range m.load_matches {
-		_, m.load_skips[i] = stringArrayContains(m.config.ExcludeMetrics, name)
 	}
+
+	m.load_skips = make([]bool, len(m.load_matches))
+	for i, name := range m.load_matches {
+		m.load_skips[i] = slices.Contains(m.config.ExcludeMetrics, name)
+	}
+
+	m.proc_skips = make([]bool, len(m.proc_matches))
 	for i, name := range m.proc_matches {
-		_, m.proc_skips[i] = stringArrayContains(m.config.ExcludeMetrics, name)
+		m.proc_skips[i] = slices.Contains(m.config.ExcludeMetrics, name)
 	}
 	m.init = true
 	return nil
@@ -99,7 +109,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.NewMetric(name, m.tags, m.meta, x, now)
 		if err == nil {
 			output <- y
 		}
@@ -118,7 +128,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.NewMetric(name, m.tags, m.meta, x, now)
 		if err == nil {
 			output <- y
 		}

collectors/lustreMetric.go

@@ -8,22 +8,25 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"os/exec"
 	"os/user"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
 )
 
-const LUSTRE_SYSFS = `/sys/fs/lustre`
+const (
-const LCTL_CMD = `lctl`
+	LUSTRE_SYSFS = `/sys/fs/lustre`
-const LCTL_OPTION = `get_param`
+	LCTL_CMD     = `lctl`
+	LCTL_OPTION  = `get_param`
+)
 
 type LustreCollectorConfig struct {
 	LCtlCommand        string   `json:"lctl_command,omitempty"`
@@ -44,6 +47,7 @@ type LustreMetricDefinition struct {
 
 type LustreCollector struct {
 	metricCollector
+
 	tags          map[string]string
 	config        LustreCollectorConfig
 	lctl          string
@@ -61,7 +65,6 @@ func (m *LustreCollector) getDeviceDataCommand(device string) []string {
 	} else {
 		command = exec.Command(m.lctl, LCTL_OPTION, statsfile)
 	}
-	command.Wait()
 	stdout, _ := command.Output()
 	return strings.Split(string(stdout), "\n")
 }
@@ -297,12 +300,15 @@ func (m *LustreCollector) Init(config json.RawMessage) error {
 	m.name = "LustreCollector"
 	m.parallel = true
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	m.tags = map[string]string{"type": "node"}
 	m.meta = map[string]string{"source": m.name, "group": "Lustre"}
 
@@ -311,18 +317,15 @@ func (m *LustreCollector) Init(config json.RawMessage) error {
 	if !m.config.Sudo {
 		user, err := user.Current()
 		if err != nil {
-			cclog.ComponentError(m.name, "Failed to get current user:", err.Error())
+			return fmt.Errorf("%s Init(): Failed to get current user: %w", m.name, err)
-			return err
 		}
 		if user.Uid != "0" {
-			cclog.ComponentError(m.name, "Lustre file system statistics can only be queried by user root")
+			return fmt.Errorf("%s Init(): Lustre file system statistics can only be queried by user root", m.name)
-			return err
 		}
 	} else {
 		p, err := exec.LookPath("sudo")
 		if err != nil {
-			cclog.ComponentError(m.name, "Cannot find 'sudo'")
+			return fmt.Errorf("%s Init(): Cannot find 'sudo': %w", m.name, err)
-			return err
 		}
 		m.sudoCmd = p
 	}
@@ -331,7 +334,7 @@ func (m *LustreCollector) Init(config json.RawMessage) error {
 	if err != nil {
 		p, err = exec.LookPath(LCTL_CMD)
 		if err != nil {
-			return err
+			return fmt.Errorf("%s Init(): Cannot find %s command: %w", m.name, LCTL_CMD, err)
 		}
 	}
 	m.lctl = p
@@ -339,32 +342,32 @@ func (m *LustreCollector) Init(config json.RawMessage) error {
 	m.definitions = []LustreMetricDefinition{}
 	if m.config.SendAbsoluteValues {
 		for _, def := range LustreAbsMetrics {
-			if _, skip := stringArrayContains(m.config.ExcludeMetrics, def.name); !skip {
+			if !slices.Contains(m.config.ExcludeMetrics, def.name) {
 				m.definitions = append(m.definitions, def)
 			}
 		}
 	}
 	if m.config.SendDiffValues {
 		for _, def := range LustreDiffMetrics {
-			if _, skip := stringArrayContains(m.config.ExcludeMetrics, def.name); !skip {
+			if !slices.Contains(m.config.ExcludeMetrics, def.name) {
 				m.definitions = append(m.definitions, def)
 			}
 		}
 	}
 	if m.config.SendDerivedValues {
 		for _, def := range LustreDeriveMetrics {
-			if _, skip := stringArrayContains(m.config.ExcludeMetrics, def.name); !skip {
+			if !slices.Contains(m.config.ExcludeMetrics, def.name) {
 				m.definitions = append(m.definitions, def)
 			}
 		}
 	}
 	if len(m.definitions) == 0 {
-		return errors.New("no metrics to collect")
+		return fmt.Errorf("%s Init(): no metrics to collect", m.name)
 	}
 
 	devices := m.getDevices()
 	if len(devices) == 0 {
-		return errors.New("no Lustre devices found")
+		return fmt.Errorf("%s Init(): no Lustre devices found", m.name)
 	}
 	m.stats = make(map[string]map[string]int64)
 	for _, d := range devices {
@@ -402,23 +405,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)

collectors/lustreMetric.md

@@ -55,3 +55,16 @@ Metrics:
 * `lustre_inode_permission_diff` (if `send_diff_values == true`)
 
 This collector adds an `device` tag.
+
+`lctl` typically require root to run.
+In order to run `cc-metric-collector` without root priviliges, you can enable `use_sudo`.
+Add a file like this in `/etc/sudoers.d/` to allow `cc-metric-collector` to run the required command:
+
+```
+# Do not log the following sudo commands from monitoring, since this causes a lot of log spam.
+# However keep log_denied enabled, to detect failures
+Defaults: monitoring !log_allowed, !pam_session
+
+# Allow to use lctl
+monitoring ALL = (root) NOPASSWD:/absolute/path/to/lctl get_param llite.*.stats
+```

collectors/megwareEureka.go

@@ -0,0 +1,194 @@
+// Copyright (C) NHR@FAU, University Erlangen-Nuremberg.
+// All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+// additional authors:
+// Michael Panzlaff (NHR@FAU)
+
+package collectors
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"time"
+
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
+)
+
+// MPS refers to Monolithic Power Systems, from which the MP5922 is used
+// to measure telemetry on the Eureka platform.
+type mpsData struct {
+	Cnt         int64   `json:"Cnt"` // No idea what this is, ignore
+	Energy      float64 `json:"Energy"`
+	Vin         float64 `json:"Vin"`
+	Iin         float64 `json:"Iin"`
+	Pin         float64 `json:"Pin"`
+	PinAvg      float64 `json:"PinAvg"`
+	Vout        float64 `json:"Vout"`
+	Iout        float64 `json:"Iout"`
+	Pout        float64 `json:"Pout"`
+	StandbyVout float64 `json:"StandbyVout"`
+	StandbyIout float64 `json:"StandbyIout"`
+	StandbyPout float64 `json:"StandbyPout"`
+	TempBusbar  float64 `json:"TempBusbar"`
+	TempSsd     float64 `json:"TempSsd"`
+	TempMps     float64 `json:"TempMps"`
+	// No idea what the ones below mean exactl. Ignore them for now.
+	EnergyTime         int64 `json:"EnergyTime"`
+	EnergyAccumulator  int64 `json:"EnergyAccumulator"`
+	EnergyRolloverCnt  int64 `json:"EnergyRolloverCnt"`
+	EnergySampleCntU24 int64 `json:"EnergySampleCntU24"`
+
+	Timestamp time.Time
+}
+
+type MegwareEurekaCollector struct {
+	metricCollector
+
+	config struct {
+		U20Path string `json:"u20_path"`
+		Sudo    bool   `json:"use_sudo"`
+	}
+
+	u20path string
+
+	energyValLast  float64
+	energyTimeLast time.Time
+}
+
+func (m *MegwareEurekaCollector) Init(config json.RawMessage) error {
+	// Check if already initialized
+	if m.init {
+		return nil
+	}
+
+	m.name = "MegwareEurekaCollector"
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
+	m.meta = map[string]string{
+		"source": m.name,
+		"group":  "U20",
+	}
+
+	m.config.U20Path = "u20"
+
+	if len(config) > 0 {
+		d := json.NewDecoder(bytes.NewReader(config))
+		d.DisallowUnknownFields()
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
+		}
+	}
+
+	m.u20path = m.config.U20Path
+
+	data, err := m.readMpsData()
+	if err != nil {
+		return fmt.Errorf("energy reading test failed: %w", err)
+	}
+
+	m.energyValLast = data.Energy
+	m.energyTimeLast = time.Now()
+	m.init = true
+
+	return nil
+}
+
+func (m *MegwareEurekaCollector) readMpsData() (*mpsData, error) {
+	argv := make([]string, 0)
+	if m.config.Sudo {
+		argv = append(argv, "sudo", "-n")
+	}
+
+	argv = append(argv, m.u20path, "values", "--read", "GET_MPS_POLL_VALUES")
+
+	cmd := exec.Command(argv[0], argv[1:]...)
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	err := cmd.Run()
+	if err != nil {
+		return nil, fmt.Errorf("failed to run u20: %w (stdout=%s stderr=%s)", err, stdout.String(), stderr.String())
+	}
+
+	var u20output struct {
+		GetMpsPollValues mpsData `json:"GET_MPS_POLL_VALUES"`
+	}
+
+	err = json.Unmarshal(stdout.Bytes(), &u20output)
+	if err != nil {
+		return nil, fmt.Errorf("unable to decode u20 JSON output: %w (stdout=%s)", err, stdout.String())
+	}
+
+	u20output.GetMpsPollValues.Timestamp = time.Now()
+
+	return &u20output.GetMpsPollValues, nil
+}
+
+func (m *MegwareEurekaCollector) Read(interval time.Duration, output chan lp.CCMessage) {
+	// Check if already initialized
+	if !m.init {
+		return
+	}
+
+	data, err := m.readMpsData()
+	if err != nil {
+		cclog.ComponentErrorf(m.name, "readMpsData failed: %v", err)
+		return
+	}
+
+	powerVal := 0.0
+
+	if data.Timestamp.After(m.energyTimeLast) {
+		// Important, m.energy comes in Wh, so multiply by 3600 to get Ws (aka Joule)
+		energyValDiff := data.Energy - m.energyValLast
+		energyTimeDiff := data.Timestamp.Sub(m.energyTimeLast)
+		powerVal = energyValDiff * 3600 / energyTimeDiff.Seconds()
+
+		m.energyValLast = data.Energy
+		m.energyTimeLast = data.Timestamp
+	}
+
+	metricNamePrefix := "eureka_"
+	metricMap := map[string]struct {
+		value any
+		unit  string
+	}{
+		"power":        {value: powerVal, unit: "Watts"},
+		"vin":          {value: data.Vin, unit: "Volts"},
+		"iin":          {value: data.Iin, unit: "Amperes"},
+		"pin":          {value: data.Pin, unit: "Watts"},
+		"pin_avg":      {value: data.PinAvg, unit: "Watts"},
+		"vout":         {value: data.Vout, unit: "Volts"},
+		"iout":         {value: data.Iout, unit: "Amperes"},
+		"pout":         {value: data.Pout, unit: "Watts"},
+		"standby_vout": {value: data.StandbyVout, unit: "Volts"},
+		"standby_iout": {value: data.StandbyIout, unit: "Amperes"},
+		"standby_pout": {value: data.StandbyPout, unit: "Watts"},
+		"temp_busbar":  {value: data.TempBusbar, unit: "degC"},
+		"temp_ssd":     {value: data.TempSsd, unit: "degC"},
+		"temp_mps":     {value: data.TempMps, unit: "degC"},
+	}
+
+	for metricName, metricData := range metricMap {
+		metricName = metricNamePrefix + metricName
+		metric, err := lp.NewMetric(metricName, map[string]string{"type": "node"}, m.meta, metricData.value, data.Timestamp)
+		if err != nil {
+			cclog.ComponentErrorf(m.name, "lp.NewMetric failed: %v", err)
+			return
+		}
+		metric.AddMeta("unit", metricData.unit)
+		output <- metric
+	}
+}
+
+func (m *MegwareEurekaCollector) Close() {
+	m.init = false
+}

collectors/megwareEureka.md

@@ -0,0 +1,44 @@
+<!--
+---
+title: Megware Eureka collector
+description: Collect power and other metrics of Megware Eureka machines using u20
+categories: [cc-metric-collector]
+tags: ['Admin']
+weight: 2
+hugo_path: docs/reference/cc-metric-collector/collectors/lenovoDensePower.md
+---
+-->
+
+## `lenovo_dense_power` collector
+
+```json
+  "megware_eureka": {
+    "u20_path": "/path/to/ipmitool",
+    "use_sudo": true
+  }
+```
+
+The `megware_eureka` collector reads power and other metrics from Megware Eureka machines via `u20`.
+If the u20 tool is available for your machines, it's possible that this collector is compatible.
+If you don't have access to u20, please contact your Megware sales person.
+
+You can test the collector compatibility by running the following command:
+
+```
+$ u20 values --read GET_MPS_POLL_VALUES
+```
+
+If this returns a JSON with energy, voltage and current readings, you're fine.
+
+In addition, `u20` typically requires root to run.
+In order to run `cc-metric-collector` without root priviliges, you can enable `use_sudo`.
+Add a file like this in `/etc/sudoers.d/` to allow `cc-metric-collector` to run the required commands:
+
+```
+# Do not log the following sudo commands from monitoring, since this causes a lot of log spam.
+# However keep log_denied enabled, to detect failures
+Defaults: monitoring !log_allowed, !pam_session
+
+# Allow to use u20 for Megware power readings
+monitoring ALL = (root) NOPASSWD:/usr/bin/u20 values --read GET_MPS_POLL_VALUES
+```

collectors/memstatMetric.go

@@ -9,22 +9,25 @@ package collectors
 
 import (
 	"bufio"
+	"bytes"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 	"regexp"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
-const MEMSTATFILE = "/proc/meminfo"
+const (
-const NUMA_MEMSTAT_BASE = "/sys/devices/system/node"
+	MEMSTATFILE       = "/proc/meminfo"
+	NUMA_MEMSTAT_BASE = "/sys/devices/system/node"
+)
 
 type MemstatCollectorConfig struct {
 	ExcludeMetrics []string `json:"exclude_metrics"`
@@ -39,6 +42,7 @@ type MemstatCollectorNode struct {
 
 type MemstatCollector struct {
 	metricCollector
+
 	stats       map[string]int64
 	tags        map[string]string
 	matches     map[string]string
@@ -58,13 +62,18 @@ func getStats(filename string) map[string]MemstatStats {
 	if err != nil {
 		cclog.Error(err.Error())
 	}
-	defer file.Close()
+	defer func() {
+		if err := file.Close(); err != nil {
+			cclog.Error(err.Error())
+		}
+	}()
 
 	scanner := bufio.NewScanner(file)
 	for scanner.Scan() {
 		line := scanner.Text()
 		linefields := strings.Fields(line)
-		if len(linefields) == 3 {
+		switch len(linefields) {
+		case 3:
 			v, err := strconv.ParseFloat(linefields[1], 64)
 			if err == nil {
 				stats[strings.Trim(linefields[0], ":")] = MemstatStats{
@@ -72,7 +81,7 @@ func getStats(filename string) map[string]MemstatStats {
 					unit:  linefields[2],
 				}
 			}
-		} else if len(linefields) == 5 {
+		case 5:
 			v, err := strconv.ParseFloat(linefields[3], 64)
 			if err == nil {
 				cclog.ComponentDebug("getStats", strings.Trim(linefields[2], ":"), v, linefields[4])
@@ -87,51 +96,77 @@ func getStats(filename string) map[string]MemstatStats {
 }
 
 func (m *MemstatCollector) Init(config json.RawMessage) error {
-	var err error
 	m.name = "MemstatCollector"
 	m.parallel = true
 	m.config.NodeStats = true
 	m.config.NumaStats = false
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
-	m.meta = map[string]string{"source": m.name, "group": "Memory"}
+	m.meta = map[string]string{
+		"source": m.name,
+		"group":  "Memory",
+	}
 	m.stats = make(map[string]int64)
 	m.matches = make(map[string]string)
 	m.tags = map[string]string{"type": "node"}
 	matches := map[string]string{
-		"MemTotal":     "mem_total",
+		"MemTotal":        "mem_total",
-		"SwapTotal":    "swap_total",
+		"SwapTotal":       "swap_total",
-		"SReclaimable": "mem_sreclaimable",
+		"SReclaimable":    "mem_sreclaimable",
-		"Slab":         "mem_slab",
+		"Slab":            "mem_slab",
-		"MemFree":      "mem_free",
+		"MemFree":         "mem_free",
-		"Buffers":      "mem_buffers",
+		"Buffers":         "mem_buffers",
-		"Cached":       "mem_cached",
+		"Cached":          "mem_cached",
-		"MemAvailable": "mem_available",
+		"MemAvailable":    "mem_available",
-		"SwapFree":     "swap_free",
+		"SwapFree":        "swap_free",
-		"MemShared":    "mem_shared",
+		"Shmem":           "mem_shared",
+		"Active":          "mem_active",
+		"Inactive":        "mem_inactive",
+		"Dirty":           "mem_dirty",
+		"Writeback":       "mem_writeback",
+		"AnonPages":       "mem_anon_pages",
+		"Mapped":          "mem_mapped",
+		"VmallocTotal":    "mem_vmalloc_total",
+		"AnonHugePages":   "mem_anon_hugepages",
+		"ShmemHugePages":  "mem_shared_hugepages",
+		"ShmemPmdMapped":  "mem_shared_pmd_mapped",
+		"HugePages_Total": "mem_hugepages_total",
+		"HugePages_Free":  "mem_hugepages_free",
+		"HugePages_Rsvd":  "mem_hugepages_reserved",
+		"HugePages_Surp":  "mem_hugepages_surplus",
+		"Hugepagesize":    "mem_hugepages_size",
+		"DirectMap4k":     "mem_direct_mapped_4k",
+		"DirectMap4M":     "mem_direct_mapped_4m",
+		"DirectMap2M":     "mem_direct_mapped_2m",
+		"DirectMap1G":     "mem_direct_mapped_1g",
+		"Mlocked":         "mem_locked",
+		"PageTables":      "mem_pagetables",
+		"KernelStack":     "mem_kernelstack",
 	}
 	for k, v := range matches {
-		_, skip := stringArrayContains(m.config.ExcludeMetrics, k)
+		if !slices.Contains(m.config.ExcludeMetrics, v) {
-		if !skip {
 			m.matches[k] = v
 		}
 	}
 	m.sendMemUsed = false
-	if _, skip := stringArrayContains(m.config.ExcludeMetrics, "mem_used"); !skip {
+	if !slices.Contains(m.config.ExcludeMetrics, "mem_used") {
 		m.sendMemUsed = true
 	}
-	if len(m.matches) == 0 {
+	if len(m.matches) == 0 && !m.sendMemUsed {
-		return errors.New("no metrics to collect")
+		return fmt.Errorf("%s Init(): no metrics to collect", m.name)
+	}
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
 	}
-	m.setup()
 
 	if m.config.NodeStats {
 		if stats := getStats(MEMSTATFILE); len(stats) == 0 {
-			return fmt.Errorf("cannot read data from file %s", MEMSTATFILE)
+			return fmt.Errorf("%s Init(): cannot read data from file %s", m.name, MEMSTATFILE)
 		}
 	}
 
@@ -143,7 +178,7 @@ func (m *MemstatCollector) Init(config json.RawMessage) error {
 			m.nodefiles = make(map[int]MemstatCollectorNode)
 			for _, f := range files {
 				if stats := getStats(f); len(stats) == 0 {
-					return fmt.Errorf("cannot read data from file %s", f)
+					return fmt.Errorf("%s Init(): cannot read data from file %s", m.name, f)
 				}
 				rematch := regex.FindStringSubmatch(f)
 				if len(rematch) == 2 {
@@ -153,7 +188,7 @@ func (m *MemstatCollector) Init(config json.RawMessage) error {
 							file: f,
 							tags: map[string]string{
 								"type":    "memoryDomain",
-								"type-id": fmt.Sprintf("%d", id),
+								"type-id": strconv.Itoa(id),
 							},
 						}
 						m.nodefiles[id] = f
@@ -163,7 +198,7 @@ func (m *MemstatCollector) Init(config json.RawMessage) error {
 		}
 	}
 	m.init = true
-	return err
+	return nil
 }
 
 func (m *MemstatCollector) Read(interval time.Duration, output chan lp.CCMessage) {
@@ -174,7 +209,7 @@ func (m *MemstatCollector) Read(interval time.Duration, output chan lp.CCMessage
 	sendStats := func(stats map[string]MemstatStats, tags map[string]string) {
 		for match, name := range m.matches {
 			var value float64 = 0
-			var unit string = ""
+			unit := ""
 			if v, ok := stats[match]; ok {
 				value = v.value
 				if len(v.unit) > 0 {
@@ -182,7 +217,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.NewMetric(name, tags, m.meta, value, time.Now())
 			if err == nil {
 				if len(unit) > 0 {
 					y.AddMeta("unit", unit)
@@ -212,10 +247,16 @@ func (m *MemstatCollector) Read(interval time.Duration, output chan lp.CCMessage
 								unit = cacheVal.unit
 							}
 						}
+						if shmemVal, shmem := stats["Shmem"]; shmem {
+							memUsed -= shmemVal.value
+							if len(shmemVal.unit) > 0 && len(unit) == 0 {
+								unit = shmemVal.unit
+							}
+						}
 					}
 				}
 			}
-			y, err := lp.NewMessage("mem_used", tags, m.meta, map[string]interface{}{"value": memUsed}, time.Now())
+			y, err := lp.NewMetric("mem_used", tags, m.meta, memUsed, time.Now())
 			if err == nil {
 				if len(unit) > 0 {
 					y.AddMeta("unit", unit)

collectors/memstatMetric.md

@@ -32,7 +32,29 @@ Metrics:
 * `mem_cached`
 * `mem_available`
 * `mem_shared`
+* `mem_active`
+* `mem_inactive`
+* `mem_dirty`
+* `mem_writeback`
+* `mem_anon_pages`
+* `mem_mapped`
+* `mem_vmalloc_total`
+* `mem_anon_hugepages`
+* `mem_shared_hugepages`
+* `mem_shared_pmd_mapped`
+* `mem_hugepages_total`
+* `mem_hugepages_free`
+* `mem_hugepages_reserved`
+* `mem_hugepages_surplus`
+* `mem_hugepages_size`
+* `mem_direct_mapped_4k`
+* `mem_direct_mapped_2m`
+* `mem_direct_mapped_4m`
+* `mem_direct_mapped_1g`
+* `mem_locked`
+* `mem_pagetables`
+* `mem_kernelstack`
 * `swap_total`
 * `swap_free`
-* `mem_used` = `mem_total` - (`mem_free` + `mem_buffers` + `mem_cached`)
+* `mem_used` = `mem_total` - (`mem_free` + `mem_buffers` + `mem_cached` + `mem_shared`)
 

collectors/metricCollector.go

@@ -12,7 +12,7 @@ import (
 	"fmt"
 	"time"
 
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 type MetricCollector interface {
@@ -51,30 +51,6 @@ func (c *metricCollector) Initialized() bool {
 	return c.init
 }
 
-// intArrayContains scans an array of ints if the value str is present in the array
-// If the specified value is found, the corresponding array index is returned.
-// The bool value is used to signal success or failure
-func intArrayContains(array []int, str int) (int, bool) {
-	for i, a := range array {
-		if a == str {
-			return i, true
-		}
-	}
-	return -1, false
-}
-
-// stringArrayContains scans an array of strings if the value str is present in the array
-// If the specified value is found, the corresponding array index is returned.
-// The bool value is used to signal success or failure
-func stringArrayContains(array []string, str string) (int, bool) {
-	for i, a := range array {
-		if a == str {
-			return i, true
-		}
-	}
-	return -1, false
-}
-
 // RemoveFromStringList removes the string r from the array of strings s
 // If r is not contained in the array an error is returned
 func RemoveFromStringList(s []string, r string) ([]string, error) {

collectors/netstatMetric.go

@@ -9,15 +9,17 @@ package collectors
 
 import (
 	"bufio"
+	"bytes"
 	"encoding/json"
-	"errors"
+	"fmt"
 	"os"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 const NETSTATFILE = "/proc/net/dev"
@@ -40,6 +42,7 @@ type NetstatCollectorMetric struct {
 
 type NetstatCollector struct {
 	metricCollector
+
 	config           NetstatCollectorConfig
 	aliasToCanonical map[string]string
 	matches          map[string][]NetstatCollectorMetric
@@ -65,7 +68,9 @@ func getCanonicalName(raw string, aliasToCanonical map[string]string) string {
 func (m *NetstatCollector) Init(config json.RawMessage) error {
 	m.name = "NetstatCollector"
 	m.parallel = true
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	m.lastTimestamp = time.Now()
 
 	const (
@@ -95,10 +100,10 @@ func (m *NetstatCollector) Init(config json.RawMessage) error {
 	m.config.SendDerivedValues = false
 	// Read configuration file, allow overwriting default config
 	if len(config) > 0 {
-		err := json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			cclog.ComponentError(m.name, "Error reading config:", err.Error())
+		if err := d.Decode(&m.config); err != nil {
-			return err
+			return fmt.Errorf("%s Init(): failed to decode JSON config: %w", m.name, err)
 		}
 	}
 
@@ -107,10 +112,8 @@ func (m *NetstatCollector) Init(config json.RawMessage) error {
 	// Check access to net statistic file
 	file, err := os.Open(NETSTATFILE)
 	if err != nil {
-		cclog.ComponentError(m.name, err.Error())
+		return fmt.Errorf("%s Init(): failed to open netstat file \"%s\": %w", m.name, NETSTATFILE, err)
-		return err
 	}
-	defer file.Close()
 
 	scanner := bufio.NewScanner(file)
 	for scanner.Scan() {
@@ -129,13 +132,33 @@ func (m *NetstatCollector) Init(config json.RawMessage) error {
 		canonical := getCanonicalName(raw, m.aliasToCanonical)
 
 		// Check if device is a included device
-		if _, ok := stringArrayContains(m.config.IncludeDevices, canonical); ok {
+		if slices.Contains(m.config.IncludeDevices, canonical) {
 			// Tag will contain original device name (raw).
-			tags := map[string]string{"stype": "network", "stype-id": raw, "type": "node"}
+			tags := map[string]string{
-			meta_unit_byte := map[string]string{"source": m.name, "group": "Network", "unit": "bytes"}
+				"stype":    "network",
-			meta_unit_byte_per_sec := map[string]string{"source": m.name, "group": "Network", "unit": "bytes/sec"}
+				"stype-id": raw,
-			meta_unit_pkts := map[string]string{"source": m.name, "group": "Network", "unit": "packets"}
+				"type":     "node",
-			meta_unit_pkts_per_sec := map[string]string{"source": m.name, "group": "Network", "unit": "packets/sec"}
+			}
+			meta_unit_byte := map[string]string{
+				"source": m.name,
+				"group":  "Network",
+				"unit":   "bytes",
+			}
+			meta_unit_byte_per_sec := map[string]string{
+				"source": m.name,
+				"group":  "Network",
+				"unit":   "bytes/sec",
+			}
+			meta_unit_pkts := map[string]string{
+				"source": m.name,
+				"group":  "Network",
+				"unit":   "packets",
+			}
+			meta_unit_pkts_per_sec := map[string]string{
+				"source": m.name,
+				"group":  "Network",
+				"unit":   "packets/sec",
+			}
 
 			m.matches[canonical] = []NetstatCollectorMetric{
 				{
@@ -174,8 +197,13 @@ func (m *NetstatCollector) Init(config json.RawMessage) error {
 		}
 	}
 
+	// Close netstat file
+	if err := file.Close(); err != nil {
+		return fmt.Errorf("%s Init(): failed to close netstat file \"%s\": %w", m.name, NETSTATFILE, err)
+	}
+
 	if len(m.matches) == 0 {
-		return errors.New("no devices to collector metrics found")
+		return fmt.Errorf("%s Init(): no devices to collect metrics found", m.name)
 	}
 	m.init = true
 	return nil
@@ -194,10 +222,18 @@ func (m *NetstatCollector) Read(interval time.Duration, output chan lp.CCMessage
 
 	file, err := os.Open(NETSTATFILE)
 	if err != nil {
-		cclog.ComponentError(m.name, err.Error())
+		cclog.ComponentError(
+			m.name,
+			fmt.Sprintf("Read(): Failed to open file '%s': %v", NETSTATFILE, err))
 		return
 	}
-	defer file.Close()
+	defer func() {
+		if err := file.Close(); err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to close file '%s': %v", NETSTATFILE, err))
+		}
+	}()
 
 	scanner := bufio.NewScanner(file)
 	for scanner.Scan() {
@@ -226,14 +262,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.NewMetric(metric.name, metric.tags, metric.meta, 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.NewMetric(metric.name+"_bw", metric.tags, metric.meta_rates, rate, now); err == nil {
 							output <- y
 						}
 					}

collectors/nfsMetric.go

@@ -8,9 +8,10 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
-	"log"
+	"slices"
 
 	//	"os"
 	"os/exec"
@@ -18,7 +19,8 @@ import (
 	"strings"
 	"time"
 
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 // First part contains the code for the general NfsCollector.
@@ -33,6 +35,7 @@ type NfsCollectorData struct {
 
 type nfsCollector struct {
 	metricCollector
+
 	tags    map[string]string
 	version string
 	config  struct {
@@ -42,68 +45,56 @@ type nfsCollector struct {
 	data map[string]NfsCollectorData
 }
 
-func (m *nfsCollector) initStats() error {
-	cmd := exec.Command(m.config.Nfsstats, `-l`, `--all`)
-	cmd.Wait()
-	buffer, err := cmd.Output()
-	if err == nil {
-		for _, line := range strings.Split(string(buffer), "\n") {
-			lf := strings.Fields(line)
-			if len(lf) != 5 {
-				continue
-			}
-			if lf[1] == m.version {
-				name := strings.Trim(lf[3], ":")
-				if _, exist := m.data[name]; !exist {
-					value, err := strconv.ParseInt(lf[4], 0, 64)
-					if err == nil {
-						x := m.data[name]
-						x.current = value
-						x.last = value
-						m.data[name] = x
-					}
-				}
-			}
-		}
-	}
-	return err
-}
-
 func (m *nfsCollector) updateStats() error {
-	cmd := exec.Command(m.config.Nfsstats, `-l`, `--all`)
+	cmd := exec.Command(m.config.Nfsstats, "-l", "--all")
-	cmd.Wait()
+
 	buffer, err := cmd.Output()
-	if err == nil {
+	if err != nil {
-		for _, line := range strings.Split(string(buffer), "\n") {
+		return err
-			lf := strings.Fields(line)
+	}
-			if len(lf) != 5 {
+
-				continue
+	for name, data := range m.data {
-			}
+		m.data[name] = NfsCollectorData{
-			if lf[1] == m.version {
+			last:    data.current,
-				name := strings.Trim(lf[3], ":")
+			current: -1,
-				if _, exist := m.data[name]; exist {
-					value, err := strconv.ParseInt(lf[4], 0, 64)
-					if err == nil {
-						x := m.data[name]
-						x.last = x.current
-						x.current = value
-						m.data[name] = x
-					}
-				}
-			}
 		}
 	}
-	return err
+
+	for line := range strings.Lines(string(buffer)) {
+		lf := strings.Fields(line)
+		if len(lf) != 5 {
+			continue
+		}
+		if lf[1] != m.version {
+			continue
+		}
+		name := strings.Trim(lf[3], ":")
+		value, err := strconv.ParseInt(lf[4], 0, 64)
+		if err != nil {
+			return err
+		}
+
+		collectorData, exist := m.data[name]
+		collectorData.current = value
+
+		if !exist {
+			collectorData.last = -1
+		}
+
+		m.data[name] = collectorData
+	}
+
+	return nil
 }
 
 func (m *nfsCollector) MainInit(config json.RawMessage) error {
 	m.config.Nfsstats = string(NFSSTAT_EXEC)
 	// Read JSON configuration
 	if len(config) > 0 {
-		err := json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			log.Print(err.Error())
+		if err := d.Decode(&m.config); err != nil {
-			return err
+			return fmt.Errorf("%s Init(): failed to decode JSON config: %w", m.name, err)
 		}
 	}
 	m.meta = map[string]string{
@@ -116,10 +107,12 @@ func (m *nfsCollector) MainInit(config json.RawMessage) error {
 	// Check if nfsstat is in executable search path
 	_, err := exec.LookPath(m.config.Nfsstats)
 	if err != nil {
-		return fmt.Errorf("NfsCollector.Init(): Failed to find nfsstat binary '%s': %v", m.config.Nfsstats, err)
+		return fmt.Errorf("%s Init(): Failed to find nfsstat binary '%s': %w", m.name, m.config.Nfsstats, err)
 	}
 	m.data = make(map[string]NfsCollectorData)
-	m.initStats()
+	if err := m.updateStats(); err != nil {
+		return fmt.Errorf("%s Init(): %w", m.name, err)
+	}
 	m.init = true
 	m.parallel = true
 	return nil
@@ -131,8 +124,14 @@ func (m *nfsCollector) Read(interval time.Duration, output chan lp.CCMessage) {
 	}
 	timestamp := time.Now()
 
-	m.updateStats()
+	if err := m.updateStats(); err != nil {
-	prefix := ""
+		cclog.ComponentError(
+			m.name,
+			fmt.Sprintf("Read(): updateStats() failed: %v", err),
+		)
+		return
+	}
+	var prefix string
 	switch m.version {
 	case "v3":
 		prefix = "nfs3"
@@ -143,14 +142,17 @@ func (m *nfsCollector) Read(interval time.Duration, output chan lp.CCMessage) {
 	}
 
 	for name, data := range m.data {
-		if _, skip := stringArrayContains(m.config.ExcludeMetrics, name); skip {
+		if slices.Contains(m.config.ExcludeMetrics, name) {
 			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)
+		if data.current >= 0 && data.last >= 0 {
-		if err == nil {
+			value := data.current - data.last
-			y.AddMeta("version", m.version)
+			y, err := lp.NewMetric(fmt.Sprintf("%s_%s", prefix, name), m.tags, m.meta, value, timestamp)
-			output <- y
+			if err == nil {
+				y.AddMeta("version", m.version)
+				output <- y
+			}
 		}
 	}
 }
@@ -170,13 +172,17 @@ type Nfs4Collector struct {
 func (m *Nfs3Collector) Init(config json.RawMessage) error {
 	m.name = "Nfs3Collector"
 	m.version = `v3`
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	return m.MainInit(config)
 }
 
 func (m *Nfs4Collector) Init(config json.RawMessage) error {
 	m.name = "Nfs4Collector"
 	m.version = `v4`
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	return m.MainInit(config)
 }

collectors/nfsiostatMetric.go

@@ -8,22 +8,23 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"os"
 	"regexp"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
 )
 
 // These are the fields we read from the JSON configuration
 type NfsIOStatCollectorConfig struct {
 	ExcludeMetrics          []string `json:"exclude_metrics,omitempty"`
-	ExcludeFilesystem       []string `json:"exclude_filesystem,omitempty"`
+	ExcludeFilesystems      []string `json:"exclude_filesystem,omitempty"`
 	UseServerAddressAsSType bool     `json:"use_server_as_stype,omitempty"`
 	SendAbsoluteValues      bool     `json:"send_abs_values"`
 	SendDerivedValues       bool     `json:"send_derived_values"`
@@ -33,6 +34,7 @@ type NfsIOStatCollectorConfig struct {
 // defined by metricCollector (name, init, ...)
 type NfsIOStatCollector struct {
 	metricCollector
+
 	config        NfsIOStatCollectorConfig    // the configuration structure
 	meta          map[string]string           // default meta information
 	tags          map[string]string           // default tags
@@ -41,8 +43,10 @@ type NfsIOStatCollector struct {
 	lastTimestamp time.Time
 }
 
-var deviceRegex = regexp.MustCompile(`device (?P<server>[^ ]+) mounted on (?P<mntpoint>[^ ]+) with fstype nfs(?P<version>\d*) statvers=[\d\.]+`)
+var (
-var bytesRegex = regexp.MustCompile(`\s+bytes:\s+(?P<nread>[^ ]+) (?P<nwrite>[^ ]+) (?P<dread>[^ ]+) (?P<dwrite>[^ ]+) (?P<nfsread>[^ ]+) (?P<nfswrite>[^ ]+) (?P<pageread>[^ ]+) (?P<pagewrite>[^ ]+)`)
+	deviceRegex = regexp.MustCompile(`device (?P<server>[^ ]+) mounted on (?P<mntpoint>[^ ]+) with fstype nfs(?P<version>\d*) statvers=[\d\.]+`)
+	bytesRegex  = regexp.MustCompile(`\s+bytes:\s+(?P<nread>[^ ]+) (?P<nwrite>[^ ]+) (?P<dread>[^ ]+) (?P<dwrite>[^ ]+) (?P<nfsread>[^ ]+) (?P<nfswrite>[^ ]+) (?P<pageread>[^ ]+) (?P<pagewrite>[^ ]+)`)
+)
 
 func resolve_regex_fields(s string, regex *regexp.Regexp) map[string]string {
 	fields := make(map[string]string)
@@ -71,7 +75,7 @@ func (m *NfsIOStatCollector) readNfsiostats() map[string]map[string]int64 {
 		// Is this a device line with mount point, remote target and NFS version?
 		dev := resolve_regex_fields(l, deviceRegex)
 		if len(dev) > 0 {
-			if _, ok := stringArrayContains(m.config.ExcludeFilesystem, dev[m.key]); !ok {
+			if !slices.Contains(m.config.ExcludeFilesystems, dev[m.key]) {
 				current = dev
 				if len(current["version"]) == 0 {
 					current["version"] = "3"
@@ -85,7 +89,7 @@ func (m *NfsIOStatCollector) readNfsiostats() map[string]map[string]int64 {
 			if len(bytes) > 0 {
 				data[current[m.key]] = make(map[string]int64)
 				for name, sval := range bytes {
-					if _, ok := stringArrayContains(m.config.ExcludeMetrics, name); !ok {
+					if !slices.Contains(m.config.ExcludeMetrics, name) {
 						val, err := strconv.ParseInt(sval, 10, 64)
 						if err == nil {
 							data[current[m.key]][name] = val
@@ -100,9 +104,10 @@ func (m *NfsIOStatCollector) readNfsiostats() map[string]map[string]int64 {
 }
 
 func (m *NfsIOStatCollector) Init(config json.RawMessage) error {
-	var err error = nil
 	m.name = "NfsIOStatCollector"
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	m.parallel = true
 	m.meta = map[string]string{"source": m.name, "group": "NFS", "unit": "bytes"}
 	m.tags = map[string]string{"type": "node"}
@@ -111,10 +116,10 @@ func (m *NfsIOStatCollector) Init(config json.RawMessage) error {
 	m.config.SendAbsoluteValues = true
 	m.config.SendDerivedValues = false
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			cclog.ComponentError(m.name, "Error reading config:", err.Error())
+		if err := d.Decode(&m.config); err != nil {
-			return err
+			return fmt.Errorf("%s Init(): failed to decode JSON config: %w", m.name, err)
 		}
 	}
 	m.key = "mntpoint"
@@ -124,7 +129,7 @@ func (m *NfsIOStatCollector) Init(config json.RawMessage) error {
 	m.data = m.readNfsiostats()
 	m.lastTimestamp = time.Now()
 	m.init = true
-	return err
+	return nil
 }
 
 func (m *NfsIOStatCollector) Read(interval time.Duration, output chan lp.CCMessage) {
@@ -140,7 +145,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.NewMetric("nfsio_"+name, m.tags, m.meta, newVal, now)
 					if err == nil {
 						msg.AddTag("stype", "filesystem")
 						msg.AddTag("stype-id", mntpoint)
@@ -149,7 +154,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.NewMetric(fmt.Sprintf("nfsio_%s_bw", name), m.tags, m.meta, rate, now)
 					if err == nil {
 						if strings.HasPrefix(name, "page") {
 							msg.AddMeta("unit", "4K_pages/s")

collectors/nfsiostatMetric.md

@@ -16,7 +16,7 @@ hugo_path: docs/reference/cc-metric-collector/collectors/nfsio.md
     "exclude_metrics": [
       "oread", "pageread"
     ],
-    "exclude_filesystems": [
+    "exclude_filesystem": [
       "/mnt"
     ],
     "use_server_as_stype": false,

collectors/numastatsMetric.go

@@ -2,6 +2,7 @@ package collectors
 
 import (
 	"bufio"
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"os"
@@ -10,8 +11,8 @@ import (
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 type NUMAStatsCollectorConfig struct {
@@ -59,6 +60,7 @@ type NUMAStatsCollectorTopolgy struct {
 
 type NUMAStatsCollector struct {
 	metricCollector
+
 	topology      []NUMAStatsCollectorTopolgy
 	config        NUMAStatsCollectorConfig
 	lastTimestamp time.Time
@@ -72,7 +74,9 @@ func (m *NUMAStatsCollector) Init(config json.RawMessage) error {
 
 	m.name = "NUMAStatsCollector"
 	m.parallel = true
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	m.meta = map[string]string{
 		"source": m.name,
 		"group":  "NUMA",
@@ -80,9 +84,10 @@ func (m *NUMAStatsCollector) Init(config json.RawMessage) error {
 
 	m.config.SendAbsoluteValues = true
 	if len(config) > 0 {
-		err := json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return fmt.Errorf("unable to unmarshal numastat configuration: %s", err.Error())
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
 
@@ -91,10 +96,10 @@ func (m *NUMAStatsCollector) Init(config json.RawMessage) error {
 	globPattern := base + "[0-9]*"
 	dirs, err := filepath.Glob(globPattern)
 	if err != nil {
-		return fmt.Errorf("unable to glob files with pattern '%s'", globPattern)
+		return fmt.Errorf("%s Init(): unable to glob files with pattern '%s'", m.name, globPattern)
 	}
 	if dirs == nil {
-		return fmt.Errorf("unable to find any files with pattern '%s'", globPattern)
+		return fmt.Errorf("%s Init(): unable to find any files with pattern '%s'", m.name, globPattern)
 	}
 	m.topology = make([]NUMAStatsCollectorTopolgy, 0, len(dirs))
 	for _, dir := range dirs {
@@ -186,7 +191,11 @@ func (m *NUMAStatsCollector) Read(interval time.Duration, output chan lp.CCMessa
 				t.previousValues[key] = value
 			}
 		}
-		file.Close()
+		if err := file.Close(); err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to close file '%s': %v", t.file, err))
+		}
 	}
 }
 

collectors/numastatsMetric.md

@@ -15,7 +15,7 @@ hugo_path: docs/reference/cc-metric-collector/collectors/numastat.md
   "numastats": {
     "send_abs_values" : true,
     "send_derived_values" : true
-}
+  }
 ```
 
 The `numastat` collector reads data from `/sys/devices/system/node/node*/numastat` and outputs a handful **memoryDomain** metrics. See: <https://www.kernel.org/doc/html/latest/admin-guide/numastat.html>

collectors/nvidiaMetric.go

@@ -12,11 +12,14 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"maps"
+	"slices"
+	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 	"github.com/NVIDIA/go-nvml/pkg/nvml"
 )
 
@@ -44,6 +47,7 @@ type NvidiaCollectorDevice struct {
 
 type NvidiaCollector struct {
 	metricCollector
+
 	config   NvidiaCollectorConfig
 	gpus     []NvidiaCollectorDevice
 	num_gpus int
@@ -64,11 +68,14 @@ func (m *NvidiaCollector) Init(config json.RawMessage) error {
 	m.config.ProcessMigDevices = false
 	m.config.UseUuidForMigDevices = false
 	m.config.UseSliceForMigDevices = false
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(strings.NewReader(string(config)))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err = d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
 	m.meta = map[string]string{
@@ -84,32 +91,28 @@ func (m *NvidiaCollector) Init(config json.RawMessage) error {
 	// Error: NVML library not found
 	// (nvml.ErrorString can not be used in this case)
 	if ret == nvml.ERROR_LIBRARY_NOT_FOUND {
-		err = fmt.Errorf("NVML library not found")
+		return fmt.Errorf("%s Init(): NVML library not found", m.name)
-		cclog.ComponentError(m.name, err.Error())
-		return err
 	}
 	if ret != nvml.SUCCESS {
 		err = errors.New(nvml.ErrorString(ret))
-		cclog.ComponentError(m.name, "Unable to initialize NVML", err.Error())
+		return fmt.Errorf("%s Init(): Unable to initialize NVML: %w", m.name, err)
-		return err
 	}
 
 	// Number of NVIDIA GPUs
 	num_gpus, ret := nvml.DeviceGetCount()
 	if ret != nvml.SUCCESS {
 		err = errors.New(nvml.ErrorString(ret))
-		cclog.ComponentError(m.name, "Unable to get device count", err.Error())
+		return fmt.Errorf("%s Init(): Unable to get device count: %w", m.name, err)
-		return err
 	}
 
 	// 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)
+		str_i := strconv.Itoa(i)
-		if _, skip := stringArrayContains(m.config.ExcludeDevices, str_i); skip {
+		if slices.Contains(m.config.ExcludeDevices, str_i) {
 			cclog.ComponentDebug(m.name, "Skipping excluded device", str_i)
 			continue
 		}
@@ -137,7 +140,7 @@ func (m *NvidiaCollector) Init(config json.RawMessage) error {
 			pciInfo.Device)
 
 		// Skip excluded devices specified by PCI ID
-		if _, skip := stringArrayContains(m.config.ExcludeDevices, pci_id); skip {
+		if slices.Contains(m.config.ExcludeDevices, pci_id) {
 			cclog.ComponentDebug(m.name, "Skipping excluded device", pci_id)
 			continue
 		}
@@ -222,18 +225,20 @@ func readMemoryInfo(device *NvidiaCollectorDevice, output chan lp.CCMessage) err
 		var total uint64
 		var used uint64
 		var reserved uint64 = 0
-		var v2 bool = false
+		v2 := false
 		meminfo, ret := nvml.DeviceGetMemoryInfo(device.device)
 		if ret != nvml.SUCCESS {
 			err := errors.New(nvml.ErrorString(ret))
 			return err
 		}
+		// Total physical device memory (in bytes)
 		total = meminfo.Total
+		// Sum of Reserved and Allocated device memory (in bytes)
 		used = meminfo.Used
 
 		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.NewMetric("nv_fb_mem_total", device.tags, device.meta, t, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MByte")
 				output <- y
@@ -242,7 +247,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.NewMetric("nv_fb_mem_used", device.tags, device.meta, f, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MByte")
 				output <- y
@@ -251,7 +256,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.NewMetric("nv_fb_mem_reserved", device.tags, device.meta, r, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MByte")
 				output <- y
@@ -270,7 +275,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.NewMetric("nv_bar1_mem_total", device.tags, device.meta, t, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MByte")
 				output <- y
@@ -278,7 +283,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.NewMetric("nv_bar1_mem_used", device.tags, device.meta, t, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MByte")
 				output <- y
@@ -312,14 +317,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.NewMetric("nv_util", device.tags, device.meta, 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.NewMetric("nv_mem_util", device.tags, device.meta, float64(util.Memory), time.Now())
 				if err == nil {
 					y.AddMeta("unit", "%")
 					output <- y
@@ -339,7 +344,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.NewMetric("nv_temp", device.tags, device.meta, float64(temp), time.Now())
 			if err == nil {
 				y.AddMeta("unit", "degC")
 				output <- y
@@ -362,7 +367,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.NewMetric("nv_fan", device.tags, device.meta, float64(fan), time.Now())
 			if err == nil {
 				y.AddMeta("unit", "%")
 				output <- y
@@ -372,27 +377,6 @@ func readFan(device *NvidiaCollectorDevice, output chan lp.CCMessage) error {
 	return nil
 }
 
-// func readFans(device *NvidiaCollectorDevice, output chan lp.CCMessage) error {
-// 	if !device.excludeMetrics["nv_fan"] {
-// 		numFans, ret := nvml.DeviceGetNumFans(device.device)
-// 		if ret == nvml.SUCCESS {
-// 			for i := 0; i < numFans; i++ {
-// 				fan, ret := nvml.DeviceGetFanSpeed_v2(device.device, i)
-// 				if ret == nvml.SUCCESS {
-// 					y, err := lp.NewMessage("nv_fan", device.tags, device.meta, map[string]interface{}{"value": float64(fan)}, time.Now())
-// 					if err == nil {
-// 						y.AddMeta("unit", "%")
-// 						y.AddTag("stype", "fan")
-// 						y.AddTag("stype-id", fmt.Sprintf("%d", i))
-// 						output <- y
-// 					}
-// 				}
-// 			}
-// 		}
-// 	}
-// 	return nil
-// }
-
 func readEccMode(device *NvidiaCollectorDevice, output chan lp.CCMessage) error {
 	if !device.excludeMetrics["nv_ecc_mode"] {
 		// Retrieves the current and pending ECC modes for the device.
@@ -403,22 +387,23 @@ func readEccMode(device *NvidiaCollectorDevice, output chan lp.CCMessage) error
 		// Changing ECC modes requires a reboot.
 		// The "pending" ECC mode refers to the target mode following the next reboot.
 		_, ecc_pend, ret := nvml.DeviceGetEccMode(device.device)
-		if ret == nvml.SUCCESS {
+		switch ret {
+		case nvml.SUCCESS:
 			var y lp.CCMessage
 			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.NewMetric("nv_ecc_mode", device.tags, device.meta, "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.NewMetric("nv_ecc_mode", device.tags, device.meta, "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.NewMetric("nv_ecc_mode", device.tags, device.meta, "UNKNOWN", time.Now())
 			}
 			if err == nil {
 				output <- y
 			}
-		} else if ret == nvml.ERROR_NOT_SUPPORTED {
+		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.NewMetric("nv_ecc_mode", device.tags, device.meta, "N/A", time.Now())
 			if err == nil {
 				output <- y
 			}
@@ -438,7 +423,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.NewMetric("nv_perf_state", device.tags, device.meta, fmt.Sprintf("P%d", int(pState)), time.Now())
 			if err == nil {
 				output <- y
 			}
@@ -464,7 +449,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.NewMetric("nv_power_usage", device.tags, device.meta, float64(power)/1000, time.Now())
 				if err == nil {
 					y.AddMeta("unit", "watts")
 					output <- y
@@ -490,7 +475,12 @@ func readEnergyConsumption(device *NvidiaCollectorDevice, output chan lp.CCMessa
 			if ret == nvml.SUCCESS {
 				if device.lastEnergyReading != 0 {
 					if !device.excludeMetrics["nv_energy"] {
-						y, err := lp.NewMetric("nv_energy", device.tags, device.meta, (energy-device.lastEnergyReading)/1000, now)
+						y, err := lp.NewMetric(
+							"nv_energy",
+							device.tags,
+							device.meta,
+							(energy-device.lastEnergyReading)/1000,
+							now)
 						if err == nil {
 							y.AddMeta("unit", "Joules")
 							output <- y
@@ -532,7 +522,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.NewMetric("nv_graphics_clock", device.tags, device.meta, float64(graphicsClock), time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MHz")
 				output <- y
@@ -543,7 +533,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.NewMetric("nv_sm_clock", device.tags, device.meta, float64(smCock), time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MHz")
 				output <- y
@@ -554,7 +544,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.NewMetric("nv_mem_clock", device.tags, device.meta, float64(memClock), time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MHz")
 				output <- y
@@ -564,7 +554,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.NewMetric("nv_video_clock", device.tags, device.meta, float64(memClock), time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MHz")
 				output <- y
@@ -589,7 +579,7 @@ func readMaxClocks(device *NvidiaCollectorDevice, output chan lp.CCMessage) erro
 	if !device.excludeMetrics["nv_max_graphics_clock"] {
 		max_gclk, ret := nvml.DeviceGetMaxClockInfo(device.device, nvml.CLOCK_GRAPHICS)
 		if ret == nvml.SUCCESS {
-			y, err := lp.NewMessage("nv_max_graphics_clock", device.tags, device.meta, map[string]interface{}{"value": float64(max_gclk)}, time.Now())
+			y, err := lp.NewMetric("nv_max_graphics_clock", device.tags, device.meta, float64(max_gclk), time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MHz")
 				output <- y
@@ -598,9 +588,9 @@ func readMaxClocks(device *NvidiaCollectorDevice, output chan lp.CCMessage) erro
 	}
 
 	if !device.excludeMetrics["nv_max_sm_clock"] {
-		maxSmClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_SM)
+		maxSmClock, ret := nvml.DeviceGetMaxClockInfo(device.device, nvml.CLOCK_SM)
 		if ret == nvml.SUCCESS {
-			y, err := lp.NewMessage("nv_max_sm_clock", device.tags, device.meta, map[string]interface{}{"value": float64(maxSmClock)}, time.Now())
+			y, err := lp.NewMetric("nv_max_sm_clock", device.tags, device.meta, float64(maxSmClock), time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MHz")
 				output <- y
@@ -609,9 +599,9 @@ func readMaxClocks(device *NvidiaCollectorDevice, output chan lp.CCMessage) erro
 	}
 
 	if !device.excludeMetrics["nv_max_mem_clock"] {
-		maxMemClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_MEM)
+		maxMemClock, ret := nvml.DeviceGetMaxClockInfo(device.device, nvml.CLOCK_MEM)
 		if ret == nvml.SUCCESS {
-			y, err := lp.NewMessage("nv_max_mem_clock", device.tags, device.meta, map[string]interface{}{"value": float64(maxMemClock)}, time.Now())
+			y, err := lp.NewMetric("nv_max_mem_clock", device.tags, device.meta, float64(maxMemClock), time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MHz")
 				output <- y
@@ -620,9 +610,9 @@ func readMaxClocks(device *NvidiaCollectorDevice, output chan lp.CCMessage) erro
 	}
 
 	if !device.excludeMetrics["nv_max_video_clock"] {
-		maxMemClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_VIDEO)
+		maxVideoClock, ret := nvml.DeviceGetMaxClockInfo(device.device, nvml.CLOCK_VIDEO)
 		if ret == nvml.SUCCESS {
-			y, err := lp.NewMessage("nv_max_video_clock", device.tags, device.meta, map[string]interface{}{"value": float64(maxMemClock)}, time.Now())
+			y, err := lp.NewMetric("nv_max_video_clock", device.tags, device.meta, float64(maxVideoClock), time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MHz")
 				output <- y
@@ -645,7 +635,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.NewMetric("nv_ecc_uncorrected_error", device.tags, device.meta, float64(ecc_db), time.Now())
 			if err == nil {
 				output <- y
 			}
@@ -654,7 +644,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.NewMetric("nv_ecc_corrected_error", device.tags, device.meta, float64(ecc_sb), time.Now())
 			if err == nil {
 				output <- y
 			}
@@ -673,7 +663,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.NewMetric("nv_power_max_limit", device.tags, device.meta, float64(pwr_limit)/1000, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "watts")
 				output <- y
@@ -700,7 +690,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.NewMetric("nv_encoder_util", device.tags, device.meta, float64(enc_util), time.Now())
 			if err == nil {
 				y.AddMeta("unit", "%")
 				output <- y
@@ -727,7 +717,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.NewMetric("nv_decoder_util", device.tags, device.meta, float64(dec_util), time.Now())
 			if err == nil {
 				y.AddMeta("unit", "%")
 				output <- y
@@ -754,33 +744,33 @@ 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.NewMetric("nv_remapped_rows_corrected", device.tags, device.meta, 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.NewMetric("nv_remapped_rows_corrected", device.tags, device.meta, float64(uncorrected), time.Now())
 				if err == nil {
 					output <- y
 				}
 			}
 			if !device.excludeMetrics["nv_remapped_rows_pending"] {
-				var p int = 0
+				p := 0
 				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.NewMetric("nv_remapped_rows_pending", device.tags, device.meta, p, time.Now())
 				if err == nil {
 					output <- y
 				}
 			}
 			if !device.excludeMetrics["nv_remapped_rows_failure"] {
-				var f int = 0
+				f := 0
 				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.NewMetric("nv_remapped_rows_failure", device.tags, device.meta, f, time.Now())
 				if err == nil {
 					output <- y
 				}
@@ -814,7 +804,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.NewMetric("nv_compute_processes", device.tags, device.meta, len(procList), time.Now())
 			if err == nil {
 				output <- y
 			}
@@ -843,7 +833,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.NewMetric("nv_graphics_processes", device.tags, device.meta, len(procList), time.Now())
 			if err == nil {
 				output <- y
 			}
@@ -873,7 +863,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.DeviceGetMPSComputeRunningProcesses(device.device)
 	// 	if ret == nvml.SUCCESS {
-	// 		y, err := lp.NewMessage("nv_mps_compute_processes", device.tags, device.meta, map[string]interface{}{"value": len(procList)}, time.Now())
+	// 		y, err := lp.NewMetric("nv_mps_compute_processes", device.tags, device.meta, len(procList), time.Now())
 	// 		if err == nil {
 	// 			output <- y
 	// 		}
@@ -901,7 +891,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.NewMetric("nv_violation_power", device.tags, device.meta, t, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "sec")
 				output <- y
@@ -913,7 +903,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.NewMetric("nv_violation_thermal", device.tags, device.meta, t, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "sec")
 				output <- y
@@ -925,7 +915,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.NewMetric("nv_violation_sync_boost", device.tags, device.meta, t, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "sec")
 				output <- y
@@ -937,7 +927,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.NewMetric("nv_violation_board_limit", device.tags, device.meta, t, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "sec")
 				output <- y
@@ -949,7 +939,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.NewMetric("nv_violation_low_util", device.tags, device.meta, t, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "sec")
 				output <- y
@@ -961,7 +951,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.NewMetric("nv_violation_reliability", device.tags, device.meta, t, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "sec")
 				output <- y
@@ -973,7 +963,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.NewMetric("nv_violation_below_app_clock", device.tags, device.meta, t, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "sec")
 				output <- y
@@ -985,7 +975,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.NewMetric("nv_violation_below_base_clock", device.tags, device.meta, t, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "sec")
 				output <- y
@@ -1008,19 +998,19 @@ 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 {
 				if !device.excludeMetrics["nv_nvlink_crc_errors"] {
 					// Data link receive data CRC error counter
 					count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_CRC_DATA)
-					aggregate_crc_errors = aggregate_crc_errors + count
+					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.NewMetric("nv_nvlink_crc_errors", device.tags, device.meta, count, time.Now())
 						if err == nil {
 							y.AddTag("stype", "nvlink")
-							y.AddTag("stype-id", fmt.Sprintf("%d", i))
+							y.AddTag("stype-id", strconv.Itoa(i))
 							output <- y
 						}
 					}
@@ -1028,12 +1018,12 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er
 				if !device.excludeMetrics["nv_nvlink_ecc_errors"] {
 					// Data link receive data ECC error counter
 					count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_ECC_DATA)
-					aggregate_ecc_errors = aggregate_ecc_errors + count
+					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.NewMetric("nv_nvlink_ecc_errors", device.tags, device.meta, count, time.Now())
 						if err == nil {
 							y.AddTag("stype", "nvlink")
-							y.AddTag("stype-id", fmt.Sprintf("%d", i))
+							y.AddTag("stype-id", strconv.Itoa(i))
 							output <- y
 						}
 					}
@@ -1041,12 +1031,12 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er
 				if !device.excludeMetrics["nv_nvlink_replay_errors"] {
 					// Data link transmit replay error counter
 					count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_REPLAY)
-					aggregate_replay_errors = aggregate_replay_errors + count
+					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.NewMetric("nv_nvlink_replay_errors", device.tags, device.meta, count, time.Now())
 						if err == nil {
 							y.AddTag("stype", "nvlink")
-							y.AddTag("stype-id", fmt.Sprintf("%d", i))
+							y.AddTag("stype-id", strconv.Itoa(i))
 							output <- y
 						}
 					}
@@ -1054,12 +1044,12 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er
 				if !device.excludeMetrics["nv_nvlink_recovery_errors"] {
 					// Data link transmit recovery error counter
 					count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_RECOVERY)
-					aggregate_recovery_errors = aggregate_recovery_errors + count
+					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.NewMetric("nv_nvlink_recovery_errors", device.tags, device.meta, count, time.Now())
 						if err == nil {
 							y.AddTag("stype", "nvlink")
-							y.AddTag("stype-id", fmt.Sprintf("%d", i))
+							y.AddTag("stype-id", strconv.Itoa(i))
 							output <- y
 						}
 					}
@@ -1067,12 +1057,12 @@ 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
 					count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_CRC_FLIT)
-					aggregate_crc_flit_errors = aggregate_crc_flit_errors + count
+					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.NewMetric("nv_nvlink_crc_flit_errors", device.tags, device.meta, count, time.Now())
 						if err == nil {
 							y.AddTag("stype", "nvlink")
-							y.AddTag("stype-id", fmt.Sprintf("%d", i))
+							y.AddTag("stype-id", strconv.Itoa(i))
 							output <- y
 						}
 					}
@@ -1084,7 +1074,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.NewMetric("nv_nvlink_crc_errors_sum", device.tags, device.meta, aggregate_crc_errors, time.Now())
 		if err == nil {
 			y.AddTag("stype", "nvlink")
 			output <- y
@@ -1092,7 +1082,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.NewMetric("nv_nvlink_ecc_errors_sum", device.tags, device.meta, aggregate_ecc_errors, time.Now())
 		if err == nil {
 			y.AddTag("stype", "nvlink")
 			output <- y
@@ -1100,7 +1090,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.NewMetric("nv_nvlink_replay_errors_sum", device.tags, device.meta, aggregate_replay_errors, time.Now())
 		if err == nil {
 			y.AddTag("stype", "nvlink")
 			output <- y
@@ -1108,7 +1098,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.NewMetric("nv_nvlink_recovery_errors_sum", device.tags, device.meta, aggregate_recovery_errors, time.Now())
 		if err == nil {
 			y.AddTag("stype", "nvlink")
 			output <- y
@@ -1116,7 +1106,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.NewMetric("nv_nvlink_crc_flit_errors_sum", device.tags, device.meta, aggregate_crc_flit_errors, time.Now())
 		if err == nil {
 			y.AddTag("stype", "nvlink")
 			output <- y
@@ -1233,7 +1223,7 @@ func (m *NvidiaCollector) Read(interval time.Duration, output chan lp.CCMessage)
 	}
 
 	// Actual read loop over all attached Nvidia GPUs
-	for i := 0; i < m.num_gpus; i++ {
+	for i := range m.num_gpus {
 
 		readAll(&m.gpus[i], output)
 
@@ -1256,7 +1246,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
@@ -1273,9 +1263,7 @@ func (m *NvidiaCollector) Read(interval time.Duration, output chan lp.CCMessage)
 					meta:           map[string]string{},
 					excludeMetrics: excludeMetrics,
 				}
-				for k, v := range m.gpus[i].tags {
+				maps.Copy(migDevice.tags, m.gpus[i].tags)
-					migDevice.tags[k] = v
-				}
 				migDevice.tags["stype"] = "mig"
 				if m.config.UseUuidForMigDevices {
 					uuid, ret := nvml.DeviceGetUUID(mdev)
@@ -1289,19 +1277,17 @@ func (m *NvidiaCollector) Read(interval time.Duration, output chan lp.CCMessage)
 					if ret == nvml.SUCCESS {
 						mname, ret := nvml.DeviceGetName(mdev)
 						if ret == nvml.SUCCESS {
-							x := strings.Replace(mname, name, "", -1)
+							x := strings.ReplaceAll(mname, name, "")
-							x = strings.Replace(x, "MIG", "", -1)
+							x = strings.ReplaceAll(x, "MIG", "")
 							x = strings.TrimSpace(x)
 							migDevice.tags["stype-id"] = x
 						}
 					}
 				}
 				if _, ok := migDevice.tags["stype-id"]; !ok {
-					migDevice.tags["stype-id"] = fmt.Sprintf("%d", j)
+					migDevice.tags["stype-id"] = strconv.Itoa(j)
-				}
-				for k, v := range m.gpus[i].meta {
-					migDevice.meta[k] = v
 				}
+				maps.Copy(migDevice.meta, m.gpus[i].meta)
 				if _, ok := migDevice.meta["uuid"]; ok && !m.config.UseUuidForMigDevices {
 					uuid, ret := nvml.DeviceGetUUID(mdev)
 					if ret == nvml.SUCCESS {
@@ -1317,7 +1303,9 @@ func (m *NvidiaCollector) Read(interval time.Duration, output chan lp.CCMessage)
 
 func (m *NvidiaCollector) Close() {
 	if m.init {
-		nvml.Shutdown()
+		if ret := nvml.Shutdown(); ret != nvml.SUCCESS {
+			cclog.ComponentError(m.name, "nvml.Shutdown() not successful")
+		}
 		m.init = false
 	}
 }

collectors/raplMetric.go

@@ -8,6 +8,7 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"os"
@@ -16,8 +17,8 @@ import (
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 // running average power limit (RAPL) monitoring attributes for a zone
@@ -34,6 +35,7 @@ type RAPLZoneInfo struct {
 
 type RAPLCollector struct {
 	metricCollector
+
 	config struct {
 		// Exclude IDs for RAPL zones, e.g.
 		// * 0 for zone 0
@@ -48,15 +50,15 @@ type RAPLCollector struct {
 
 // Init initializes the running average power limit (RAPL) collector
 func (m *RAPLCollector) Init(config json.RawMessage) error {
-
 	// Check if already initialized
 	if m.init {
 		return nil
 	}
 
-	var err error = nil
 	m.name = "RAPLCollector"
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	m.parallel = true
 	m.meta = map[string]string{
 		"source": m.name,
@@ -66,10 +68,10 @@ func (m *RAPLCollector) Init(config json.RawMessage) error {
 
 	// Read in the JSON configuration
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			cclog.ComponentError(m.name, "Error reading config:", err.Error())
+		if err := d.Decode(&m.config); err != nil {
-			return err
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
 
@@ -89,19 +91,20 @@ func (m *RAPLCollector) Init(config json.RawMessage) error {
 
 	// readZoneInfo reads RAPL monitoring attributes for a zone given by zonePath
 	// See: https://www.kernel.org/doc/html/latest/power/powercap/powercap.html#monitoring-attributes
-	readZoneInfo := func(zonePath string) (z struct {
+	readZoneInfo := func(zonePath string) (
-		name            string    // zones name e.g. psys, dram, core, uncore, package-0
+		z struct {
-		energyFilepath  string    // path to a file containing the zones current energy counter in micro joules
+			name            string    // zones name e.g. psys, dram, core, uncore, package-0
-		energy          int64     // current reading of the energy counter in micro joules
+			energyFilepath  string    // path to a file containing the zones current energy counter in micro joules
-		energyTimestamp time.Time // timestamp when energy counter was read
+			energy          int64     // current reading of the energy counter in micro joules
-		maxEnergyRange  int64     // Range of the above energy counter in micro-joules
+			energyTimestamp time.Time // timestamp when energy counter was read
-		ok              bool      // Are all information available?
+			maxEnergyRange  int64     // Range of the above energy counter in micro-joules
-	}) {
+			ok              bool      // Are all information available?
+		},
+	) {
 		// zones name e.g. psys, dram, core, uncore, package-0
 		foundName := false
-		if v, err :=
+		if v, err := os.ReadFile(
-			os.ReadFile(
+			filepath.Join(zonePath, "name")); err == nil {
-				filepath.Join(zonePath, "name")); err == nil {
 			foundName = true
 			z.name = strings.TrimSpace(string(v))
 		}
@@ -122,9 +125,8 @@ func (m *RAPLCollector) Init(config json.RawMessage) error {
 
 		// Range of the above energy counter in micro-joules
 		foundMaxEnergyRange := false
-		if v, err :=
+		if v, err := os.ReadFile(
-			os.ReadFile(
+			filepath.Join(zonePath, "max_energy_range_uj")); err == nil {
-				filepath.Join(zonePath, "max_energy_range_uj")); err == nil {
 			if i, err := strconv.ParseInt(strings.TrimSpace(string(v)), 10, 64); err == nil {
 				foundMaxEnergyRange = true
 				z.maxEnergyRange = i
@@ -156,19 +158,18 @@ func (m *RAPLCollector) Init(config json.RawMessage) error {
 			!isNameExcluded[z.name] {
 
 			// Add RAPL monitoring attributes for a zone
-			m.RAPLZoneInfo =
+			m.RAPLZoneInfo = append(
-				append(
+				m.RAPLZoneInfo,
-					m.RAPLZoneInfo,
+				RAPLZoneInfo{
-					RAPLZoneInfo{
+					tags: map[string]string{
-						tags: map[string]string{
+						"id":        zoneID,
-							"id":        zoneID,
+						"zone_name": z.name,
-							"zone_name": z.name,
+					},
-						},
+					energyFilepath:  z.energyFilepath,
-						energyFilepath:  z.energyFilepath,
+					energy:          z.energy,
-						energy:          z.energy,
+					energyTimestamp: z.energyTimestamp,
-						energyTimestamp: z.energyTimestamp,
+					maxEnergyRange:  z.maxEnergyRange,
-						maxEnergyRange:  z.maxEnergyRange,
+				})
-					})
 		}
 
 		// find all sub zones for the given zone
@@ -185,27 +186,25 @@ func (m *RAPLCollector) Init(config json.RawMessage) error {
 				sz.ok &&
 				!isIDExcluded[zoneID+":"+subZoneID] &&
 				!isNameExcluded[sz.name] {
-				m.RAPLZoneInfo =
+				m.RAPLZoneInfo = append(
-					append(
+					m.RAPLZoneInfo,
-						m.RAPLZoneInfo,
+					RAPLZoneInfo{
-						RAPLZoneInfo{
+						tags: map[string]string{
-							tags: map[string]string{
+							"id":            zoneID + ":" + subZoneID,
-								"id":            zoneID + ":" + subZoneID,
+							"zone_name":     z.name,
-								"zone_name":     z.name,
+							"sub_zone_name": sz.name,
-								"sub_zone_name": sz.name,
+						},
-							},
+						energyFilepath:  sz.energyFilepath,
-							energyFilepath:  sz.energyFilepath,
+						energy:          sz.energy,
-							energy:          sz.energy,
+						energyTimestamp: sz.energyTimestamp,
-							energyTimestamp: sz.energyTimestamp,
+						maxEnergyRange:  sz.maxEnergyRange,
-							maxEnergyRange:  sz.maxEnergyRange,
+					})
-						})
 			}
 		}
 	}
 
 	if m.RAPLZoneInfo == nil {
 		return fmt.Errorf("no running average power limit (RAPL) device found in %s", controlTypePath)
-
 	}
 
 	// Initialized
@@ -222,7 +221,6 @@ func (m *RAPLCollector) Init(config json.RawMessage) error {
 // Read reads running average power limit (RAPL) monitoring attributes for all initialized zones
 // See: https://www.kernel.org/doc/html/latest/power/powercap/powercap.html#monitoring-attributes
 func (m *RAPLCollector) Read(interval time.Duration, output chan lp.CCMessage) {
-
 	for i := range m.RAPLZoneInfo {
 		p := &m.RAPLZoneInfo[i]
 
@@ -244,12 +242,7 @@ func (m *RAPLCollector) Read(interval time.Duration, output chan lp.CCMessage) {
 				timeDiff := energyTimestamp.Sub(p.energyTimestamp)
 				averagePower := float64(energyDiff) / float64(timeDiff.Microseconds())
 
-				y, err := lp.NewMessage(
+				y, err := lp.NewMetric("rapl_average_power", p.tags, m.meta, averagePower, energyTimestamp)
-					"rapl_average_power",
-					p.tags,
-					m.meta,
-					map[string]interface{}{"value": averagePower},
-					energyTimestamp)
 				if err == nil {
 					output <- y
 				}

collectors/rocmsmiMetric.go

@@ -8,13 +8,15 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
-	"errors"
 	"fmt"
+	"slices"
+	"strconv"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 	"github.com/ClusterCockpit/go-rocm-smi/pkg/rocm_smi"
 )
 
@@ -36,6 +38,7 @@ type RocmSmiCollectorDevice struct {
 
 type RocmSmiCollector struct {
 	metricCollector
+
 	config  RocmSmiCollectorConfig // the configuration structure
 	devices []RocmSmiCollectorDevice
 }
@@ -48,73 +51,46 @@ type RocmSmiCollector struct {
 // Called once by the collector manager
 // All tags, meta data tags and metrics that do not change over the runtime should be set here
 func (m *RocmSmiCollector) Init(config json.RawMessage) error {
-	var err error = nil
 	// Always set the name early in Init() to use it in cclog.Component* functions
 	m.name = "RocmSmiCollector"
 	// This is for later use, also call it early
-	m.setup()
+	if err := m.setup(); err != nil {
-	// Define meta information sent with each metric
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
-	// (Can also be dynamic or this is the basic set with extension through AddMeta())
+	}
-	//m.meta = map[string]string{"source": m.name, "group": "AMD"}
-	// Define tags sent with each metric
-	// The 'type' tag is always needed, it defines the granulatity of the metric
-	// node -> whole system
-	// socket -> CPU socket (requires socket ID as 'type-id' tag)
-	// cpu -> single CPU hardware thread (requires cpu ID as 'type-id' tag)
-	//m.tags = map[string]string{"type": "node"}
 	// Read in the JSON configuration
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			cclog.ComponentError(m.name, "Error reading config:", err.Error())
+		if err := d.Decode(&m.config); err != nil {
-			return err
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
 
 	ret := rocm_smi.Init()
 	if ret != rocm_smi.STATUS_SUCCESS {
-		err = errors.New("failed to initialize ROCm SMI library")
+		return fmt.Errorf("%s Init(): failed to initialize ROCm SMI library", m.name)
-		cclog.ComponentError(m.name, err.Error())
-		return err
 	}
 
 	numDevs, ret := rocm_smi.NumMonitorDevices()
 	if ret != rocm_smi.STATUS_SUCCESS {
-		err = errors.New("failed to get number of GPUs from ROCm SMI library")
+		return fmt.Errorf("%s Init(): failed to get number of GPUs from ROCm SMI library", m.name)
-		cclog.ComponentError(m.name, err.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)
+		str_i := strconv.Itoa(i)
-		if exclDev(str_i) {
+		if slices.Contains(m.config.ExcludeDevices, str_i) {
 			continue
 		}
 		device, ret := rocm_smi.DeviceGetHandleByIndex(i)
 		if ret != rocm_smi.STATUS_SUCCESS {
-			err = fmt.Errorf("failed to get handle for GPU %d", i)
+			return fmt.Errorf("%s Init(): failed to get get handle for GPU %d", m.name, i)
-			cclog.ComponentError(m.name, err.Error())
-			return err
 		}
 
 		pciInfo, ret := rocm_smi.DeviceGetPciInfo(device)
 		if ret != rocm_smi.STATUS_SUCCESS {
-			err = fmt.Errorf("failed to get PCI information for GPU %d", i)
+			return fmt.Errorf("%s Init(): failed to get PCI information for GPU %d", m.name, i)
-			cclog.ComponentError(m.name, err.Error())
-			return err
 		}
 
 		pciId := fmt.Sprintf(
@@ -124,7 +100,7 @@ func (m *RocmSmiCollector) Init(config json.RawMessage) error {
 			pciInfo.Device,
 			pciInfo.Function)
 
-		if exclDev(pciId) {
+		if slices.Contains(m.config.ExcludeDevices, pciId) {
 			continue
 		}
 
@@ -164,7 +140,7 @@ func (m *RocmSmiCollector) Init(config json.RawMessage) error {
 
 	// Set this flag only if everything is initialized properly, all required files exist, ...
 	m.init = true
-	return err
+	return nil
 }
 
 // Read collects all metrics belonging to the sample collector
@@ -182,136 +158,117 @@ 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)
+			if y, err := lp.NewMetric("rocm_gfx_util", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_umc_util", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_mm_util", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_avg_power", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_temp_mem", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_temp_hotspot", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_temp_edge", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_temp_vrgfx", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_temp_vrsoc", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_temp_vrmem", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_gfx_clock", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_soc_clock", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_u_clock", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_v0_clock", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_v1_clock", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_d0_clock", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+			if y, err := lp.NewMetric("rocm_d1_clock", dev.tags, dev.meta, value, timestamp); err == nil {
-			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)
+				if y, err := lp.NewMetric("rocm_temp_hbm", dev.tags, dev.meta, value, timestamp); err == nil {
-				if err == nil {
 					y.AddTag("stype", "device")
-					y.AddTag("stype-id", fmt.Sprintf("%d", i))
+					y.AddTag("stype-id", strconv.Itoa(i))
 					output <- y
 				}
 			}
 		}
 	}
-
 }
 
 // Close metric collector: close network connection, close files, close libraries, ...

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
   }
 ```
 

collectors/sampleMetric.go

@@ -8,11 +8,12 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
+	"fmt"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
 )
 
 // These are the fields we read from the JSON configuration
@@ -24,6 +25,7 @@ type SampleCollectorConfig struct {
 // defined by metricCollector (name, init, ...)
 type SampleCollector struct {
 	metricCollector
+
 	config SampleCollectorConfig // the configuration structure
 	meta   map[string]string     // default meta information
 	tags   map[string]string     // default tags
@@ -41,14 +43,19 @@ func (m *SampleCollector) Init(config json.RawMessage) error {
 	// Always set the name early in Init() to use it in cclog.Component* functions
 	m.name = "SampleCollector"
 	// This is for later use, also call it early
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	// Tell whether the collector should be run in parallel with others (reading files, ...)
 	// or it should be run serially, mostly for collectors actually doing measurements
 	// because they should not measure the execution of the other collectors
 	m.parallel = true
 	// Define meta information sent with each metric
 	// (Can also be dynamic or this is the basic set with extension through AddMeta())
-	m.meta = map[string]string{"source": m.name, "group": "SAMPLE"}
+	m.meta = map[string]string{
+		"source": m.name,
+		"group":  "SAMPLE",
+	}
 	// Define tags sent with each metric
 	// The 'type' tag is always needed, it defines the granularity of the metric
 	// node -> whole system
@@ -59,13 +66,15 @@ func (m *SampleCollector) Init(config json.RawMessage) error {
 	// core -> single CPU core that may consist of multiple hardware threads (SMT) (requires core ID as 'type-id' tag)
 	// hwthtread -> single CPU hardware thread (requires hardware thread ID as 'type-id' tag)
 	// accelerator -> A accelerator device like GPU or FPGA (requires an accelerator ID as 'type-id' tag)
-	m.tags = map[string]string{"type": "node"}
+	m.tags = map[string]string{
+		"type": "node",
+	}
 	// Read in the JSON configuration
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			cclog.ComponentError(m.name, "Error reading config:", err.Error())
+		if err := d.Decode(&m.config); err != nil {
-			return err
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
 
@@ -92,12 +101,11 @@ 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.NewMetric("sample_metric", m.tags, m.meta, value, timestamp)
 	if err == nil {
 		// Send it to output channel
 		output <- y
 	}
-
 }
 
 // Close metric collector: close network connection, close files, close libraries, ...

collectors/sampleTimerMetric.go

@@ -8,12 +8,14 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
+	"fmt"
 	"sync"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 // These are the fields we read from the JSON configuration
@@ -25,6 +27,7 @@ type SampleTimerCollectorConfig struct {
 // defined by metricCollector (name, init, ...)
 type SampleTimerCollector struct {
 	metricCollector
+
 	wg       sync.WaitGroup             // sync group for management
 	done     chan bool                  // channel for management
 	meta     map[string]string          // default meta information
@@ -36,33 +39,39 @@ type SampleTimerCollector struct {
 }
 
 func (m *SampleTimerCollector) Init(name string, config json.RawMessage) error {
-	var err error = nil
+	var err error
 	// Always set the name early in Init() to use it in cclog.Component* functions
 	m.name = "SampleTimerCollector"
 	// This is for later use, also call it early
-	m.setup()
+	if err = m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	// Define meta information sent with each metric
 	// (Can also be dynamic or this is the basic set with extension through AddMeta())
-	m.meta = map[string]string{"source": m.name, "group": "SAMPLE"}
+	m.meta = map[string]string{
+		"source": m.name,
+		"group":  "SAMPLE",
+	}
 	// Define tags sent with each metric
 	// The 'type' tag is always needed, it defines the granularity of the metric
 	// node -> whole system
 	// socket -> CPU socket (requires socket ID as 'type-id' tag)
 	// cpu -> single CPU hardware thread (requires cpu ID as 'type-id' tag)
-	m.tags = map[string]string{"type": "node"}
+	m.tags = map[string]string{
+		"type": "node",
+	}
 	// Read in the JSON configuration
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			cclog.ComponentError(m.name, "Error reading config:", err.Error())
+		if err := d.Decode(&m.config); err != nil {
-			return err
+			return fmt.Errorf("%s Init(): error decoding JSON config: %w", m.name, err)
 		}
 	}
 	// Parse the read interval duration
 	m.interval, err = time.ParseDuration(m.config.Interval)
 	if err != nil {
-		cclog.ComponentError(m.name, "Error parsing interval:", err.Error())
+		return fmt.Errorf("%s Init(): error parsing interval: %w", m.name, err)
-		return err
 	}
 
 	// Storage for output channel
@@ -73,13 +82,11 @@ func (m *SampleTimerCollector) Init(name string, config json.RawMessage) error {
 	m.ticker = time.NewTicker(m.interval)
 
 	// Start the timer loop with return functionality by sending 'true' to the done channel
-	m.wg.Add(1)
+	m.wg.Go(func() {
-	go func() {
 		select {
 		case <-m.done:
 			// Exit the timer loop
 			cclog.ComponentDebug(m.name, "Closing...")
-			m.wg.Done()
 			return
 		case timestamp := <-m.ticker.C:
 			// This is executed every timer tick but we have to wait until the first
@@ -88,7 +95,7 @@ func (m *SampleTimerCollector) Init(name string, config json.RawMessage) error {
 				m.ReadMetrics(timestamp)
 			}
 		}
-	}()
+	})
 
 	// Set this flag only if everything is initialized properly, all required files exist, ...
 	m.init = true
@@ -107,7 +114,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.NewMetric("sample_metric", m.tags, m.meta, value, timestamp)
 	if err == nil && m.output != nil {
 		// Send it to output channel if we have a valid channel
 		m.output <- y

collectors/schedstatMetric.go

@@ -9,16 +9,16 @@ package collectors
 
 import (
 	"bufio"
+	"bytes"
 	"encoding/json"
 	"fmt"
-	"math"
 	"os"
 	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 const SCHEDSTATFILE = `/proc/schedstat`
@@ -32,6 +32,7 @@ type SchedstatCollectorConfig struct {
 // defined by metricCollector (name, init, ...)
 type SchedstatCollector struct {
 	metricCollector
+
 	config        SchedstatCollectorConfig     // the configuration structure
 	lastTimestamp time.Time                    // Store time stamp of last tick to derive values
 	meta          map[string]string            // default meta information
@@ -47,37 +48,39 @@ type SchedstatCollector struct {
 // Called once by the collector manager
 // All tags, meta data tags and metrics that do not change over the runtime should be set here
 func (m *SchedstatCollector) Init(config json.RawMessage) error {
-	var err error = nil
 	// Always set the name early in Init() to use it in cclog.Component* functions
 	m.name = "SchedstatCollector"
 	// This is for later use, also call it early
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	// Tell whether the collector should be run in parallel with others (reading files, ...)
-	// or it should be run serially, mostly for collectors acutally doing measurements
+	// or it should be run serially, mostly for collectors actually doing measurements
 	// because they should not measure the execution of the other collectors
 	m.parallel = true
 	// Define meta information sent with each metric
 	// (Can also be dynamic or this is the basic set with extension through AddMeta())
-	m.meta = map[string]string{"source": m.name, "group": "SCHEDSTAT"}
+	m.meta = map[string]string{
+		"source": m.name,
+		"group":  "SCHEDSTAT",
+	}
 
 	// Read in the JSON configuration
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			cclog.ComponentError(m.name, "Error reading config:", err.Error())
+		if err := d.Decode(&m.config); err != nil {
-			return err
+			return fmt.Errorf("%s Init(): failed to decode JSON config: %w", m.name, err)
 		}
 	}
 
 	// Check input file
-	file, err := os.Open(string(SCHEDSTATFILE))
+	file, err := os.Open(SCHEDSTATFILE)
 	if err != nil {
-		cclog.ComponentError(m.name, err.Error())
+		return fmt.Errorf("%s Init(): Failed opening scheduler statistics file \"%s\": %w", m.name, SCHEDSTATFILE, err)
 	}
-	defer file.Close()
 
 	// Pre-generate tags for all CPUs
-	num_cpus := 0
 	m.cputags = make(map[string]map[string]string)
 	m.olddata = make(map[string]map[string]int64)
 	scanner := bufio.NewScanner(file)
@@ -89,11 +92,19 @@ func (m *SchedstatCollector) Init(config json.RawMessage) error {
 			cpu, _ := strconv.Atoi(cpustr)
 			running, _ := strconv.ParseInt(linefields[7], 10, 64)
 			waiting, _ := strconv.ParseInt(linefields[8], 10, 64)
-			m.cputags[linefields[0]] = map[string]string{"type": "hwthread", "type-id": fmt.Sprintf("%d", cpu)}
+			m.cputags[linefields[0]] = map[string]string{
-			m.olddata[linefields[0]] = map[string]int64{"running": running, "waiting": waiting}
+				"type":    "hwthread",
-			num_cpus++
+				"type-id": strconv.Itoa(cpu),
+			}
+			m.olddata[linefields[0]] = map[string]int64{
+				"running": running,
+				"waiting": waiting,
+			}
 		}
 	}
+	if err := file.Close(); err != nil {
+		return fmt.Errorf("%s Init(): Failed closing scheduler statistics file \"%s\": %w", m.name, SCHEDSTATFILE, err)
+	}
 
 	// Save current timestamp
 	m.lastTimestamp = time.Now()
@@ -109,14 +120,14 @@ func (m *SchedstatCollector) ParseProcLine(linefields []string, tags map[string]
 	diff_running := running - m.olddata[linefields[0]]["running"]
 	diff_waiting := waiting - m.olddata[linefields[0]]["waiting"]
 
-	var l_running float64 = float64(diff_running) / tsdelta.Seconds() / (math.Pow(1000, 3))
+	l_running := float64(diff_running) / tsdelta.Seconds() / 1000_000_000
-	var l_waiting float64 = float64(diff_waiting) / tsdelta.Seconds() / (math.Pow(1000, 3))
+	l_waiting := float64(diff_waiting) / tsdelta.Seconds() / 1000_000_000
 
 	m.olddata[linefields[0]]["running"] = running
 	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.NewMetric("cpu_load_core", tags, m.meta, value, now)
 	if err == nil {
 		// Send it to output channel
 		output <- y
@@ -130,15 +141,23 @@ func (m *SchedstatCollector) Read(interval time.Duration, output chan lp.CCMessa
 		return
 	}
 
-	//timestamps
+	// timestamps
 	now := time.Now()
 	tsdelta := now.Sub(m.lastTimestamp)
 
-	file, err := os.Open(string(SCHEDSTATFILE))
+	file, err := os.Open(SCHEDSTATFILE)
 	if err != nil {
-		cclog.ComponentError(m.name, err.Error())
+		cclog.ComponentError(
+			m.name,
+			fmt.Sprintf("Read(): Failed to open file '%s': %v", SCHEDSTATFILE, err))
 	}
-	defer file.Close()
+	defer func() {
+		if err := file.Close(); err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to close file '%s': %v", SCHEDSTATFILE, err))
+		}
+	}()
 
 	scanner := bufio.NewScanner(file)
 	for scanner.Scan() {
@@ -150,7 +169,6 @@ func (m *SchedstatCollector) Read(interval time.Duration, output chan lp.CCMessa
 	}
 
 	m.lastTimestamp = now
-
 }
 
 // Close metric collector: close network connection, close files, close libraries, ...

collectors/selfMetric.go

@@ -8,13 +8,14 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
+	"fmt"
 	"runtime"
 	"syscall"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
 )
 
 type SelfCollectorConfig struct {
@@ -26,6 +27,7 @@ type SelfCollectorConfig struct {
 
 type SelfCollector struct {
 	metricCollector
+
 	config SelfCollectorConfig // the configuration structure
 	meta   map[string]string   // default meta information
 	tags   map[string]string   // default tags
@@ -34,15 +36,22 @@ type SelfCollector struct {
 func (m *SelfCollector) Init(config json.RawMessage) error {
 	var err error = nil
 	m.name = "SelfCollector"
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	m.parallel = true
-	m.meta = map[string]string{"source": m.name, "group": "Self"}
+	m.meta = map[string]string{
-	m.tags = map[string]string{"type": "node"}
+		"source": m.name,
+		"group":  "Self",
+	}
+	m.tags = map[string]string{
+		"type": "node",
+	}
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			cclog.ComponentError(m.name, "Error reading config:", err.Error())
+		if err := d.Decode(&m.config); err != nil {
-			return err
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
 	m.init = true
@@ -56,49 +65,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.NewMetric("total_alloc", m.tags, m.meta, 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.NewMetric("heap_alloc", m.tags, m.meta, 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.NewMetric("heap_sys", m.tags, m.meta, 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.NewMetric("heap_idle", m.tags, m.meta, 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.NewMetric("heap_inuse", m.tags, m.meta, 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.NewMetric("heap_released", m.tags, m.meta, 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.NewMetric("heap_objects", m.tags, m.meta, 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.NewMetric("num_goroutines", m.tags, m.meta, 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.NewMetric("num_cgo_calls", m.tags, m.meta, runtime.NumCgoCall(), timestamp)
 		if err == nil {
 			output <- y
 		}
@@ -109,35 +118,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.NewMetric("rusage_user_time", m.tags, m.meta, 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.NewMetric("rusage_system_time", m.tags, m.meta, 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.NewMetric("rusage_vol_ctx_switch", m.tags, m.meta, 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.NewMetric("rusage_invol_ctx_switch", m.tags, m.meta, 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.NewMetric("rusage_signals", m.tags, m.meta, 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.NewMetric("rusage_major_pgfaults", m.tags, m.meta, 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.NewMetric("rusage_minor_pgfaults", m.tags, m.meta, rusage.Minflt, timestamp)
 			if err == nil {
 				output <- y
 			}

collectors/slurmCgroupMetric.go

@@ -7,12 +7,13 @@ import (
 	"os/exec"
 	"os/user"
 	"path/filepath"
+	"regexp"
 	"strconv"
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 type SlurmJobData struct {
@@ -32,6 +33,7 @@ type SlurmCgroupsConfig struct {
 
 type SlurmCgroupCollector struct {
 	metricCollector
+
 	config         SlurmCgroupsConfig
 	meta           map[string]string
 	tags           map[string]string
@@ -44,14 +46,44 @@ type SlurmCgroupCollector struct {
 
 const defaultCgroupBase = "/sys/fs/cgroup/system.slice/slurmstepd.scope"
 
+var (
+	// Slurm cgroup v2 directory layout:
+	// - Slurm <= 25.11: job_<numeric job id>
+	// - Slurm >= 26.05: SLUID, encoded as "s" + 13 Crockford Base32 characters
+	jobIDDirRE = regexp.MustCompile(`^job_[0-9]+$`)
+	sluidDirRE = regexp.MustCompile(`(?i)^s[0-9A-HJKMNP-TV-Z]{13}$`)
+)
+
+func (m *SlurmCgroupCollector) findSlurmJobDirs() ([]string, error) {
+	entries, err := os.ReadDir(m.cgroupBase)
+	if err != nil {
+		return nil, err
+	}
+
+	jobDirs := make([]string, 0)
+
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+
+		name := entry.Name()
+
+		if jobIDDirRE.MatchString(name) || sluidDirRE.MatchString(name) {
+			jobDirs = append(jobDirs, filepath.Join(m.cgroupBase, name))
+		}
+	}
+
+	return jobDirs, nil
+}
+
 func ParseCPUs(cpuset string) ([]int, error) {
 	var result []int
 	if cpuset == "" {
 		return result, nil
 	}
 
-	ranges := strings.Split(cpuset, ",")
+	for r := range strings.SplitSeq(cpuset, ",") {
-	for _, r := range ranges {
 		if strings.Contains(r, "-") {
 			parts := strings.Split(r, "-")
 			if len(parts) != 2 {
@@ -80,9 +112,10 @@ func ParseCPUs(cpuset string) ([]int, error) {
 }
 
 func GetAllCPUs() ([]int, error) {
-	data, err := os.ReadFile("/sys/devices/system/cpu/online")
+	cpuOnline := "/sys/devices/system/cpu/online"
+	data, err := os.ReadFile(cpuOnline)
 	if err != nil {
-		return nil, fmt.Errorf("failed to read /sys/devices/system/cpu/online: %v", err)
+		return nil, fmt.Errorf("failed to read file \"%s\": %w", cpuOnline, err)
 	}
 	return ParseCPUs(strings.TrimSpace(string(data)))
 }
@@ -103,18 +136,25 @@ func (m *SlurmCgroupCollector) readFile(path string) ([]byte, error) {
 func (m *SlurmCgroupCollector) Init(config json.RawMessage) error {
 	var err error
 	m.name = "SlurmCgroupCollector"
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	m.parallel = true
-	m.meta = map[string]string{"source": m.name, "group": "SLURM"}
+	m.meta = map[string]string{
-	m.tags = map[string]string{"type": "hwthread"}
+		"source": m.name,
+		"group":  "SLURM",
+	}
+	m.tags = map[string]string{
+		"type": "hwthread",
+	}
 	m.cpuUsed = make(map[int]bool)
 	m.cgroupBase = defaultCgroupBase
 
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(strings.NewReader(string(config)))
-		if err != nil {
+		d.DisallowUnknownFields()
-			cclog.ComponentError(m.name, "Error reading config:", err.Error())
+		if err = d.Decode(&m.config); err != nil {
-			return err
+			return fmt.Errorf("%s Init(): Error reading JSON config: %w", m.name, err)
 		}
 		m.excludeMetrics = make(map[string]struct{})
 		for _, metric := range m.config.ExcludeMetrics {
@@ -129,19 +169,16 @@ func (m *SlurmCgroupCollector) Init(config json.RawMessage) error {
 	if !m.useSudo {
 		user, err := user.Current()
 		if err != nil {
-			cclog.ComponentError(m.name, "Failed to get current user:", err.Error())
+			return fmt.Errorf("%s Init(): Failed to get current user: %w", m.name, err)
-			return err
 		}
 		if user.Uid != "0" {
-			cclog.ComponentError(m.name, "Reading cgroup files requires root privileges (or enable use_sudo in config)")
+			return fmt.Errorf("%s Init(): Reading cgroup files requires root privileges (or enable use_sudo in config)", m.name)
-			return fmt.Errorf("not root")
 		}
 	}
 
 	m.allCPUs, err = GetAllCPUs()
 	if err != nil {
-		cclog.ComponentError(m.name, "Error reading online CPUs:", err.Error())
+		return fmt.Errorf("%s Init(): Error reading online CPUs: %w", m.name, err)
-		return err
 	}
 
 	m.init = true
@@ -158,7 +195,9 @@ func (m *SlurmCgroupCollector) ReadJobData(jobdir string) (SlurmJobData, error)
 		CpuSet:           []int{},
 	}
 
-	cg := func(f string) string { return filepath.Join(m.cgroupBase, jobdir, f) }
+	cg := func(f string) string {
+		return filepath.Join(m.cgroupBase, jobdir, f)
+	}
 
 	memUsage, err := m.readFile(cg("memory.current"))
 	if err == nil {
@@ -207,8 +246,8 @@ func (m *SlurmCgroupCollector) ReadJobData(jobdir string) (SlurmJobData, error)
 			}
 		}
 		if usageUsec > 0 {
-			jobdata.CpuUsageUser = (userUsec * 100 / usageUsec)
+			jobdata.CpuUsageUser = (userUsec * 100.0 / usageUsec)
-			jobdata.CpuUsageSys = (systemUsec * 100 / usageUsec)
+			jobdata.CpuUsageSys = (systemUsec * 100.0 / usageUsec)
 		}
 	}
 
@@ -230,10 +269,9 @@ func (m *SlurmCgroupCollector) Read(interval time.Duration, output chan lp.CCMes
 		delete(m.cpuUsed, k)
 	}
 
-	globPattern := filepath.Join(m.cgroupBase, "job_*")
+	jobDirs, err := m.findSlurmJobDirs()
-	jobDirs, err := filepath.Glob(globPattern)
 	if err != nil {
-		cclog.ComponentError(m.name, "Error globbing job directories:", err.Error())
+		cclog.ComponentError(m.name, "Error reading job directories:", err.Error())
 		return
 	}
 
@@ -251,12 +289,19 @@ func (m *SlurmCgroupCollector) Read(interval time.Duration, output chan lp.CCMes
 			for _, cpu := range jobdata.CpuSet {
 				coreTags := map[string]string{
 					"type":    "hwthread",
-					"type-id": fmt.Sprintf("%d", cpu),
+					"type-id": strconv.Itoa(cpu),
 				}
 
 				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
 					}
@@ -264,7 +309,14 @@ 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
 					}
@@ -272,7 +324,14 @@ 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
 					}
@@ -280,7 +339,14 @@ 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
 					}
@@ -288,7 +354,14 @@ 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
 					}
@@ -303,39 +376,60 @@ func (m *SlurmCgroupCollector) Read(interval time.Duration, output chan lp.CCMes
 		if !m.cpuUsed[cpu] {
 			coreTags := map[string]string{
 				"type":    "hwthread",
-				"type-id": fmt.Sprintf("%d", cpu),
+				"type-id": strconv.Itoa(cpu),
 			}
 
 			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
 				}

collectors/smartmonMetric.go

@@ -0,0 +1,360 @@
+package collectors
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"slices"
+	"time"
+
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
+)
+
+type SmartMonCollectorConfig struct {
+	UseSudo        bool     `json:"use_sudo,omitempty"`
+	ExcludeDevices []string `json:"exclude_devices,omitempty"`
+	ExcludeMetrics []string `json:"excludeMetrics,omitempty"`
+	Devices        []struct {
+		Name string `json:"name"`
+		Type string `json:"type"`
+	} `json:"devices,omitempty"`
+}
+
+type deviceT struct {
+	Name         string `json:"name"`
+	Type         string `json:"type"`
+	queryCommand []string
+}
+
+type SmartMonCollector struct {
+	metricCollector
+	config        SmartMonCollectorConfig // the configuration structure
+	meta          map[string]string       // default meta information
+	tags          map[string]string       // default tags
+	devices       []deviceT               // smartmon devices
+	sudoCmd       string                  // Full path to 'sudo' command
+	smartCtlCmd   string                  // Full path to 'smartctl' command
+	excludeMetric struct {
+		temp,
+		percentUsed,
+		availSpare,
+		dataUnitsRead,
+		dataUnitsWrite,
+		hostReads,
+		hostWrites,
+		powerCycles,
+		powerOn,
+		UnsafeShutdowns,
+		mediaErrors,
+		errlogEntries,
+		warnTempTime,
+		critCompTime bool
+	}
+}
+
+func (m *SmartMonCollector) getSmartmonDevices() error {
+	// Use configured devices
+	if len(m.config.Devices) > 0 {
+		for _, configDevice := range m.config.Devices {
+			if !slices.Contains(m.config.ExcludeDevices, configDevice.Name) {
+				d := deviceT{
+					Name: configDevice.Name,
+					Type: configDevice.Type,
+				}
+				if m.config.UseSudo {
+					d.queryCommand = append(d.queryCommand, m.sudoCmd)
+				}
+				d.queryCommand = append(d.queryCommand, m.smartCtlCmd, "--json=c", "--device="+d.Type, "--all", d.Name)
+
+				m.devices = append(m.devices, d)
+			}
+		}
+		return nil
+	}
+
+	// Use scan command
+	var scanCmd []string
+	if m.config.UseSudo {
+		scanCmd = append(scanCmd, m.sudoCmd)
+	}
+	scanCmd = append(scanCmd, m.smartCtlCmd, "--scan", "--json=c")
+	command := exec.Command(scanCmd[0], scanCmd[1:]...)
+
+	stdout, err := command.Output()
+	if err != nil {
+		return fmt.Errorf(
+			"%s getSmartmonDevices(): Failed to execute device scan command %s: %w",
+			m.name, command.String(), err)
+	}
+
+	var scanOutput struct {
+		Devices []deviceT `json:"devices"`
+	}
+	err = json.Unmarshal(stdout, &scanOutput)
+	if err != nil {
+		return fmt.Errorf("%s getSmartmonDevices(): Failed to parse JSON output from device scan command: %w",
+			m.name, err)
+	}
+
+	m.devices = make([]deviceT, 0)
+	for _, d := range scanOutput.Devices {
+		if !slices.Contains(m.config.ExcludeDevices, d.Name) {
+			if m.config.UseSudo {
+				d.queryCommand = append(d.queryCommand, m.sudoCmd)
+			}
+			d.queryCommand = append(d.queryCommand, m.smartCtlCmd, "--json=c", "--device="+d.Type, "--all", d.Name)
+
+			m.devices = append(m.devices, d)
+		}
+	}
+
+	return nil
+}
+
+func (m *SmartMonCollector) Init(config json.RawMessage) error {
+	m.name = "SmartMonCollector"
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
+	m.parallel = true
+	m.meta = map[string]string{
+		"source": m.name,
+		"group":  "Disk",
+	}
+	m.tags = map[string]string{
+		"type":  "node",
+		"stype": "disk",
+	}
+
+	// Read in the JSON configuration
+	if len(config) > 0 {
+		d := json.NewDecoder(bytes.NewReader(config))
+		d.DisallowUnknownFields()
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error reading config: %w", m.name, err)
+		}
+	}
+	for _, excludeMetric := range m.config.ExcludeMetrics {
+		switch excludeMetric {
+		case "smartmon_temp":
+			m.excludeMetric.temp = true
+		case "smartmon_percent_used":
+			m.excludeMetric.percentUsed = true
+		case "smartmon_avail_spare":
+			m.excludeMetric.availSpare = true
+		case "smartmon_data_units_read":
+			m.excludeMetric.dataUnitsRead = true
+		case "smartmon_data_units_write":
+			m.excludeMetric.dataUnitsWrite = true
+		case "smartmon_host_reads":
+			m.excludeMetric.hostReads = true
+		case "smartmon_host_writes":
+			m.excludeMetric.hostWrites = true
+		case "smartmon_power_cycles":
+			m.excludeMetric.powerCycles = true
+		case "smartmon_power_on":
+			m.excludeMetric.powerOn = true
+		case "smartmon_unsafe_shutdowns":
+			m.excludeMetric.UnsafeShutdowns = true
+		case "smartmon_media_errors":
+			m.excludeMetric.mediaErrors = true
+		case "smartmon_errlog_entries":
+			m.excludeMetric.errlogEntries = true
+		case "smartmon_warn_temp_time":
+			m.excludeMetric.warnTempTime = true
+		case "smartmon_crit_comp_time":
+			m.excludeMetric.critCompTime = true
+		default:
+			return fmt.Errorf("%s Init(): Unknown excluded metric: %s", m.name, excludeMetric)
+		}
+
+	}
+
+	// Check if sudo and smartctl are in search path
+	if m.config.UseSudo {
+		p, err := exec.LookPath("sudo")
+		if err != nil {
+			return fmt.Errorf("%s Init(): No sudo command found in search path: %w", m.name, err)
+		}
+		m.sudoCmd = p
+	}
+	p, err := exec.LookPath("smartctl")
+	if err != nil {
+		return fmt.Errorf("%s Init(): No smartctl command found in search path: %w", m.name, err)
+	}
+	m.smartCtlCmd = p
+
+	if err = m.getSmartmonDevices(); err != nil {
+		return err
+	}
+
+	m.init = true
+	return err
+}
+
+type SmartMonData struct {
+	SerialNumber string `json:"serial_number"`
+	UserCapacity struct {
+		Blocks int `json:"blocks"`
+		Bytes  int `json:"bytes"`
+	} `json:"user_capacity"`
+	HealthLog struct {
+		// Available SMART health information:
+		// sudo smartctl -a --json=c /dev/nvme0 | jq --color-output | less --RAW-CONTROL-CHARS
+		Temperature        int `json:"temperature"`
+		PercentageUsed     int `json:"percentage_used"`
+		AvailableSpare     int `json:"available_spare"`
+		DataUnitsRead      int `json:"data_units_read"`
+		DataUnitsWrite     int `json:"data_units_written"`
+		HostReads          int `json:"host_reads"`
+		HostWrites         int `json:"host_writes"`
+		PowerCycles        int `json:"power_cycles"`
+		PowerOnHours       int `json:"power_on_hours"`
+		UnsafeShutdowns    int `json:"unsafe_shutdowns"`
+		MediaErrors        int `json:"media_errors"`
+		NumErrorLogEntries int `json:"num_err_log_entries"`
+		WarnTempTime       int `json:"warning_temp_time"`
+		CriticalCompTime   int `json:"critical_comp_time"`
+	} `json:"nvme_smart_health_information_log"`
+}
+
+func (m *SmartMonCollector) Read(interval time.Duration, output chan lp.CCMessage) {
+	timestamp := time.Now()
+	for _, d := range m.devices {
+		var data SmartMonData
+		command := exec.Command(d.queryCommand[0], d.queryCommand[1:]...)
+
+		stdout, err := command.Output()
+		if err != nil {
+			cclog.ComponentError(m.name, "cannot read data for device", d.Name)
+			continue
+		}
+		err = json.Unmarshal(stdout, &data)
+		if err != nil {
+			cclog.ComponentError(m.name, "cannot unmarshal data for device", d.Name)
+			continue
+		}
+		if !m.excludeMetric.temp {
+			y, err := lp.NewMetric(
+				"smartmon_temp", m.tags, m.meta, data.HealthLog.Temperature, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				y.AddMeta("unit", "degC")
+				output <- y
+			}
+		}
+		if !m.excludeMetric.percentUsed {
+			y, err := lp.NewMetric(
+				"smartmon_percent_used", m.tags, m.meta, data.HealthLog.PercentageUsed, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				y.AddMeta("unit", "percent")
+				output <- y
+			}
+		}
+		if !m.excludeMetric.availSpare {
+			y, err := lp.NewMetric(
+				"smartmon_avail_spare", m.tags, m.meta, data.HealthLog.AvailableSpare, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				y.AddMeta("unit", "percent")
+				output <- y
+			}
+		}
+		if !m.excludeMetric.dataUnitsRead {
+			y, err := lp.NewMetric(
+				"smartmon_data_units_read", m.tags, m.meta, data.HealthLog.DataUnitsRead, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				output <- y
+			}
+		}
+		if !m.excludeMetric.dataUnitsWrite {
+			y, err := lp.NewMetric(
+				"smartmon_data_units_write", m.tags, m.meta, data.HealthLog.DataUnitsWrite, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				output <- y
+			}
+		}
+		if !m.excludeMetric.hostReads {
+			y, err := lp.NewMetric(
+				"smartmon_host_reads", m.tags, m.meta, data.HealthLog.HostReads, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				output <- y
+			}
+		}
+		if !m.excludeMetric.hostWrites {
+			y, err := lp.NewMetric(
+				"smartmon_host_writes", m.tags, m.meta, data.HealthLog.HostWrites, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				output <- y
+			}
+		}
+		if !m.excludeMetric.powerCycles {
+			y, err := lp.NewMetric(
+				"smartmon_power_cycles", m.tags, m.meta, data.HealthLog.PowerCycles, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				output <- y
+			}
+		}
+		if !m.excludeMetric.powerOn {
+			y, err := lp.NewMetric(
+				"smartmon_power_on", m.tags, m.meta, int64(data.HealthLog.PowerOnHours)*3600, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				y.AddMeta("unit", "sec")
+				output <- y
+			}
+		}
+		if !m.excludeMetric.UnsafeShutdowns {
+			y, err := lp.NewMetric(
+				"smartmon_unsafe_shutdowns", m.tags, m.meta, data.HealthLog.UnsafeShutdowns, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				output <- y
+			}
+		}
+		if !m.excludeMetric.mediaErrors {
+			y, err := lp.NewMetric(
+				"smartmon_media_errors", m.tags, m.meta, data.HealthLog.MediaErrors, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				output <- y
+			}
+		}
+		if !m.excludeMetric.errlogEntries {
+			y, err := lp.NewMetric(
+				"smartmon_errlog_entries", m.tags, m.meta, data.HealthLog.NumErrorLogEntries, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				output <- y
+			}
+		}
+		if !m.excludeMetric.warnTempTime {
+			y, err := lp.NewMetric(
+				"smartmon_warn_temp_time", m.tags, m.meta, data.HealthLog.WarnTempTime, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				output <- y
+			}
+		}
+		if !m.excludeMetric.critCompTime {
+			y, err := lp.NewMetric(
+				"smartmon_crit_comp_time", m.tags, m.meta, data.HealthLog.CriticalCompTime, timestamp)
+			if err == nil {
+				y.AddTag("stype-id", d.Name)
+				output <- y
+			}
+		}
+	}
+}
+
+func (m *SmartMonCollector) Close() {
+	m.init = false
+}

collectors/smartmonMetric.md

@@ -0,0 +1,67 @@
+<!--
+---
+title: smartmon metric collector
+description: Collect S.M.A.R.T data from NVMEs
+categories: [cc-metric-collector]
+tags: ['Admin']
+weight: 2
+hugo_path: docs/reference/cc-metric-collector/collectors/smartmonMetric.md
+---
+-->
+
+## `smartmon` collector
+
+```json
+  "smartmon": {
+    "use_sudo": true,
+    "exclude_devices": [
+      "/dev/sda"
+    ],
+    "excludeMetrics": [
+      "smartmon_warn_temp_time",
+      "smartmon_crit_comp_time"
+    ],
+    "devices": [
+      {
+        "name": "/dev/nvme0",
+        "type": "nvme"
+      }
+    ]
+  }
+```
+
+The `smartmon` collector retrieves S.M.A.R.T data from NVMEs via command `smartctl`.
+
+Available NVMEs can be either automatically detected by a device scan or manually added with the "devices" config option.
+
+Metrics:
+
+* `smartmon_temp`: Temperature of the device (`unit=degC`)
+* `smartmon_avail_spare`: Amount of spare left (`unit=percent`)
+* `smartmon_percent_used`: Percentage of the device is used (`unit=percent`)
+* `smartmon_data_units_read`: Read data units
+* `smartmon_data_units_write`: Written data units
+* `smartmon_host_reads`: Read operations
+* `smartmon_host_writes`: Write operations
+* `smartmon_power_cycles`: Number of power cycles
+* `smartmon_power_on`: Seconds the device is powered on (`unit=seconds`)
+* `smartmon_unsafe_shutdowns`: Count of unsafe shutdowns
+* `smartmon_media_errors`: Media errors of the device
+* `smartmon_errlog_entries`: Error log entries
+* `smartmon_warn_temp_time`: Time above the warning temperature threshold
+* `smartmon_crit_comp_time`: Time above the critical composite temperature threshold
+
+`smartctl` typically require root to run.
+In order to run `cc-metric-collector` without root priviliges, you can enable `use_sudo`.
+Add a file like this in `/etc/sudoers.d/` to allow `cc-metric-collector` to run the required command:
+
+```
+# Do not log the following sudo commands from monitoring, since this causes a lot of log spam.
+# However keep log_denied enabled, to detect failures
+Defaults: monitoring !log_allowed, !pam_session
+
+# Allow to use lctl
+monitoring ALL = (root) NOPASSWD:/absolute/path/to/smartctl --json=c --device=* "--all" *
+# Or add individual rules for each device
+# monitoring ALL = (root) NOPASSWD:/absolute/path/to/smartctl --json=c --device=<device_type> "--all" <device>
+```

collectors/tempMetric.go

@@ -8,6 +8,7 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"os"
@@ -16,8 +17,8 @@ import (
 	"strings"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
 // See: https://www.kernel.org/doc/html/latest/hwmon/sysfs-interface.html
@@ -41,6 +42,7 @@ type TempCollectorSensor struct {
 
 type TempCollector struct {
 	metricCollector
+
 	config struct {
 		ExcludeMetrics     []string                     `json:"exclude_metrics"`
 		TagOverride        map[string]map[string]string `json:"tag_override"`
@@ -58,11 +60,14 @@ func (m *TempCollector) Init(config json.RawMessage) error {
 
 	m.name = "TempCollector"
 	m.parallel = true
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	if len(config) > 0 {
-		err := json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
 
@@ -78,10 +83,10 @@ func (m *TempCollector) Init(config json.RawMessage) error {
 	globPattern := filepath.Join("/sys/class/hwmon", "*", "temp*_input")
 	inputFiles, err := filepath.Glob(globPattern)
 	if err != nil {
-		return fmt.Errorf("unable to glob files with pattern '%s': %v", globPattern, err)
+		return fmt.Errorf("%s Init(): unable to glob files with pattern '%s': %w", m.name, globPattern, err)
 	}
 	if inputFiles == nil {
-		return fmt.Errorf("unable to find any files with pattern '%s'", globPattern)
+		return fmt.Errorf("%s Init(): unable to find any files with pattern '%s'", m.name, globPattern)
 	}
 
 	// Get sensor name for each temperature sensor file
@@ -117,7 +122,7 @@ func (m *TempCollector) Init(config json.RawMessage) error {
 			sensor.metricName = sensor.label
 		}
 		sensor.metricName = strings.ToLower(sensor.metricName)
-		sensor.metricName = strings.Replace(sensor.metricName, " ", "_", -1)
+		sensor.metricName = strings.ReplaceAll(sensor.metricName, " ", "_")
 		// Add temperature prefix, if required
 		if !strings.Contains(sensor.metricName, "temp") {
 			sensor.metricName = "temp_" + sensor.metricName
@@ -170,7 +175,7 @@ func (m *TempCollector) Init(config json.RawMessage) error {
 
 	// Empty sensors map
 	if len(m.sensors) == 0 {
-		return fmt.Errorf("no temperature sensors found")
+		return fmt.Errorf("%s Init(): no temperature sensors found", m.name)
 	}
 
 	// Finished initialization
@@ -179,7 +184,6 @@ func (m *TempCollector) Init(config json.RawMessage) error {
 }
 
 func (m *TempCollector) Read(interval time.Duration, output chan lp.CCMessage) {
-
 	for _, sensor := range m.sensors {
 		// Read sensor file
 		buffer, err := os.ReadFile(sensor.file)
@@ -197,26 +201,14 @@ func (m *TempCollector) Read(interval time.Duration, output chan lp.CCMessage) {
 			continue
 		}
 		x /= 1000
-		y, err := lp.NewMessage(
+		y, err := lp.NewMetric(sensor.metricName, sensor.tags, m.meta, x, time.Now())
-			sensor.metricName,
-			sensor.tags,
-			m.meta,
-			map[string]interface{}{"value": x},
-			time.Now(),
-		)
 		if err == nil {
 			output <- y
 		}
 
 		// max temperature
 		if m.config.ReportMaxTemp && sensor.maxTemp != 0 {
-			y, err := lp.NewMessage(
+			y, err := lp.NewMetric(sensor.maxTempName, sensor.tags, m.meta, sensor.maxTemp, time.Now())
-				sensor.maxTempName,
-				sensor.tags,
-				m.meta,
-				map[string]interface{}{"value": sensor.maxTemp},
-				time.Now(),
-			)
 			if err == nil {
 				output <- y
 			}
@@ -224,19 +216,12 @@ func (m *TempCollector) Read(interval time.Duration, output chan lp.CCMessage) {
 
 		// critical temperature
 		if m.config.ReportCriticalTemp && sensor.critTemp != 0 {
-			y, err := lp.NewMessage(
+			y, err := lp.NewMetric(sensor.critTempName, sensor.tags, m.meta, sensor.critTemp, time.Now())
-				sensor.critTempName,
-				sensor.tags,
-				m.meta,
-				map[string]interface{}{"value": sensor.critTemp},
-				time.Now(),
-			)
 			if err == nil {
 				output <- y
 			}
 		}
 	}
-
 }
 
 func (m *TempCollector) Close() {

collectors/tempMetric.md

@@ -14,10 +14,10 @@ hugo_path: docs/reference/cc-metric-collector/collectors/temp.md
 
 ```json
   "tempstat": {
-    "tag_override" : {
+    "tag_override": {
-        "<device like hwmon1>" : {
+        "<device like hwmon1>": {
-            "type" : "socket",
+            "type": "socket",
-            "type-id" : "0"
+            "type-id": "0"
         }
     },
     "exclude_metrics": [

collectors/topprocsMetric.go

@@ -8,19 +8,21 @@
 package collectors
 
 import (
+	"bytes"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"log"
 	"os/exec"
 	"strings"
 	"time"
 
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 )
 
-const MAX_NUM_PROCS = 10
+const (
-const DEFAULT_NUM_PROCS = 2
+	MAX_NUM_PROCS     = 10
+	DEFAULT_NUM_PROCS = 2
+)
 
 type TopProcsCollectorConfig struct {
 	Num_procs int `json:"num_procs"`
@@ -28,6 +30,7 @@ type TopProcsCollectorConfig struct {
 
 type TopProcsCollector struct {
 	metricCollector
+
 	tags   map[string]string
 	config TopProcsCollectorConfig
 }
@@ -36,12 +39,18 @@ func (m *TopProcsCollector) Init(config json.RawMessage) error {
 	var err error
 	m.name = "TopProcsCollector"
 	m.parallel = true
-	m.tags = map[string]string{"type": "node"}
+	m.tags = map[string]string{
-	m.meta = map[string]string{"source": m.name, "group": "TopProcs"}
+		"type": "node",
+	}
+	m.meta = map[string]string{
+		"source": m.name,
+		"group":  "TopProcs",
+	}
 	if len(config) > 0 {
-		err = json.Unmarshal(config, &m.config)
+		d := json.NewDecoder(bytes.NewReader(config))
-		if err != nil {
+		d.DisallowUnknownFields()
-			return err
+		if err := d.Decode(&m.config); err != nil {
+			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	} else {
 		m.config.Num_procs = int(DEFAULT_NUM_PROCS)
@@ -49,12 +58,13 @@ func (m *TopProcsCollector) Init(config json.RawMessage) error {
 	if m.config.Num_procs <= 0 || m.config.Num_procs > MAX_NUM_PROCS {
 		return fmt.Errorf("num_procs option must be set in 'topprocs' config (range: 1-%d)", MAX_NUM_PROCS)
 	}
-	m.setup()
+	if err := m.setup(); err != nil {
+		return fmt.Errorf("%s Init(): setup() call failed: %w", m.name, err)
+	}
 	command := exec.Command("ps", "-Ao", "comm", "--sort=-pcpu")
-	command.Wait()
 	_, err = command.Output()
 	if err != nil {
-		return errors.New("failed to execute command")
+		return fmt.Errorf("%s Init(): failed to get output from command: %w", m.name, err)
 	}
 	m.init = true
 	return nil
@@ -65,18 +75,18 @@ func (m *TopProcsCollector) Read(interval time.Duration, output chan lp.CCMessag
 		return
 	}
 	command := exec.Command("ps", "-Ao", "comm", "--sort=-pcpu")
-	command.Wait()
 	stdout, err := command.Output()
 	if err != nil {
-		log.Print(m.name, err)
+		cclog.ComponentError(
+			m.name,
+			fmt.Sprintf("Read(): Failed to read output from command \"%s\": %v", command.String(), err))
 		return
 	}
 
 	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())
+		if y, err := lp.NewMetric(name, m.tags, m.meta, lines[i], time.Now()); err == nil {
-		if err == nil {
 			output <- y
 		}
 	}

docs/configuration.md

@@ -4,7 +4,7 @@ The configuration of the CC metric collector consists of five configuration file
 
 ## Global configuration
 
-The global file contains the paths to the other four files and some global options. 
+The global file contains the paths to the other four files and some global options. You can find examples in `example_configs`.
 
 ```json
 {

example-configs/collectors.json

@@ -1,6 +1,19 @@
 {
     "cpufreq": {},
     "cpufreq_cpuinfo": {},
+    "cpustat": {
+        "exclude_metrics": [
+            "cpu_idle"
+        ]
+    },
+    "diskstat": {
+        "exclude_metrics": [
+            "disk_total"
+        ],
+        "exclude_mounts": [
+            "slurm-tmpfs"
+        ]
+    },
     "gpfs": {
         "exclude_filesystem": [
             "test_fs"
@@ -21,6 +34,8 @@
     },
     "numastats": {},
     "nvidia": {},
+    "schedstat": {},
+    "smartmon": {},
     "tempstat": {
         "report_max_temperature": true,
         "report_critical_temperature": true,
@@ -38,4 +53,4 @@
     "topprocs": {
         "num_procs": 5
     }
-}
+}

example-configs/router.json

@@ -1,6 +1,6 @@
 {
     "process_messages" : {
-        "add_tag_if": [
+        "add_tags_if": [
             {
                 "key" : "cluster",
                 "value" : "testcluster",
@@ -12,7 +12,7 @@
                 "if" : "name == 'temp_package_id_0'"
             }
         ],
-        "delete_tag_if": [
+        "delete_meta_if": [
             {
                 "key" : "unit",
                 "if" : "true"

go.mod

@@ -1,45 +1,46 @@
 module github.com/ClusterCockpit/cc-metric-collector
 
-go 1.24.0
+go 1.25.0
 
 require (
-	github.com/ClusterCockpit/cc-lib v0.10.1
+	github.com/ClusterCockpit/cc-lib/v2 v2.12.0
-	github.com/ClusterCockpit/go-rocm-smi v0.3.0
+	github.com/ClusterCockpit/go-rocm-smi v0.4.0
-	github.com/NVIDIA/go-nvml v0.13.0-1
+	github.com/NVIDIA/go-nvml v0.13.2-0
 	github.com/PaesslerAG/gval v1.2.4
-	github.com/fsnotify/fsnotify v1.9.0
+	github.com/fsnotify/fsnotify v1.10.1
-	github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf
+	github.com/tklauser/go-sysconf v0.4.0
-	github.com/tklauser/go-sysconf v0.3.15
+	golang.design/x/runtime v0.3.0
-	golang.design/x/thread v0.0.0-20210122121316-335e9adffdf1
+	golang.org/x/sys v0.45.0
-	golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b
-	golang.org/x/sys v0.37.0
 )
 
 require (
+	github.com/ClusterCockpit/cc-line-protocol/v2 v2.4.0 // indirect
 	github.com/apapsch/go-jsonmerge/v2 v2.0.0 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/expr-lang/expr v1.17.6 // indirect
+	github.com/coder/websocket v1.8.14 // indirect
+	github.com/expr-lang/expr v1.17.8 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/mux v1.8.1 // indirect
 	github.com/influxdata/influxdb-client-go/v2 v2.14.0 // indirect
-	github.com/influxdata/line-protocol/v2 v2.2.1 // indirect
+	github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf // indirect
-	github.com/klauspost/compress v1.18.0 // indirect
+	github.com/klauspost/compress v1.18.5 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
-	github.com/nats-io/nats.go v1.46.1 // indirect
+	github.com/nats-io/nats.go v1.51.0 // indirect
-	github.com/nats-io/nkeys v0.4.11 // indirect
+	github.com/nats-io/nkeys v0.4.15 // indirect
 	github.com/nats-io/nuid v1.0.1 // indirect
-	github.com/oapi-codegen/runtime v1.1.1 // indirect
+	github.com/oapi-codegen/runtime v1.4.0 // indirect
 	github.com/prometheus/client_golang v1.23.2 // indirect
 	github.com/prometheus/client_model v0.6.2 // indirect
-	github.com/prometheus/common v0.66.1 // indirect
+	github.com/prometheus/common v0.67.5 // indirect
-	github.com/prometheus/procfs v0.16.1 // indirect
+	github.com/prometheus/procfs v0.20.1 // indirect
+	github.com/questdb/go-questdb-client/v4 v4.2.0 // indirect
 	github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 // indirect
-	github.com/shopspring/decimal v1.3.1 // indirect
+	github.com/shopspring/decimal v1.4.0 // indirect
-	github.com/stmcginnis/gofish v0.20.0 // indirect
+	github.com/stmcginnis/gofish v0.21.6 // indirect
-	github.com/tklauser/numcpus v0.10.0 // indirect
+	github.com/tklauser/numcpus v0.12.0 // indirect
-	go.yaml.in/yaml/v2 v2.4.2 // indirect
+	go.yaml.in/yaml/v2 v2.4.4 // indirect
-	golang.org/x/crypto v0.42.0 // indirect
+	golang.org/x/crypto v0.50.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	golang.org/x/net v0.53.0 // indirect
-	google.golang.org/protobuf v1.36.8 // indirect
+	google.golang.org/protobuf v1.36.11 // indirect
 )

go.sum

@@ -1,42 +1,71 @@
-github.com/ClusterCockpit/cc-lib v0.10.1 h1:tjGEH8mFGgznYxO8BKLiiar0eZR1Oytk8x5iIQHZR5s=
+dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
-github.com/ClusterCockpit/cc-lib v0.10.1/go.mod h1:nvTZuxFCTwlos8I1rL5O1RPab7vRtkU8E/PGiaF6pQA=
+dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
-github.com/ClusterCockpit/go-rocm-smi v0.3.0 h1:1qZnSpG7/NyLtc7AjqnUL9Jb8xtqG1nMVgp69rJfaR8=
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
-github.com/ClusterCockpit/go-rocm-smi v0.3.0/go.mod h1:+I3UMeX3OlizXDf1WpGD43W4KGZZGVSGmny6rTeOnWA=
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
-github.com/NVIDIA/go-nvml v0.11.6-0/go.mod h1:hy7HYeQy335x6nEss0Ne3PYqleRa6Ct+VKD9RQ4nyFs=
+github.com/ClusterCockpit/cc-lib/v2 v2.12.0 h1:ZbGD68nDniuvzFjJCdyYawpCBrabdSyWOg5FFSyFbjQ=
-github.com/NVIDIA/go-nvml v0.13.0-1 h1:OLX8Jq3dONuPOQPC7rndB6+iDmDakw0XTYgzMxObkEw=
+github.com/ClusterCockpit/cc-lib/v2 v2.12.0/go.mod h1:ml8xtcYa5WhPM7JDQ+M9/R9ZBxITCR/5xqGJ//GxXJI=
+github.com/ClusterCockpit/cc-line-protocol/v2 v2.4.0 h1:hIzxgTBWcmCIHtoDKDkSCsKCOCOwUC34sFsbD2wcW0Q=
+github.com/ClusterCockpit/cc-line-protocol/v2 v2.4.0/go.mod h1:y42qUu+YFmu5fdNuUAS4VbbIKxVjxCvbVqFdpdh8ahY=
+github.com/ClusterCockpit/go-rocm-smi v0.4.0 h1:3+bEPrSkjEJcOtt+qBUX48ugDVlOFaKUnXHTef2Ve2Q=
+github.com/ClusterCockpit/go-rocm-smi v0.4.0/go.mod h1:c19u5vBCcgb7DjL4EWTGSGpo6c79d07r4rxD50z25ng=
+github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
+github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
+github.com/Microsoft/hcsshim v0.11.4 h1:68vKo2VN8DE9AdN4tnkWnmdhqdbpUFM8OF3Airm7fz8=
+github.com/Microsoft/hcsshim v0.11.4/go.mod h1:smjE4dvqPX9Zldna+t5FG3rnoHhaB7QYxPRqGcpAD9w=
 github.com/NVIDIA/go-nvml v0.13.0-1/go.mod h1:+KNA7c7gIBH7SKSJ1ntlwkfN80zdx8ovl4hrK3LmPt4=
+github.com/NVIDIA/go-nvml v0.13.2-0 h1:7M4cFG62wSUHw8i0XSiNU7ejKODytTS6ZrW/vgB2NSI=
+github.com/NVIDIA/go-nvml v0.13.2-0/go.mod h1:ahi2psRYoa+wYUBIrZPRO+wJs9lcvMhxSSkjjvsJJNQ=
 github.com/PaesslerAG/gval v1.2.4 h1:rhX7MpjJlcxYwL2eTTYIOBUyEKZ+A96T9vQySWkVUiU=
 github.com/PaesslerAG/gval v1.2.4/go.mod h1:XRFLwvmkTEdYziLdaCeCa5ImcGVrfQbeNUbVR+C6xac=
 github.com/PaesslerAG/jsonpath v0.1.0 h1:gADYeifvlqK3R3i2cR5B4DGgxLXIPb3TRTH1mGi0jPI=
 github.com/PaesslerAG/jsonpath v0.1.0/go.mod h1:4BzmtoM/PI8fPO4aQGIusjGxGir2BzcV0grWtFzq1Y8=
 github.com/RaveNoX/go-jsoncommentstrip v1.0.0/go.mod h1:78ihd09MekBnJnxpICcwzCMzGrKSKYe4AqU6PDYYpjk=
-github.com/antithesishq/antithesis-sdk-go v0.4.3-default-no-op h1:+OSa/t11TFhqfrX0EOSqQBDJ0YlpmK0rDSiB19dg9M0=
+github.com/antithesishq/antithesis-sdk-go v0.6.0-default-no-op h1:kpBdlEPbRvff0mDD1gk7o9BhI16b9p5yYAXRlidpqJE=
-github.com/antithesishq/antithesis-sdk-go v0.4.3-default-no-op/go.mod h1:IUpT2DPAKh6i/YhSbt6Gl3v2yvUZjmKncl7U91fup7E=
+github.com/antithesishq/antithesis-sdk-go v0.6.0-default-no-op/go.mod h1:IUpT2DPAKh6i/YhSbt6Gl3v2yvUZjmKncl7U91fup7E=
 github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ=
 github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bmatcuk/doublestar v1.1.1/go.mod h1:UD6OnuiIn0yFxxA2le/rnRU1G4RaI4UvFv1sNto9p6w=
+github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM=
+github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/coder/websocket v1.8.14 h1:9L0p0iKiNOibykf283eHkKUHHrpG7f65OE3BhhO7v9g=
+github.com/coder/websocket v1.8.14/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
+github.com/containerd/containerd v1.7.12 h1:+KQsnv4VnzyxWcfO9mlxxELaoztsDEjOuCMPAuPqgU0=
+github.com/containerd/containerd v1.7.12/go.mod h1:/5OMpE1p0ylxtEUGY8kuCYkDRzJm9NO1TFMWjUpdevk=
+github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I=
+github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo=
+github.com/cpuguy83/dockercfg v0.3.1 h1:/FpZ+JaygUR/lZP2NlFI2DVfrOEMAIKP5wWEJdoYe9E=
+github.com/cpuguy83/dockercfg v0.3.1/go.mod h1:sugsbF4//dDlL/i+S+rtpIWp+5h0BHJHfjj5/jFyUJc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/expr-lang/expr v1.17.6 h1:1h6i8ONk9cexhDmowO/A64VPxHScu7qfSl2k8OlINec=
+github.com/docker/distribution v2.8.2+incompatible h1:T3de5rq0dB1j30rp0sA2rER+m322EBzniBPB6ZIzuh8=
-github.com/expr-lang/expr v1.17.6/go.mod h1:8/vRC7+7HBzESEqt5kKpYXxrxkr31SaO8r40VO/1IT4=
+github.com/docker/distribution v2.8.2+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
-github.com/frankban/quicktest v1.11.0/go.mod h1:K+q6oSqb0W0Ininfk863uOk1lMy69l/P6txr3mVT54s=
+github.com/docker/docker v24.0.9+incompatible h1:HPGzNmwfLZWdxHqK9/II92pyi1EpYKsAqcl4G0Of9v0=
-github.com/frankban/quicktest v1.11.2/go.mod h1:K+q6oSqb0W0Ininfk863uOk1lMy69l/P6txr3mVT54s=
+github.com/docker/docker v24.0.9+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
+github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
+github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
+github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
+github.com/expr-lang/expr v1.17.8 h1:W1loDTT+0PQf5YteHSTpju2qfUfNoBt4yw9+wOEU9VM=
+github.com/expr-lang/expr v1.17.8/go.mod h1:8/vRC7+7HBzESEqt5kKpYXxrxkr31SaO8r40VO/1IT4=
 github.com/frankban/quicktest v1.13.0 h1:yNZif1OkDfNoDfb9zZa9aXIpejNR4F23Wely0c+Qdqk=
 github.com/frankban/quicktest v1.13.0/go.mod h1:qLE0fzW0VuyUAJgPU19zByoIr0HtCHN/r/VLSOOIySU=
-github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.10.1 h1:b0/UzAf9yR5rhf3RPm9gf3ehBPpf0oZKIjtpKrx59Ho=
-github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/fsnotify/fsnotify v1.10.1/go.mod h1:TLheqan6HD6GBK6PrDWyDPBaEV8LspOxvPSjC+bVfgo=
-github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
+github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/go-tpm v0.9.5 h1:ocUmnDebX54dnW+MQWGQRbdaAcJELsa6PqZhJ48KwVU=
+github.com/google/go-tpm v0.9.8 h1:slArAR9Ft+1ybZu0lBwpSmpwhRXaa85hWtMinMyRAWo=
-github.com/google/go-tpm v0.9.5/go.mod h1:h9jEsEECg7gtLis0upRBQU+GhYVH6jMjrFxI8u6bVUY=
+github.com/google/go-tpm v0.9.8/go.mod h1:h9jEsEECg7gtLis0upRBQU+GhYVH6jMjrFxI8u6bVUY=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
@@ -45,93 +74,129 @@ github.com/influxdata/influxdb-client-go/v2 v2.14.0 h1:AjbBfJuq+QoaXNcrova8smSjw
 github.com/influxdata/influxdb-client-go/v2 v2.14.0/go.mod h1:Ahpm3QXKMJslpXl3IftVLVezreAUtBOTZssDrjZEFHI=
 github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf h1:7JTmneyiNEwVBOHSjoMxiWAqB992atOeepeFYegn5RU=
 github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo=
-github.com/influxdata/line-protocol-corpus v0.0.0-20210519164801-ca6fa5da0184/go.mod h1:03nmhxzZ7Xk2pdG+lmMd7mHDfeVOYFyhOgwO61qWU98=
 github.com/influxdata/line-protocol-corpus v0.0.0-20210922080147-aa28ccfb8937 h1:MHJNQ+p99hFATQm6ORoLmpUCF7ovjwEFshs/NHzAbig=
 github.com/influxdata/line-protocol-corpus v0.0.0-20210922080147-aa28ccfb8937/go.mod h1:BKR9c0uHSmRgM/se9JhFHtTT7JTO67X23MtKMHtZcpo=
-github.com/influxdata/line-protocol/v2 v2.0.0-20210312151457-c52fdecb625a/go.mod h1:6+9Xt5Sq1rWx+glMgxhcg2c0DUaehK+5TDcPZ76GypY=
-github.com/influxdata/line-protocol/v2 v2.1.0/go.mod h1:QKw43hdUBg3GTk2iC3iyCxksNj7PX9aUSeYOYE/ceHY=
-github.com/influxdata/line-protocol/v2 v2.2.1 h1:EAPkqJ9Km4uAxtMRgUubJyqAr6zgWM0dznKMLRauQRE=
-github.com/influxdata/line-protocol/v2 v2.2.1/go.mod h1:DmB3Cnh+3oxmG6LOBIxce4oaL4CPj3OmMPgvauXh+tM=
 github.com/juju/gnuflag v0.0.0-20171113085948-2ce1bb71843d/go.mod h1:2PavIy+JPciBPrBUjwbNvtwB6RQlve+hkpll6QSNmOE=
-github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
+github.com/klauspost/compress v1.18.5 h1:/h1gH5Ce+VWNLSWqPzOVn6XBO+vJbCNGvjoaGBFW2IE=
-github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/klauspost/compress v1.18.5/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
-github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
-github.com/minio/highwayhash v1.0.3 h1:kbnuUMoHYyVl7szWjSxJnxw11k2U709jqFPPmIUyD6Q=
+github.com/lufia/plan9stats v0.0.0-20230326075908-cb1d2100619a h1:N9zuLhTvBSRt0gWSiJswwQ2HqDmtX/ZCDJURnKUt1Ik=
-github.com/minio/highwayhash v1.0.3/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ=
+github.com/lufia/plan9stats v0.0.0-20230326075908-cb1d2100619a/go.mod h1:JKx41uQRwqlTZabZc+kILPrO/3jlKnQ2Z8b7YiVw5cE=
+github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY=
+github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
+github.com/minio/highwayhash v1.0.4-0.20251030100505-070ab1a87a76 h1:KGuD/pM2JpL9FAYvBrnBBeENKZNh6eNtjqytV6TYjnk=
+github.com/minio/highwayhash v1.0.4-0.20251030100505-070ab1a87a76/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ=
+github.com/moby/patternmatcher v0.6.0 h1:GmP9lR19aU5GqSSFko+5pRqHi+Ohk1O69aFiKkVGiPk=
+github.com/moby/patternmatcher v0.6.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc=
+github.com/moby/sys/sequential v0.5.0 h1:OPvI35Lzn9K04PBbCLW0g4LcFAJgHsvXsRyewg5lXtc=
+github.com/moby/sys/sequential v0.5.0/go.mod h1:tH2cOOs5V9MlPiXcQzRC+eEyab644PWKGRYaaV5ZZlo=
+github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
+github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
+github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
+github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
-github.com/nats-io/jwt/v2 v2.8.0 h1:K7uzyz50+yGZDO5o772eRE7atlcSEENpL7P+b74JV1g=
+github.com/nats-io/jwt/v2 v2.8.1 h1:V0xpGuD/N8Mi+fQNDynXohVvp7ZztevW5io8CUWlPmU=
-github.com/nats-io/jwt/v2 v2.8.0/go.mod h1:me11pOkwObtcBNR8AiMrUbtVOUGkqYjMQZ6jnSdVUIA=
+github.com/nats-io/jwt/v2 v2.8.1/go.mod h1:nWnOEEiVMiKHQpnAy4eXlizVEtSfzacZ1Q43LIRavZg=
-github.com/nats-io/nats-server/v2 v2.12.0 h1:OIwe8jZUqJFrh+hhiyKu8snNib66qsx806OslqJuo74=
+github.com/nats-io/nats-server/v2 v2.12.7 h1:prQ9cPiWHcnwfT81Wi5lU9LL8TLY+7pxDru6fQYLCQQ=
-github.com/nats-io/nats-server/v2 v2.12.0/go.mod h1:nr8dhzqkP5E/lDwmn+A2CvQPMd1yDKXQI7iGg3lAvww=
+github.com/nats-io/nats-server/v2 v2.12.7/go.mod h1:dOnmkprKMluTmTF7/QHZioxlau3sKHUM/LBPy9AiBPw=
-github.com/nats-io/nats.go v1.46.1 h1:bqQ2ZcxVd2lpYI97xYASeRTY3I5boe/IVmuUDPitHfo=
+github.com/nats-io/nats.go v1.51.0 h1:ByW84XTz6W03GSSsygsZcA+xgKK8vPGaa/FCAAEHnAI=
-github.com/nats-io/nats.go v1.46.1/go.mod h1:iRWIPokVIFbVijxuMQq4y9ttaBTMe0SFdlZfMDd+33g=
+github.com/nats-io/nats.go v1.51.0/go.mod h1:26HypzazeOkyO3/mqd1zZd53STJN0EjCYF9Uy2ZOBno=
-github.com/nats-io/nkeys v0.4.11 h1:q44qGV008kYd9W1b1nEBkNzvnWxtRSQ7A8BoqRrcfa0=
+github.com/nats-io/nkeys v0.4.15 h1:JACV5jRVO9V856KOapQ7x+EY8Jo3qw1vJt/9Jpwzkk4=
-github.com/nats-io/nkeys v0.4.11/go.mod h1:szDimtgmfOi9n25JpfIdGw12tZFYXqhGxjhVxsatHVE=
+github.com/nats-io/nkeys v0.4.15/go.mod h1:CpMchTXC9fxA5zrMo4KpySxNjiDVvr8ANOSZdiNfUrs=
 github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
 github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
-github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/oapi-codegen/runtime v1.4.0 h1:KLOSFOp7UzkbS7Cs1ms6NBEKYr0WmH2wZG0KKbd2er4=
-github.com/oapi-codegen/runtime v1.1.1 h1:EXLHh0DXIJnWhdRPN2w4MXAzFyE4CskzhNLUmtpMYro=
+github.com/oapi-codegen/runtime v1.4.0/go.mod h1:5sw5fxCDmnOzKNYmkVNF8d34kyUeejJEY8HNT2WaPec=
-github.com/oapi-codegen/runtime v1.1.1/go.mod h1:SK9X900oXmPWilYR5/WKPzt3Kqxn/uS/+lbpREv+eCg=
+github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
+github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
+github.com/opencontainers/image-spec v1.1.0-rc5 h1:Ygwkfw9bpDvs+c9E34SdgGOj41dX/cbdlwvlWt0pnFI=
+github.com/opencontainers/image-spec v1.1.0-rc5/go.mod h1:X4pATf0uXsnn3g5aiGIsVnJBR4mxhKzfwmvK/B2NTm8=
+github.com/opencontainers/runc v1.1.5 h1:L44KXEpKmfWDcS02aeGm8QNTFXTo2D+8MYGDIJ/GDEs=
+github.com/opencontainers/runc v1.1.5/go.mod h1:1J5XiS+vdZ3wCyZybsuxXZWGrgSr8fFJHLXuG2PsnNg=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/power-devops/perfstat v0.0.0-20221212215047-62379fc7944b h1:0LFwY6Q3gMACTjAbMZBjXAqTOzOwFaj2Ld6cjeQ7Rig=
+github.com/power-devops/perfstat v0.0.0-20221212215047-62379fc7944b/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
 github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
 github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=
 github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
 github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
-github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs=
+github.com/prometheus/common v0.67.5 h1:pIgK94WWlQt1WLwAC5j2ynLaBRDiinoAb86HZHTUGI4=
-github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA=
+github.com/prometheus/common v0.67.5/go.mod h1:SjE/0MzDEEAyrdr5Gqc6G+sXI67maCxzaT3A2+HqjUw=
-github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg=
+github.com/prometheus/procfs v0.20.1 h1:XwbrGOIplXW/AU3YhIhLODXMJYyC1isLFfYCsTEycfc=
-github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is=
+github.com/prometheus/procfs v0.20.1/go.mod h1:o9EMBZGRyvDrSPH1RqdxhojkuXstoe4UlK79eF5TGGo=
+github.com/questdb/go-questdb-client/v4 v4.2.0 h1:+d0HJwCjUWMj7zmY6qmhoqTJzTyoYKl+LSTYGN0T8T8=
+github.com/questdb/go-questdb-client/v4 v4.2.0/go.mod h1:/2x93LK1wjM4JX/b5c6q7Yqk22htjWY1lE6p1X8iLbE=
 github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
 github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 h1:lZUw3E0/J3roVtGQ+SCrUrg3ON6NgVqpn3+iol9aGu4=
 github.com/santhosh-tekuri/jsonschema/v5 v5.3.1/go.mod h1:uToXkOrWAZ6/Oc07xWQrPOhJotwFIyu2bBVN41fcDUY=
-github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8=
+github.com/shirou/gopsutil/v3 v3.23.12 h1:z90NtUkp3bMtmICZKpC4+WaknU1eXtp5vtbQ11DgpE4=
+github.com/shirou/gopsutil/v3 v3.23.12/go.mod h1:1FrWgea594Jp7qmjHUUPlJDTPgcsb9mGnXDxavtikzM=
+github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM=
+github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ=
 github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o=
+github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
+github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0=
-github.com/stmcginnis/gofish v0.20.0 h1:hH2V2Qe898F2wWT1loApnkDUrXXiLKqbSlMaH3Y1n08=
+github.com/stmcginnis/gofish v0.21.6 h1:jK3TGD6VANaAHKHypVNfD6io2nPrU+6eF8X4qARsTlY=
-github.com/stmcginnis/gofish v0.20.0/go.mod h1:PzF5i8ecRG9A2ol8XT64npKUunyraJ+7t0kYMpQAtqU=
+github.com/stmcginnis/gofish v0.21.6/go.mod h1:PzF5i8ecRG9A2ol8XT64npKUunyraJ+7t0kYMpQAtqU=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-github.com/tklauser/go-sysconf v0.3.15 h1:VE89k0criAymJ/Os65CSn1IXaol+1wrsFHEB8Ol49K4=
+github.com/testcontainers/testcontainers-go v0.26.0 h1:uqcYdoOHBy1ca7gKODfBd9uTHVK3a7UL848z09MVZ0c=
-github.com/tklauser/go-sysconf v0.3.15/go.mod h1:Dmjwr6tYFIseJw7a3dRLJfsHAMXZ3nEnL/aZY+0IuI4=
+github.com/testcontainers/testcontainers-go v0.26.0/go.mod h1:ICriE9bLX5CLxL9OFQ2N+2N+f+803LNJ1utJb1+Inx0=
-github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfjso=
+github.com/tklauser/go-sysconf v0.4.0 h1:7H0uAN+7RkwWRaxhYXDLqa5V3LPrJeV8wmD9dRUgPQU=
-github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ=
+github.com/tklauser/go-sysconf v0.4.0/go.mod h1:8mTNWyog7H+MpKijp4VmKJAd2bbYQ2zuUwkYRbUArPI=
+github.com/tklauser/numcpus v0.12.0 h1:NR85qdvHA9pFse3x3weVZ0r0ST8R6l5RHbZrlRaqob4=
+github.com/tklauser/numcpus v0.12.0/go.mod h1:ABHeXzJnr/qqwguhClkZKT1/8VABcYrsyUiUGobwWJg=
+github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw=
+github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI=
+go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=
-go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU=
+go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=
-golang.design/x/thread v0.0.0-20210122121316-335e9adffdf1 h1:P7S/GeHBAFEZIYp0ePPs2kHXoazz8q2KsyxHyQVGCJg=
+golang.design/x/runtime v0.3.0 h1:8bA+GQfO8A18JXJQlQA56pEc+Sgrbo4cmLzjzmJ58ZI=
-golang.design/x/thread v0.0.0-20210122121316-335e9adffdf1/go.mod h1:9CWpnTUmlQkfdpdutA1nNf4iE5lAVt3QZOu0Z6hahBE=
+golang.design/x/runtime v0.3.0/go.mod h1:PjVKQjImLdSrvjIw4FmrnCPq9BGs5PMBHb8i6b2BN9I=
-golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
+golang.org/x/crypto v0.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI=
-golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
+golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q=
-golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b h1:M2rDM6z3Fhozi9O7NWsxAkg/yqS/lQJ6PmkyIV3YP+o=
+golang.org/x/exp v0.0.0-20231005195138-3e424a577f31 h1:9k5exFQKQglLo+RoP+4zMjOFE14P6+vyR0baDAi0Rcs=
-golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b/go.mod h1:3//PLf8L/X+8b4vuAfHzxeRUl04Adcb341+IGKfnqS8=
+golang.org/x/exp v0.0.0-20231005195138-3e424a577f31/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
+golang.org/x/mod v0.13.0 h1:I/DsJXRlw/8l/0c24sM9yb0T4z9liZTduXvdAWYiysY=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/mod v0.13.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/sys v0.0.0-20210122093101-04d7465088b8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/net v0.53.0 h1:d+qAbo5L0orcWAr0a9JweQpjXF19LMXJE8Ey7hwOdUA=
-golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
+golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs=
-golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY=
-golang.org/x/time v0.13.0 h1:eUlYslOIt32DgYD6utsuUeHs4d7AsEYLuIAdg7FlYgI=
+golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/time v0.13.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
+golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
-google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
+golang.org/x/tools v0.14.0 h1:jvNa2pY0M4r62jkRQ6RwEZZyPcymeL9XZMLBbV7U2nc=
-google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
+golang.org/x/tools v0.14.0/go.mod h1:uYBEerGOWcJyEORxN+Ek8+TT266gXkNlHdJBwexUsBg=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97 h1:6GQBEOdGkX6MMTLT9V+TjtIRZCw9VPD5Z+yHY9wMgS0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97/go.mod h1:v7nGkzlmW8P3n/bKmWBn2WpBjpOEx8Q6gMueudAmKfY=
+google.golang.org/grpc v1.58.3 h1:BjnpXut1btbtgN/6sp+brB2Kbm2LjNXnidYujAVbSoQ=
+google.golang.org/grpc v1.58.3/go.mod h1:tgX3ZQDlNJGU96V6yHh1T/JeoBQ2TXdr43YbYSsCJk0=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/metricAggregator/metricAggregator.go

@@ -10,15 +10,17 @@ package metricAggregator
 import (
 	"context"
 	"fmt"
+	"maps"
 	"math"
 	"os"
+	"slices"
 	"strings"
 	"sync"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
 
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 	topo "github.com/ClusterCockpit/cc-metric-collector/pkg/ccTopology"
 
 	"github.com/PaesslerAG/gval"
@@ -36,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
 }
@@ -70,10 +72,12 @@ var metricCacheLanguage = gval.NewLanguage(
 	gval.Function("getCpuList", getCpuListOfNode),
 	gval.Function("getCpuListOfType", getCpuListOfType),
 )
+
 var language gval.Language = gval.NewLanguage(
 	gval.Full(),
 	metricCacheLanguage,
 )
+
 var evaluables = struct {
 	mapping map[string]gval.Evaluable
 	mutex   sync.Mutex
@@ -84,14 +88,13 @@ 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
 	hostname, err := os.Hostname()
 	if err != nil {
-		cclog.Error(err.Error())
+		return fmt.Errorf("metricAggregator: failed to get hostname: %w", err)
-		return err
 	}
 	// Drop domain part of host name
 	c.constants["hostname"] = strings.SplitN(hostname, `.`, 2)[0]
@@ -120,14 +123,12 @@ 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)
-	for k, v := range c.constants {
+	maps.Copy(vars, c.constants)
-		vars[k] = v
-	}
 	vars["starttime"] = starttime
 	vars["endtime"] = endtime
 	for _, f := range c.functions {
-		cclog.ComponentDebug("MetricCache", "COLLECT", f.Name, "COND", f.Condition)
+		cclog.ComponentDebugf("MetricCache", "COLLECT %s COND '%s'", f.Name, f.Condition)
 		var valuesFloat64 []float64
 		var valuesFloat32 []float32
 		var valuesInt []int
@@ -137,10 +138,9 @@ func (c *metricAggregator) Eval(starttime time.Time, endtime time.Time, metrics
 		matches := make([]lp.CCMessage, 0)
 		for _, m := range metrics {
 			vars["metric"] = m
-			//value, err := gval.Evaluate(f.Condition, vars, c.language)
 			value, err := f.gvalCond.EvalBool(context.Background(), vars)
 			if err != nil {
-				cclog.ComponentError("MetricCache", "COLLECT", f.Name, "COND", f.Condition, ":", err.Error())
+				cclog.ComponentErrorf("MetricCache", "COLLECT %s COND '%s' : %s", f.Name, f.Condition, err.Error())
 				continue
 			}
 			if value {
@@ -160,7 +160,7 @@ func (c *metricAggregator) Eval(starttime time.Time, endtime time.Time, metrics
 					case bool:
 						valuesBool = append(valuesBool, x)
 					default:
-						cclog.ComponentError("MetricCache", "COLLECT ADD VALUE", v, "FAILED")
+						cclog.ComponentErrorf("MetricCache", "COLLECT ADD VALUE %v FAILED", v)
 					}
 				}
 				matches = append(matches, m)
@@ -171,22 +171,22 @@ func (c *metricAggregator) Eval(starttime time.Time, endtime time.Time, metrics
 		// Check, that only values of one type were collected
 		countValueTypes := 0
 		if len(valuesFloat64) > 0 {
-			countValueTypes += 1
+			countValueTypes++
 		}
 		if len(valuesFloat32) > 0 {
-			countValueTypes += 1
+			countValueTypes++
 		}
 		if len(valuesInt) > 0 {
-			countValueTypes += 1
+			countValueTypes++
 		}
 		if len(valuesInt32) > 0 {
-			countValueTypes += 1
+			countValueTypes++
 		}
 		if len(valuesInt64) > 0 {
-			countValueTypes += 1
+			countValueTypes++
 		}
 		if len(valuesBool) > 0 {
-			countValueTypes += 1
+			countValueTypes++
 		}
 		if countValueTypes > 1 {
 			cclog.ComponentError("MetricCache", "Collected values of different types")
@@ -213,13 +213,13 @@ func (c *metricAggregator) Eval(starttime time.Time, endtime time.Time, metrics
 			vars["values"] = valuesBool
 			len_values = len(valuesBool)
 		}
-		cclog.ComponentDebug("MetricCache", "EVALUATE", f.Name, "METRICS", len_values, "CALC", f.Function)
+		cclog.ComponentDebugf("MetricCache", "EVALUATE %s METRICS %d CALC '%s'", f.Name, len_values, f.Function)
 
 		vars["metrics"] = matches
 		if len_values > 0 {
 			value, err := gval.Evaluate(f.Function, vars, c.language)
 			if err != nil {
-				cclog.ComponentError("MetricCache", "EVALUATE", f.Name, "METRICS", len_values, "CALC", f.Function, ":", err.Error())
+				cclog.ComponentErrorf("MetricCache", "EVALUATE %s METRICS %d CALC '%s': %s", f.Name, len_values, f.Function, err.Error())
 				break
 			}
 
@@ -263,22 +263,22 @@ 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)
+				cclog.ComponentErrorf("MetricCache", "Gval returned invalid type %s skipping metric %s", t, f.Name)
 			}
 			if err != nil {
-				cclog.ComponentError("MetricCache", "Cannot create metric from Gval result", value, ":", err.Error())
+				cclog.ComponentErrorf("MetricCache", "Cannot create metric from Gval result %v: %s", value, err.Error())
 			}
-			cclog.ComponentDebug("MetricCache", "SEND", m)
+			cclog.ComponentDebugf("MetricCache", "SEND %s", m.ToLineProtocol(nil))
 			select {
 			case c.output <- m:
 			default:
@@ -295,12 +295,12 @@ func (c *metricAggregator) AddAggregation(name, function, condition string, tags
 	newcond := strings.ReplaceAll(condition, "'", "\"")
 	gvalCond, err := gval.Full(metricCacheLanguage).NewEvaluable(newcond)
 	if err != nil {
-		cclog.ComponentError("MetricAggregator", "Cannot add aggregation, invalid if condition", newcond, ":", err.Error())
+		cclog.ComponentErrorf("MetricAggregator", "Cannot add aggregation, invalid if condition '%s': %s", newcond, err.Error())
 		return err
 	}
 	gvalFunc, err := gval.Full(metricCacheLanguage).NewEvaluable(newfunc)
 	if err != nil {
-		cclog.ComponentError("MetricAggregator", "Cannot add aggregation, invalid function condition", newfunc, ":", err.Error())
+		cclog.ComponentErrorf("MetricAggregator", "Cannot add aggregation, invalid function condition %s: %s", newfunc, err.Error())
 		return err
 	}
 	for _, agg := range c.functions {
@@ -329,18 +329,21 @@ func (c *metricAggregator) AddAggregation(name, function, condition string, tags
 }
 
 func (c *metricAggregator) DeleteAggregation(name string) error {
-	for i, agg := range c.functions {
+	i := slices.IndexFunc(
-		if agg.Name == name {
+		c.functions,
-			copy(c.functions[i:], c.functions[i+1:])
+		func(agg *MetricAggregatorIntervalConfig) bool {
-			c.functions[len(c.functions)-1] = nil
+			return agg.Name == name
-			c.functions = c.functions[:len(c.functions)-1]
+		})
-			return nil
+	if i == -1 {
-		}
+		return fmt.Errorf("no aggregation for metric name %s", name)
 	}
-	return fmt.Errorf("no aggregation for metric name %s", 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
 }
 
-func (c *metricAggregator) AddConstant(name string, value interface{}) {
+func (c *metricAggregator) AddConstant(name string, value any) {
 	c.constants[name] = value
 }
 
@@ -348,19 +351,18 @@ 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()
 	if !ok {
-		newcond :=
+		newcond := strings.ReplaceAll(
 			strings.ReplaceAll(
-				strings.ReplaceAll(
+				condition, "'", "\""), "%", "\\")
-					condition, "'", "\""), "%", "\\")
 		var err error
 		evaluable, err = language.NewEvaluable(newcond)
 		if err != nil {
@@ -379,10 +381,9 @@ func EvalFloat64Condition(condition string, params map[string]float64) (float64,
 	evaluable, ok := evaluables.mapping[condition]
 	evaluables.mutex.Unlock()
 	if !ok {
-		newcond :=
+		newcond := strings.ReplaceAll(
 			strings.ReplaceAll(
-				strings.ReplaceAll(
+				condition, "'", "\""), "%", "\\")
-					condition, "'", "\""), "%", "\\")
 		var err error
 		evaluable, err = language.NewEvaluable(newcond)
 		if err != nil {

internal/metricAggregator/metricAggregatorFunctions.go

@@ -11,10 +11,10 @@ import (
 	"errors"
 	"fmt"
 	"regexp"
+	"slices"
+	"strconv"
 	"strings"
 
-	"golang.org/x/exp/slices"
-
 	topo "github.com/ClusterCockpit/cc-metric-collector/pkg/ccTopology"
 )
 
@@ -34,8 +34,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) {
 	case []float64:
@@ -63,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)
@@ -84,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)
@@ -114,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)
@@ -146,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)
@@ -167,9 +166,9 @@ 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
+	var err error
-	var length int = 0
+	length := 0
 	switch values := args.(type) {
 	case []float64:
 		length = len(values)
@@ -181,13 +180,7 @@ func lenfunc(args interface{}) (interface{}, error) {
 		length = len(values)
 	case []int32:
 		length = len(values)
-	case float64:
+	case float64, float32, int, int64:
-		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:
 		err = errors.New("function 'len' can only be applied on arrays and strings")
 	case string:
 		length = len(values)
@@ -197,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) {
@@ -213,13 +206,9 @@ func infunc(a interface{}, b interface{}) (interface{}, error) {
 	case int:
 		switch total := b.(type) {
 		case []int:
-			for _, x := range total {
+			return slices.Contains(total, match), nil
-				if x == match {
-					return true, nil
-				}
-			}
 		case string:
-			smatch := fmt.Sprintf("%d", match)
+			smatch := strconv.Itoa(match)
 			return strings.Contains(total, smatch), nil
 		}
 
@@ -233,12 +222,12 @@ 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) {
 		case string:
-			smatch := strings.Replace(match, "%", "\\", -1)
+			smatch := strings.ReplaceAll(match, "%", "\\")
 			regex, err := regexp.Compile(smatch)
 			if err != nil {
 				return false, err
@@ -255,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
@@ -264,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
@@ -273,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
@@ -282,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
@@ -291,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:
@@ -305,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:
@@ -319,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:
@@ -333,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:
@@ -347,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:

internal/metricRouter/metricCache.go

@@ -8,12 +8,13 @@
 package metricRouter
 
 import (
+	"fmt"
 	"sync"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
 
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
 	agg "github.com/ClusterCockpit/cc-metric-collector/internal/metricAggregator"
 	mct "github.com/ClusterCockpit/cc-metric-collector/pkg/multiChanTicker"
 )
@@ -51,7 +52,7 @@ type MetricCache interface {
 }
 
 func (c *metricCache) Init(output chan lp.CCMessage, ticker mct.MultiChanTicker, wg *sync.WaitGroup, numPeriods int) error {
-	var err error = nil
+	var err error
 	c.done = make(chan bool)
 	c.wg = wg
 	c.ticker = ticker
@@ -70,8 +71,7 @@ func (c *metricCache) Init(output chan lp.CCMessage, ticker mct.MultiChanTicker,
 	// The code is executed by the MetricCache goroutine
 	c.aggEngine, err = agg.NewAggregator(c.output)
 	if err != nil {
-		cclog.ComponentError("MetricCache", "Cannot create aggregator")
+		return fmt.Errorf("MetricCache: failed to create aggregator: %w", err)
-		return err
 	}
 
 	return nil
@@ -79,7 +79,6 @@ func (c *metricCache) Init(output chan lp.CCMessage, ticker mct.MultiChanTicker,
 
 // Start starts the metric cache
 func (c *metricCache) Start() {
-
 	c.tickchan = make(chan time.Time)
 	c.ticker.AddChannel(c.tickchan)
 	// Router cache is done
@@ -102,9 +101,7 @@ func (c *metricCache) Start() {
 		return oldPeriod
 	}
 
-	c.wg.Add(1)
+	c.wg.Go(func() {
-	go func() {
-		defer c.wg.Done()
 		for {
 			select {
 			case <-c.done:
@@ -124,7 +121,7 @@ func (c *metricCache) Start() {
 				}
 			}
 		}
-	}()
+	})
 	cclog.ComponentDebug("MetricCache", "START")
 }
 
@@ -137,12 +134,12 @@ func (c *metricCache) Add(metric lp.CCMessage) {
 		p := c.intervals[c.curPeriod]
 		if p.numMetrics < p.sizeMetrics {
 			p.metrics[p.numMetrics] = metric
-			p.numMetrics = p.numMetrics + 1
+			p.numMetrics++
 			p.stopstamp = metric.Time()
 		} else {
 			p.metrics = append(p.metrics, metric)
-			p.numMetrics = p.numMetrics + 1
+			p.numMetrics++
-			p.sizeMetrics = p.sizeMetrics + 1
+			p.sizeMetrics++
 			p.stopstamp = metric.Time()
 		}
 		c.lock.Unlock()
@@ -161,8 +158,8 @@ func (c *metricCache) DeleteAggregation(name string) error {
 // is the current one, index=1 the last interval and so on. Returns and empty array if a wrong index
 // is given (negative index, index larger than configured number of total intervals, ...)
 func (c *metricCache) GetPeriod(index int) (time.Time, time.Time, []lp.CCMessage) {
-	var start time.Time = time.Now()
+	start := time.Now()
-	var stop time.Time = time.Now()
+	stop := time.Now()
 	var metrics []lp.CCMessage
 	if index >= 0 && index < c.numPeriods {
 		pindex := c.curPeriod - index
@@ -173,7 +170,6 @@ func (c *metricCache) GetPeriod(index int) (time.Time, time.Time, []lp.CCMessage
 			start = c.intervals[pindex].startstamp
 			stop = c.intervals[pindex].stopstamp
 			metrics = c.intervals[pindex].metrics
-			//return c.intervals[pindex].startstamp, c.intervals[pindex].stopstamp, c.intervals[pindex].metrics
 		} else {
 			metrics = make([]lp.CCMessage, 0)
 		}

internal/metricRouter/metricRouter.go

@@ -8,17 +8,18 @@
 package metricRouter
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
+	"maps"
 	"os"
 	"strings"
 	"sync"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-
+	lp "github.com/ClusterCockpit/cc-lib/v2/ccMessage"
-	lp "github.com/ClusterCockpit/cc-lib/ccMessage"
+	mp "github.com/ClusterCockpit/cc-lib/v2/messageProcessor"
-	mp "github.com/ClusterCockpit/cc-lib/messageProcessor"
 	agg "github.com/ClusterCockpit/cc-metric-collector/internal/metricAggregator"
 	mct "github.com/ClusterCockpit/cc-metric-collector/pkg/multiChanTicker"
 )
@@ -46,8 +47,7 @@ type metricRouterConfig struct {
 	MaxForward        int                                  `json:"max_forward"`         // Number of maximal forwarded metrics at one select
 	NormalizeUnits    bool                                 `json:"normalize_units"`     // Check unit meta flag and normalize it using cc-units
 	ChangeUnitPrefix  map[string]string                    `json:"change_unit_prefix"`  // Add prefix that should be applied to the metrics
-	// dropMetrics       map[string]bool                      // Internal map for O(1) lookup
+	MessageProcessor  json.RawMessage                      `json:"process_messages,omitempty"`
-	MessageProcessor json.RawMessage `json:"process_messages,omitempty"`
 }
 
 // Metric router data structure
@@ -102,76 +102,93 @@ func (r *metricRouter) Init(ticker mct.MultiChanTicker, wg *sync.WaitGroup, rout
 	// Drop domain part of host name
 	r.hostname = strings.SplitN(hostname, `.`, 2)[0]
 
-	err = json.Unmarshal(routerConfig, &r.config)
+	d := json.NewDecoder(bytes.NewReader(routerConfig))
-	if err != nil {
+	d.DisallowUnknownFields()
-		cclog.ComponentError("MetricRouter", err.Error())
+	if err := d.Decode(&r.config); err != nil {
-		return err
+		return fmt.Errorf("failed to decode metric router config: %w", err)
-	}
-	r.maxForward = 1
-	if r.config.MaxForward > r.maxForward {
-		r.maxForward = r.config.MaxForward
 	}
+	r.maxForward = max(1, r.config.MaxForward)
+
 	if r.config.NumCacheIntervals > 0 {
 		r.cache, err = NewCache(r.cache_input, r.ticker, &r.cachewg, r.config.NumCacheIntervals)
 		if err != nil {
-			cclog.ComponentError("MetricRouter", "MetricCache initialization failed:", err.Error())
+			return fmt.Errorf("MetricRouter: failed to initialize MetricCache: %w", err)
-			return err
 		}
 		for _, agg := range r.config.IntervalAgg {
-			r.cache.AddAggregation(agg.Name, agg.Function, agg.Condition, agg.Tags, agg.Meta)
+			err = r.cache.AddAggregation(agg.Name, agg.Function, agg.Condition, agg.Tags, agg.Meta)
+			if err != nil {
+				return fmt.Errorf("MetricCache AddAggregation() failed: %w", err)
+			}
 		}
 	}
 	p, err := mp.NewMessageProcessor()
 	if err != nil {
-		return fmt.Errorf("initialization of message processor failed: %v", err.Error())
+		return fmt.Errorf("MessageProcessor NewMessageProcessor() failed: %w", err)
 	}
 	r.mp = p
 
 	if len(r.config.MessageProcessor) > 0 {
 		err = r.mp.FromConfigJSON(r.config.MessageProcessor)
 		if err != nil {
-			return fmt.Errorf("failed parsing JSON for message processor: %v", err.Error())
+			return fmt.Errorf("MessageProcessor FromConfigJSON() failed: %w", err)
 		}
 	}
 	for _, mname := range r.config.DropMetrics {
-		r.mp.AddDropMessagesByName(mname)
+		err = r.mp.AddDropMessagesByName(mname)
+		if err != nil {
+			return fmt.Errorf("MessageProcessor AddDropMessagesByName() failed: %w", err)
+		}
 	}
 	for _, cond := range r.config.DropMetricsIf {
-		r.mp.AddDropMessagesByCondition(cond)
+		err = r.mp.AddDropMessagesByCondition(cond)
+		if err != nil {
+			return fmt.Errorf("MessageProcessor AddDropMessagesByCondition() failed: %w", err)
+		}
 	}
 	for _, data := range r.config.AddTags {
 		cond := data.Condition
 		if cond == "*" {
 			cond = "true"
 		}
-		r.mp.AddAddTagsByCondition(cond, data.Key, data.Value)
+		err = r.mp.AddAddTagsByCondition(cond, data.Key, data.Value)
+		if err != nil {
+			return fmt.Errorf("MessageProcessor AddAddTagsByCondition() failed: %w", err)
+		}
 	}
 	for _, data := range r.config.DelTags {
 		cond := data.Condition
 		if cond == "*" {
 			cond = "true"
 		}
-		r.mp.AddDeleteTagsByCondition(cond, data.Key, data.Value)
+		err = r.mp.AddDeleteTagsByCondition(cond, data.Key, data.Value)
+		if err != nil {
+			return fmt.Errorf("MessageProcessor AddDeleteTagsByCondition() failed: %w", err)
+		}
 	}
 	for oldname, newname := range r.config.RenameMetrics {
-		r.mp.AddRenameMetricByName(oldname, newname)
+		err = r.mp.AddRenameMetricByName(oldname, newname)
+		if err != nil {
+			return fmt.Errorf("MessageProcessor AddRenameMetricByName() failed: %w", err)
+		}
 	}
 	for metricName, prefix := range r.config.ChangeUnitPrefix {
-		r.mp.AddChangeUnitPrefix(fmt.Sprintf("name == '%s'", metricName), prefix)
+		err = r.mp.AddChangeUnitPrefix(fmt.Sprintf("name == '%s'", metricName), prefix)
+		if err != nil {
+			return fmt.Errorf("MessageProcessor AddChangeUnitPrefix() failed: %w", err)
+		}
 	}
 	r.mp.SetNormalizeUnits(r.config.NormalizeUnits)
 
-	r.mp.AddAddTagsByCondition("true", r.config.HostnameTagName, r.hostname)
+	err = r.mp.AddAddTagsByCondition("!msg.HasTag('"+r.config.HostnameTagName+"')", r.config.HostnameTagName, r.hostname)
+	if err != nil {
+		return fmt.Errorf("MessageProcessor AddAddTagsByCondition() failed: %w", err)
+	}
 
-	// r.config.dropMetrics = make(map[string]bool)
-	// for _, mname := range r.config.DropMetrics {
-	// 	r.config.dropMetrics[mname] = true
-	// }
 	return nil
 }
 
-func getParamMap(point lp.CCMessage) map[string]interface{} {
+func getParamMap(point lp.CCMessage) map[string]any {
-	params := make(map[string]interface{})
+	params := make(map[string]any)
 	params["metric"] = point
 	params["name"] = point.Name()
 	for key, value := range point.Tags() {
@@ -180,14 +197,12 @@ func getParamMap(point lp.CCMessage) map[string]interface{} {
 	for key, value := range point.Meta() {
 		params[key] = value
 	}
-	for key, value := range point.Fields() {
+	maps.Copy(params, point.Fields())
-		params[key] = value
-	}
 	params["timestamp"] = point.Time()
 	return params
 }
 
-// DoAddTags adds a tag when condition is fullfiled
+// DoAddTags adds a tag when condition is fulfilled
 func (r *metricRouter) DoAddTags(point lp.CCMessage) {
 	var conditionMatches bool
 	for _, m := range r.config.AddTags {
@@ -209,83 +224,6 @@ func (r *metricRouter) DoAddTags(point lp.CCMessage) {
 	}
 }
 
-// DoDelTags removes a tag when condition is fullfiled
-// func (r *metricRouter) DoDelTags(point lp.CCMessage) {
-// 	var conditionMatches bool
-// 	for _, m := range r.config.DelTags {
-// 		if m.Condition == "*" {
-// 			// Condition is always matched
-// 			conditionMatches = true
-// 		} else {
-// 			// Evaluate condition
-// 			var err error
-// 			conditionMatches, err = agg.EvalBoolCondition(m.Condition, getParamMap(point))
-// 			if err != nil {
-// 				cclog.ComponentError("MetricRouter", err.Error())
-// 				conditionMatches = false
-// 			}
-// 		}
-// 		if conditionMatches {
-// 			point.RemoveTag(m.Key)
-// 		}
-// 	}
-// }
-
-// Conditional test whether a metric should be dropped
-// func (r *metricRouter) dropMetric(point lp.CCMessage) bool {
-// 	// Simple drop check
-// 	if conditionMatches, ok := r.config.dropMetrics[point.Name()]; ok {
-// 		return conditionMatches
-// 	}
-
-// 	// Checking the dropping conditions
-// 	for _, m := range r.config.DropMetricsIf {
-// 		conditionMatches, err := agg.EvalBoolCondition(m, getParamMap(point))
-// 		if err != nil {
-// 			cclog.ComponentError("MetricRouter", err.Error())
-// 			conditionMatches = false
-// 		}
-// 		if conditionMatches {
-// 			return conditionMatches
-// 		}
-// 	}
-
-// 	// No dropping condition met
-// 	return false
-// }
-
-// func (r *metricRouter) prepareUnit(point lp.CCMessage) bool {
-// 	if r.config.NormalizeUnits {
-// 		if in_unit, ok := point.GetMeta("unit"); ok {
-// 			u := units.NewUnit(in_unit)
-// 			if u.Valid() {
-// 				point.AddMeta("unit", u.Short())
-// 			}
-// 		}
-// 	}
-// 	if newP, ok := r.config.ChangeUnitPrefix[point.Name()]; ok {
-
-// 		newPrefix := units.NewPrefix(newP)
-
-// 		if in_unit, ok := point.GetMeta("unit"); ok && newPrefix != units.InvalidPrefix {
-// 			u := units.NewUnit(in_unit)
-// 			if u.Valid() {
-// 				cclog.ComponentDebug("MetricRouter", "Change prefix to", newP, "for metric", point.Name())
-// 				conv, out_unit := units.GetUnitPrefixFactor(u, newPrefix)
-// 				if conv != nil && out_unit.Valid() {
-// 					if val, ok := point.GetField("value"); ok {
-// 						point.AddField("value", conv(val))
-// 						point.AddMeta("unit", out_unit.Short())
-// 					}
-// 				}
-// 			}
-
-// 		}
-// 	}
-
-// 	return true
-// }
-
 // Start starts the metric router
 func (r *metricRouter) Start() {
 	// start timer if configured
@@ -301,31 +239,9 @@ func (r *metricRouter) Start() {
 		cclog.ComponentDebug("MetricRouter", "DONE")
 	}
 
-	// Forward takes a received metric, adds or deletes tags
+	// Forward message received from collector channel
-	// and forwards it to the output channels
-	// forward := func(point lp.CCMessage) {
-	// 	cclog.ComponentDebug("MetricRouter", "FORWARD", point)
-	// 	r.DoAddTags(point)
-	// 	r.DoDelTags(point)
-	// 	name := point.Name()
-	// 	if new, ok := r.config.RenameMetrics[name]; ok {
-	// 		point.SetName(new)
-	// 		point.AddMeta("oldname", name)
-	// 		r.DoAddTags(point)
-	// 		r.DoDelTags(point)
-	// 	}
-
-	// 	r.prepareUnit(point)
-
-	// 	for _, o := range r.outputs {
-	// 		o <- point
-	// 	}
-	// }
-
-	// Foward message received from collector channel
 	coll_forward := func(p lp.CCMessage) {
 		// receive from metric collector
-		//p.AddTag(r.config.HostnameTagName, r.hostname)
 		if r.config.IntervalStamp {
 			p.SetTime(r.timestamp)
 		}
@@ -335,11 +251,6 @@ func (r *metricRouter) Start() {
 				o <- m
 			}
 		}
-		// if !r.dropMetric(p) {
-		// 	for _, o := range r.outputs {
-		// 		o <- point
-		// 	}
-		// }
 		// even if the metric is dropped, it is stored in the cache for
 		// aggregations
 		if r.config.NumCacheIntervals > 0 {
@@ -359,9 +270,6 @@ func (r *metricRouter) Start() {
 				o <- m
 			}
 		}
-		// if !r.dropMetric(p) {
-		// 	forward(p)
-		// }
 	}
 
 	// Forward message received from cache channel
@@ -380,10 +288,7 @@ func (r *metricRouter) Start() {
 		r.cache.Start()
 	}
 
-	r.wg.Add(1)
+	r.wg.Go(func() {
-	go func() {
-		defer r.wg.Done()
-
 		for {
 			select {
 			case <-r.done:
@@ -413,7 +318,7 @@ func (r *metricRouter) Start() {
 				}
 			}
 		}
-	}()
+	})
 	cclog.ComponentDebug("MetricRouter", "STARTED")
 }
 

pkg/ccTopology/ccTopology.go

@@ -13,11 +13,11 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"slices"
 	"strconv"
 	"strings"
 
-	cclogger "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclogger "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
-	"golang.org/x/exp/slices"
 )
 
 const SYSFS_CPUBASE = `/sys/devices/system/cpu`
@@ -51,14 +51,13 @@ var cache struct {
 func fileToInt(path string) int {
 	buffer, err := os.ReadFile(path)
 	if err != nil {
-		log.Print(err)
+		cclogger.ComponentError("ccTopology", fmt.Sprintf("fileToInt(): Reading \"%s\": %v", path, err))
-		cclogger.ComponentError("ccTopology", "fileToInt", "Reading", path, ":", err.Error())
 		return -1
 	}
 	stringBuffer := strings.TrimSpace(string(buffer))
 	id, err := strconv.Atoi(stringBuffer)
 	if err != nil {
-		cclogger.ComponentError("ccTopology", "fileToInt", "Parsing", path, ":", stringBuffer, err.Error())
+		cclogger.ComponentError("ccTopology", fmt.Sprintf("fileToInt(): Parsing \"%s\": %v", stringBuffer, err))
 		return -1
 	}
 	return id
@@ -80,7 +79,7 @@ func fileToList(path string) []int {
 	// Create list
 	list := make([]int, 0)
 	stringBuffer := strings.TrimSpace(string(buffer))
-	for _, valueRangeString := range strings.Split(stringBuffer, ",") {
+	for valueRangeString := range strings.SplitSeq(stringBuffer, ",") {
 		valueRange := strings.Split(valueRangeString, "-")
 		switch len(valueRange) {
 		case 1:
@@ -112,79 +111,76 @@ func fileToList(path string) []int {
 
 // init initializes the cache structure
 func init() {
+	getHWThreads := func() []int {
+		globPath := filepath.Join(SYSFS_CPUBASE, "cpu[0-9]*")
+		regexPath := filepath.Join(SYSFS_CPUBASE, "cpu([[:digit:]]+)")
+		regex := regexp.MustCompile(regexPath)
 
-	getHWThreads :=
+		// File globbing for hardware threads
-		func() []int {
+		files, err := filepath.Glob(globPath)
-			globPath := filepath.Join(SYSFS_CPUBASE, "cpu[0-9]*")
+		if err != nil {
-			regexPath := filepath.Join(SYSFS_CPUBASE, "cpu([[:digit:]]+)")
+			cclogger.ComponentError("CCTopology", "init:getHWThreads", err.Error())
-			regex := regexp.MustCompile(regexPath)
+			return nil
+		}
 
-			// File globbing for hardware threads
+		hwThreadIDs := make([]int, len(files))
-			files, err := filepath.Glob(globPath)
+		for i, file := range files {
-			if err != nil {
+			// Extract hardware thread ID
-				cclogger.ComponentError("CCTopology", "init:getHWThreads", err.Error())
+			matches := regex.FindStringSubmatch(file)
+			if len(matches) != 2 {
+				cclogger.ComponentError("CCTopology", "init:getHWThreads: Failed to extract hardware thread ID from ", file)
 				return nil
 			}
 
-			hwThreadIDs := make([]int, len(files))
+			// Convert hardware thread ID to int
-			for i, file := range files {
-				// Extract hardware thread ID
-				matches := regex.FindStringSubmatch(file)
-				if len(matches) != 2 {
-					cclogger.ComponentError("CCTopology", "init:getHWThreads: Failed to extract hardware thread ID from ", file)
-					return nil
-				}
-
-				// Convert hardware thread ID to int
-				id, err := strconv.Atoi(matches[1])
-				if err != nil {
-					cclogger.ComponentError("CCTopology", "init:getHWThreads: Failed to convert to int hardware thread ID ", matches[1])
-					return nil
-				}
-
-				hwThreadIDs[i] = id
-			}
-
-			// Sort hardware thread IDs
-			slices.Sort(hwThreadIDs)
-			return hwThreadIDs
-		}
-
-	getNumaDomain :=
-		func(basePath string) int {
-			globPath := filepath.Join(basePath, "node*")
-			regexPath := filepath.Join(basePath, "node([[:digit:]]+)")
-			regex := regexp.MustCompile(regexPath)
-
-			// File globbing for NUMA node
-			files, err := filepath.Glob(globPath)
-			if err != nil {
-				cclogger.ComponentError("CCTopology", "init:getNumaDomain", err.Error())
-				return -1
-			}
-
-			// Check, that exactly one NUMA domain was found
-			if len(files) != 1 {
-				cclogger.ComponentError("CCTopology", "init:getNumaDomain", "Number of NUMA domains != 1: ", len(files))
-				return -1
-			}
-
-			// Extract NUMA node ID
-			matches := regex.FindStringSubmatch(files[0])
-			if len(matches) != 2 {
-				cclogger.ComponentError("CCTopology", "init:getNumaDomain", "Failed to extract NUMA node ID from: ", files[0])
-				return -1
-			}
-
 			id, err := strconv.Atoi(matches[1])
 			if err != nil {
-				cclogger.ComponentError("CCTopology", "init:getNumaDomain", "Failed to parse NUMA node ID from: ", matches[1])
+				cclogger.ComponentError("CCTopology", "init:getHWThreads: Failed to convert to int hardware thread ID ", matches[1])
-				return -1
+				return nil
 			}
 
-			return id
+			hwThreadIDs[i] = id
 		}
 
+		// Sort hardware thread IDs
+		slices.Sort(hwThreadIDs)
+		return hwThreadIDs
+	}
+
+	getNumaDomain := func(basePath string) int {
+		globPath := filepath.Join(basePath, "node*")
+		regexPath := filepath.Join(basePath, "node([[:digit:]]+)")
+		regex := regexp.MustCompile(regexPath)
+
+		// File globbing for NUMA node
+		files, err := filepath.Glob(globPath)
+		if err != nil {
+			cclogger.ComponentError("CCTopology", "init:getNumaDomain", err.Error())
+			return -1
+		}
+
+		// Check, that exactly one NUMA domain was found
+		if len(files) != 1 {
+			cclogger.ComponentError("CCTopology", "init:getNumaDomain", "Number of NUMA domains != 1: ", len(files))
+			return -1
+		}
+
+		// Extract NUMA node ID
+		matches := regex.FindStringSubmatch(files[0])
+		if len(matches) != 2 {
+			cclogger.ComponentError("CCTopology", "init:getNumaDomain", "Failed to extract NUMA node ID from: ", files[0])
+			return -1
+		}
+
+		id, err := strconv.Atoi(matches[1])
+		if err != nil {
+			cclogger.ComponentError("CCTopology", "init:getNumaDomain", "Failed to parse NUMA node ID from: ", matches[1])
+			return -1
+		}
+
+		return id
+	}
+
 	cache.HwthreadList = getHWThreads()
 	cache.CoreList = make([]int, len(cache.HwthreadList))
 	cache.SocketList = make([]int, len(cache.HwthreadList))
@@ -219,16 +215,15 @@ func init() {
 		// Lookup NUMA domain id
 		cache.NumaDomainList[i] = getNumaDomain(cpuBase)
 
-		cache.CpuData[i] =
+		cache.CpuData[i] = HwthreadEntry{
-			HwthreadEntry{
+			CpuID:        cache.HwthreadList[i],
-				CpuID:        cache.HwthreadList[i],
+			SMT:          cache.SMTList[i],
-				SMT:          cache.SMTList[i],
+			CoreCPUsList: coreCPUsList,
-				CoreCPUsList: coreCPUsList,
+			Socket:       cache.SocketList[i],
-				Socket:       cache.SocketList[i],
+			NumaDomain:   cache.NumaDomainList[i],
-				NumaDomain:   cache.NumaDomainList[i],
+			Die:          cache.DieList[i],
-				Die:          cache.DieList[i],
+			Core:         cache.CoreList[i],
-				Core:         cache.CoreList[i],
+		}
-			}
 	}
 
 	slices.Sort(cache.HwthreadList)
@@ -260,12 +255,6 @@ func HwthreadList() []int {
 	return slices.Clone(cache.HwthreadList)
 }
 
-// Get list of hardware thread IDs in the order of listing in /proc/cpuinfo
-// Deprecated! Use HwthreadList()
-func CpuList() []int {
-	return HwthreadList()
-}
-
 // CoreList gets the list of CPU core IDs in the order of listing in /proc/cpuinfo
 func CoreList() []int {
 	return slices.Clone(cache.CoreList)
@@ -304,20 +293,19 @@ func GetTypeList(topology_type string) []int {
 }
 
 func GetTypeId(hwt HwthreadEntry, topology_type string) (int, error) {
-	var err error = nil
 	switch topology_type {
 	case "node":
-		return 0, err
+		return 0, nil
 	case "socket":
-		return hwt.Socket, err
+		return hwt.Socket, nil
 	case "die":
-		return hwt.Die, err
+		return hwt.Die, nil
 	case "memoryDomain":
-		return hwt.NumaDomain, err
+		return hwt.NumaDomain, nil
 	case "core":
-		return hwt.Core, err
+		return hwt.Core, nil
 	case "hwthread":
-		return hwt.CpuID, err
+		return hwt.CpuID, nil
 	}
 	return -1, fmt.Errorf("unknown topology type '%s'", topology_type)
 }

pkg/multiChanTicker/multiChanTicker.go

@@ -10,7 +10,7 @@ package multiChanTicker
 import (
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-lib/ccLogger"
+	cclog "github.com/ClusterCockpit/cc-lib/v2/ccLogger"
 )
 
 type multiChanTicker struct {
@@ -21,7 +21,7 @@ type multiChanTicker struct {
 
 type MultiChanTicker interface {
 	Init(duration time.Duration)
-	AddChannel(chan time.Time)
+	AddChannel(channel chan time.Time)
 	Close()
 }
 

scripts/cc-metric-collector.deb.control

@@ -6,7 +6,7 @@ Installed-Size: {INSTALLED_SIZE}
 Architecture: {ARCH}
 Maintainer: thomas.gruber@fau.de
 Depends: libc6 (>= 2.2.1)
-Build-Depends: debhelper-compat (= 13), git, golang-go
+Build-Depends: debhelper-compat (= 13), git, golang-go, libdrm-dev
 Description: Metric collection daemon from the ClusterCockpit suite
 Homepage: https://github.com/ClusterCockpit/cc-metric-collector
 Source: cc-metric-collector

scripts/cc-metric-collector.spec

@@ -29,12 +29,12 @@ make
 
 
 %install
-install -Dpm 0750 %{name} %{buildroot}%{_bindir}/%{name}
+install -Dpm 0755 %{name} %{buildroot}%{_bindir}/%{name}
-install -Dpm 0600 config.json %{buildroot}%{_sysconfdir}/%{name}/%{name}.json
+install -Dpm 0600 example-configs/config.json %{buildroot}%{_sysconfdir}/%{name}/%{name}.json
-install -Dpm 0600 collectors.json %{buildroot}%{_sysconfdir}/%{name}/collectors.json
+install -Dpm 0600 example-configs/collectors.json %{buildroot}%{_sysconfdir}/%{name}/collectors.json
-install -Dpm 0600 sinks.json %{buildroot}%{_sysconfdir}/%{name}/sinks.json
+install -Dpm 0600 example-configs/sinks.json %{buildroot}%{_sysconfdir}/%{name}/sinks.json
-install -Dpm 0600 receivers.json %{buildroot}%{_sysconfdir}/%{name}/receivers.json
+install -Dpm 0600 example-configs/receivers.json %{buildroot}%{_sysconfdir}/%{name}/receivers.json
-install -Dpm 0600 router.json %{buildroot}%{_sysconfdir}/%{name}/router.json
+install -Dpm 0600 example-configs/router.json %{buildroot}%{_sysconfdir}/%{name}/router.json
 install -Dpm 0644 scripts/%{name}.service %{buildroot}%{_unitdir}/%{name}.service
 install -Dpm 0600 scripts/%{name}.config %{buildroot}%{_sysconfdir}/default/%{name}
 install -Dpm 0644 scripts/%{name}.sysusers %{buildroot}%{_sysusersdir}/%{name}.conf
@@ -54,7 +54,7 @@ install -Dpm 0644 scripts/%{name}.sysusers %{buildroot}%{_sysusersdir}/%{name}.c
 
 %files
 # Binary
-%attr(-,clustercockpit,clustercockpit) %{_bindir}/%{name}
+%attr(-,root,root) %{_bindir}/%{name}
 # Config
 %dir %{_sysconfdir}/%{name}
 %attr(0600,clustercockpit,clustercockpit) %config(noreplace) %{_sysconfdir}/%{name}/%{name}.json