Fix startup error of iostat collector

2025-12-13 11:06:16 +01:00 · 2025-10-20 17:03:55 +02:00
13 changed files with 514 additions and 526 deletions
--- a/.github/workflows/Release.yml
+++ b/.github/workflows/Release.yml
@@ -126,11 +126,11 @@ jobs:
    - name: Setup Golang
      run: |
          dnf --assumeyes --disableplugin=subscription-manager install \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/go-toolset-1.25.3-1.el9_7.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-1.25.3-1.el9_7.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-bin-1.25.3-1.el9_7.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-src-1.25.3-1.el9_7.noarch.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-race-1.25.3-1.el9_7.x86_64.rpm
+              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
@@ -262,11 +262,11 @@ jobs:
    - name: Setup Golang
      run: |
          dnf --assumeyes --disableplugin=subscription-manager install \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/go-toolset-1.25.3-1.el9_7.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-1.25.3-1.el9_7.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-bin-1.25.3-1.el9_7.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-src-1.25.3-1.el9_7.noarch.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-race-1.25.3-1.el9_7.x86_64.rpm
+              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
--- a/.github/workflows/runonce.yml
+++ b/.github/workflows/runonce.yml
@@ -116,11 +116,11 @@ jobs:
    - name: Setup Golang
      run: |
          dnf --assumeyes --disableplugin=subscription-manager install \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/go-toolset-1.25.3-1.el9_7.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-1.25.3-1.el9_7.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-bin-1.25.3-1.el9_7.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-src-1.25.3-1.el9_7.noarch.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-race-1.25.3-1.el9_7.x86_64.rpm
+              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
@@ -202,11 +202,11 @@ jobs:
    - name: Setup Golang
      run: |
          dnf --assumeyes --disableplugin=subscription-manager install \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/go-toolset-1.25.3-1.el9_7.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-1.25.3-1.el9_7.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-bin-1.25.3-1.el9_7.x86_64.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-src-1.25.3-1.el9_7.noarch.rpm \
-              https://repo.almalinux.org/almalinux/9/AppStream/x86_64/os/Packages/golang-race-1.25.3-1.el9_7.x86_64.rpm
+              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
--- a/example-configs/collectors.json
+++ b/example-configs/collectors.json
--- a/collectors/gpfsMetric.go
+++ b/collectors/gpfsMetric.go
@@ -28,280 +28,35 @@ import (

 const DEFAULT_GPFS_CMD = "mmpmon"

-type GpfsCollectorState map[string]int64
-
-type GpfsCollectorConfig struct {
-	Mmpmon             string   `json:"mmpmon_path,omitempty"`
-	ExcludeFilesystem  []string `json:"exclude_filesystem,omitempty"`
-	ExcludeMetrics     []string `json:"exclude_metrics,omitempty"`
-	Sudo               bool     `json:"use_sudo,omitempty"`
-	SendAbsoluteValues bool     `json:"send_abs_values,omitempty"`
-	SendDiffValues     bool     `json:"send_diff_values,omitempty"`
-	SendDerivedValues  bool     `json:"send_derived_values,omitempty"`
-	SendTotalValues    bool     `json:"send_total_values,omitempty"`
-	SendBandwidths     bool     `json:"send_bandwidths,omitempty"`
-}
-
-type GpfsMetricDefinition struct {
-	name       string
-	desc       string
-	prefix     string
-	unit       string
-	calc       string
+type GpfsCollectorLastState struct {
+	numOpens    	int64
+	numCloses 		int64
+	numReads		int64
+	numWrites		int64
+	numReaddirs		int64
+	numInodeUpdates int64
+	bytesRead    	int64
+	bytesWritten 	int64
+	bytesTotal		int64
+	iops			int64
+	metaops			int64
 }

 type GpfsCollector struct {
 	metricCollector
-	tags          map[string]string
-	config        GpfsCollectorConfig
+	tags   map[string]string
+	config struct {
+		Mmpmon            string   `json:"mmpmon_path,omitempty"`
+		ExcludeFilesystem []string `json:"exclude_filesystem,omitempty"`
+		Sudo              bool     `json:"use_sudo,omitempty"`
+		SendBandwidths    bool     `json:"send_bandwidths"`
+		SendTotalValues   bool     `json:"send_total_values"`
+		SendDerivedValues bool     `json:"send_derived_values"`
+	}
 	sudoCmd       string
 	skipFS        map[string]struct{}
-	lastTimestamp map[string]time.Time // Store timestamp of lastState per filesystem to derive bandwidths
-	definitions   []GpfsMetricDefinition // all metrics to report
-	lastState     map[string]GpfsCollectorState // one GpfsCollectorState per filesystem
-}
-
-var GpfsAbsMetrics = []GpfsMetricDefinition{
-	{
-		name:       "gpfs_num_opens",
-		desc:       "number of opens",
-		prefix:     "_oc_",
-		unit:       "requests",
-		calc:       "none",
-	},
-	{
-		name:       "gpfs_num_closes",
-		desc:       "number of closes",
-		prefix:     "_cc_",
-		unit:       "requests",
-		calc:       "none",
-	},
-	{
-		name:       "gpfs_num_reads",
-		desc:       "number of reads",
-		prefix:     "_rdc_",
-		unit:       "requests",
-		calc:       "none",
-	},
-	{
-		name:       "gpfs_num_writes",
-		desc:       "number of writes",
-		prefix:     "_wc_",
-		unit:       "requests",
-		calc:       "none",
-	},
-	{
-		name:       "gpfs_num_readdirs",
-		desc:       "number of readdirs",
-		prefix:     "_dir_",
-		unit:       "requests",
-		calc:       "none",
-	},
-	{
-		name:       "gpfs_num_inode_updates",
-		desc:       "number of Inode Updates",
-		prefix:     "_iu_",
-		unit:       "requests",
-		calc:       "none",
-	},
-	{
-		name:       "gpfs_bytes_read",
-		desc:       "bytes read",
-		prefix:     "_br_",
-		unit:       "bytes",
-		calc:       "none",
-	},
-	{
-		name:       "gpfs_bytes_written",
-		desc:       "bytes written",
-		prefix:     "_bw_",
-		unit:       "bytes",
-		calc:       "none",
-	},
-}
-
-var GpfsDiffMetrics = []GpfsMetricDefinition{
-	{
-		name:       "gpfs_num_opens_diff",
-		desc:       "number of opens (diff)",
-		prefix:     "_oc_",
-		unit:       "requests",
-		calc:       "difference",
-	},
-	{
-		name:       "gpfs_num_closes_diff",
-		desc:       "number of closes (diff)",
-		prefix:     "_cc_",
-		unit:       "requests",
-		calc:       "difference",
-	},
-	{
-		name:       "gpfs_num_reads_diff",
-		desc:       "number of reads (diff)",
-		prefix:     "_rdc_",
-		unit:       "requests",
-		calc:       "difference",
-	},
-	{
-		name:       "gpfs_num_writes_diff",
-		desc:       "number of writes (diff)",
-		prefix:     "_wc_",
-		unit:       "requests",
-		calc:       "difference",
-	},
-	{
-		name:       "gpfs_num_readdirs_diff",
-		desc:       "number of readdirs (diff)",
-		prefix:     "_dir_",
-		unit:       "requests",
-		calc:       "difference",
-	},
-	{
-		name:       "gpfs_num_inode_updates_diff",
-		desc:       "number of Inode Updates (diff)",
-		prefix:     "_iu_",
-		unit:       "requests",
-		calc:       "difference",
-	},
-	{
-		name:       "gpfs_bytes_read_diff",
-		desc:       "bytes read (diff)",
-		prefix:     "_br_",
-		unit:       "bytes",
-		calc:       "difference",
-	},
-	{
-		name:       "gpfs_bytes_written_diff",
-		desc:       "bytes written (diff)",
-		prefix:     "_bw_",
-		unit:       "bytes",
-		calc:       "difference",
-	},
-}
-
-var GpfsDeriveMetrics = []GpfsMetricDefinition{
-	{
-		name:       "gpfs_opens_rate",
-		desc:       "number of opens (rate)",
-		prefix:     "_oc_",
-		unit:       "requests/sec",
-		calc:       "derivative",
-	},
-	{
-		name:       "gpfs_closes_rate",
-		desc:       "number of closes (rate)",
-		prefix:     "_oc_",
-		unit:       "requests/sec",
-		calc:       "derivative",
-	},
-	{
-		name:       "gpfs_reads_rate",
-		desc:       "number of reads (rate)",
-		prefix:     "_rdc_",
-		unit:       "requests/sec",
-		calc:       "derivative",
-	},
-	{
-		name:       "gpfs_writes_rate",
-		desc:       "number of writes (rate)",
-		prefix:     "_wc_",
-		unit:       "requests/sec",
-		calc:       "derivative",
-	},
-	{
-		name:       "gpfs_readdirs_rate",
-		desc:       "number of readdirs (rate)",
-		prefix:     "_dir_",
-		unit:       "requests/sec",
-		calc:       "derivative",
-	},
-	{
-		name:       "gpfs_inode_updates_rate",
-		desc:       "number of Inode Updates (rate)",
-		prefix:     "_iu_",
-		unit:       "requests/sec",
-		calc:       "derivative",
-	},
-	{
-		name:       "gpfs_bw_read",
-		desc:       "bytes read (rate)",
-		prefix:     "_br_",
-		unit:       "bytes/sec",
-		calc:       "derivative",
-	},
-	{
-		name:       "gpfs_bw_write",
-		desc:       "bytes written (rate)",
-		prefix:     "_bw_",
-		unit:       "bytes/sec",
-		calc:       "derivative",
-	},
-}
-
-var GpfsTotalMetrics = []GpfsMetricDefinition{
-	{
-		name:       "gpfs_bytes_total",
-		desc:       "bytes total",
-		prefix:     "bytesTotal",
-		unit:       "bytes",
-		calc:       "none",
-	},
-	{
-		name:       "gpfs_bytes_total_diff",
-		desc:       "bytes total (diff)",
-		prefix:     "bytesTotal",
-		unit:       "bytes",
-		calc:       "difference",
-	},
-	{
-		name:       "gpfs_bw_total",
-		desc:       "bytes total (rate)",
-		prefix:     "bytesTotal",
-		unit:       "bytes/sec",
-		calc:       "derivative",
-	},
-	{
-		name:       "gpfs_iops",
-		desc:       "iops",
-		prefix:     "iops",
-		unit:       "requests",
-		calc:       "none",
-	},
-	{
-		name:       "gpfs_iops_diff",
-		desc:       "iops  (diff)",
-		prefix:     "iops",
-		unit:       "requests",
-		calc:       "difference",
-	},
-	{
-		name:       "gpfs_iops_rate",
-		desc:       "iops (rate)",
-		prefix:     "iops",
-		unit:       "requests/sec",
-		calc:       "derivative",
-	},
-	{
-		name:       "gpfs_metaops",
-		desc:       "metaops",
-		prefix:     "metaops",
-		unit:       "requests",
-		calc:       "none",
-	},
-	{
-		name:       "gpfs_metaops_diff",
-		desc:       "metaops (diff)",
-		prefix:     "metaops",
-		unit:       "requests",
-		calc:       "difference",
-	},
-	{
-		name:       "gpfs_metaops_rate",
-		desc:       "metaops (rate)",
-		prefix:     "metaops",
-		unit:       "requests/sec",
-		calc:       "derivative",
-	},
+	lastTimestamp time.Time // Store time stamp of last tick to derive bandwidths
+	lastState     map[string]GpfsCollectorLastState
 }

 func (m *GpfsCollector) Init(config json.RawMessage) error {
@@ -338,8 +93,7 @@ func (m *GpfsCollector) Init(config json.RawMessage) error {
 	for _, fs := range m.config.ExcludeFilesystem {
 		m.skipFS[fs] = struct{}{}
 	}
-	m.lastState = make(map[string]GpfsCollectorState)
-	m.lastTimestamp = make(map[string]time.Time)
+	m.lastState = make(map[string]GpfsCollectorLastState)

 	// GPFS / IBM Spectrum Scale file system statistics can only be queried by user root
 	if !m.config.Sudo {
@@ -382,60 +136,6 @@ func (m *GpfsCollector) Init(config json.RawMessage) error {
 	}
 	m.config.Mmpmon = p

-	m.definitions = []GpfsMetricDefinition{}
-	if m.config.SendAbsoluteValues {
-		for _, def := range GpfsAbsMetrics {
-			if _, skip := stringArrayContains(m.config.ExcludeMetrics, def.name); !skip {
-				m.definitions = append(m.definitions, def)
-			}
-		}
-	}
-	if m.config.SendDiffValues {
-		for _, def := range GpfsDiffMetrics {
-			if _, skip := stringArrayContains(m.config.ExcludeMetrics, def.name); !skip {
-				m.definitions = append(m.definitions, def)
-			}
-		}
-	}
-	if m.config.SendDerivedValues {
-		for _, def := range GpfsDeriveMetrics {
-			if _, skip := stringArrayContains(m.config.ExcludeMetrics, def.name); !skip {
-				m.definitions = append(m.definitions, def)
-			}
-		}
-	} else if m.config.SendBandwidths {
-		for _, def := range GpfsDeriveMetrics {
-			if def.unit == "bytes/sec" {
-				if _, skip := stringArrayContains(m.config.ExcludeMetrics, def.name); !skip {
-					m.definitions = append(m.definitions, def)
-				}
-			}
-		}
-	}
-	if m.config.SendTotalValues {
-		for _, def := range GpfsTotalMetrics {
-			if _, skip := stringArrayContains(m.config.ExcludeMetrics, def.name); !skip {
-				// only send total metrics of the types requested
-				if ( def.calc == "none" && m.config.SendAbsoluteValues ) ||
-				   ( def.calc == "difference" && m.config.SendDiffValues ) ||
-				   ( def.calc == "derivative" && m.config.SendDerivedValues ) {
-					m.definitions = append(m.definitions, def)
-				   }
-			}
-		}
-	} else if m.config.SendBandwidths {
-		for _, def := range GpfsTotalMetrics {
-			if def.unit == "bytes/sec" {
-				if _, skip := stringArrayContains(m.config.ExcludeMetrics, def.name); !skip {
-					m.definitions = append(m.definitions, def)
-				}
-			}
-		}
-	}
-	if len(m.definitions) == 0 {
-		return errors.New("no metrics to collect")
-	}
-
 	m.init = true
 	return nil
 }
@@ -446,6 +146,13 @@ func (m *GpfsCollector) Read(interval time.Duration, output chan lp.CCMessage) {
 		return
 	}

+	// Current time stamp
+	now := time.Now()
+	// time difference to last time stamp
+	timeDiff := now.Sub(m.lastTimestamp).Seconds()
+	// Save current timestamp
+	m.lastTimestamp = now
+
 	// mmpmon:
 	// -p: generate output that can be parsed
 	// -s: suppress the prompt on input
@@ -499,7 +206,9 @@ func (m *GpfsCollector) Read(interval time.Duration, output chan lp.CCMessage) {

 		filesystem, ok := key_value["_fs_"]
 		if !ok {
-			cclog.ComponentError(m.name, "Read(): Failed to get filesystem name.")
+			cclog.ComponentError(
+				m.name,
+				"Read(): Failed to get filesystem name.")
 			continue
 		}

@@ -511,142 +220,438 @@ func (m *GpfsCollector) Read(interval time.Duration, output chan lp.CCMessage) {
 		// Add filesystem tag
 		m.tags["filesystem"] = filesystem

-		if _, ok := m.lastState[filesystem]; !ok {
-			m.lastState[filesystem] = make(GpfsCollectorState)
+		// Create initial last state
+		if m.config.SendBandwidths {
+			if _, ok := m.lastState[filesystem]; !ok {
+				m.lastState[filesystem] = GpfsCollectorLastState{
+					bytesRead:    -1,
+					bytesWritten: -1,
+				}
+			}
+		}
+
+		if m.config.SendDerivedValues {
+			if _, ok := m.lastState[filesystem]; !ok {
+				m.lastState[filesystem] = GpfsCollectorLastState{
+					numReads:    -1,
+					numWrites: -1,
+					numOpens: -1,
+					numCloses: -1,
+					numReaddirs: -1,
+					numInodeUpdates: -1,
+					bytesTotal: -1,
+					iops: -1,
+					metaops: -1,
+				}
+			}		
 		}

-		// read the new values from mmpmon
 		// return code
 		rc, err := strconv.Atoi(key_value["_rc_"])
 		if err != nil {
-			cclog.ComponentError(m.name, fmt.Sprintf("Read(): Failed to convert return code '%s' to int: %v", key_value["_rc_"], err))
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to convert return code '%s' to int: %v", key_value["_rc_"], err))
 			continue
 		}
 		if rc != 0 {
-			cclog.ComponentError(m.name, fmt.Sprintf("Read(): Filesystem '%s' is not ok.", filesystem))
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Filesystem '%s' is not ok.", filesystem))
 			continue
 		}

-		// timestamp
 		sec, err := strconv.ParseInt(key_value["_t_"], 10, 64)
 		if err != nil {
-			cclog.ComponentError(m.name, fmt.Sprintf("Read(): Failed to convert seconds '%s' to int64: %v", key_value["_t_"], err))
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to convert seconds '%s' to int64: %v", key_value["_t_"], err))
 			continue
 		}
 		msec, err := strconv.ParseInt(key_value["_tu_"], 10, 64)
 		if err != nil {
-			cclog.ComponentError(m.name, fmt.Sprintf("Read(): Failed to convert micro seconds '%s' to int64: %v", key_value["_tu_"], err))
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to convert micro seconds '%s' to int64: %v", key_value["_tu_"], err))
 			continue
 		}
 		timestamp := time.Unix(sec, msec*1000)

-		// time difference to last time stamp
-		var timeDiff float64 = 0
-		if lastTime, ok := m.lastTimestamp[filesystem]; !ok {
-			m.lastTimestamp[filesystem] = time.Time{}
-		} else {
-			timeDiff = timestamp.Sub(lastTime).Seconds()
+		// bytes read
+		bytesRead, err := strconv.ParseInt(key_value["_br_"], 10, 64)
+		if err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to convert bytes read '%s' to int64: %v", key_value["_br_"], err))
+			continue
 		}
-
-		// get values of all abs metrics
-		newstate := make(GpfsCollectorState)
-		for _, metric := range GpfsAbsMetrics {
-			value, err := strconv.ParseInt(key_value[metric.prefix], 10, 64)
-			if err != nil {
-				cclog.ComponentError(m.name, fmt.Sprintf("Read(): Failed to convert %s '%s' to int64: %v", metric.desc, key_value[metric.prefix], err))
-				continue
-			}
-			newstate[metric.prefix] = value
+		if y, err :=
+			lp.NewMessage(
+				"gpfs_bytes_read",
+				m.tags,
+				m.meta,
+				map[string]interface{}{
+					"value": bytesRead,
+				},
+				timestamp,
+			); err == nil {
+			y.AddMeta("unit", "bytes")
+			output <- y
 		}
-
-		// compute total metrics (map[...] will return 0 if key not found)
-		// bytes read and written
-		if br, br_ok := newstate["_br_"]; br_ok {
-			newstate["bytesTotal"] = newstate["bytesTotal"] + br
-		}
-		if bw, bw_ok := newstate["_bw_"]; bw_ok {
-			newstate["bytesTotal"] = newstate["bytesTotal"] + bw
-		}
-		// read and write count
-		if rdc, rdc_ok := newstate["_rdc_"]; rdc_ok {
-			newstate["iops"] = newstate["iops"] + rdc
-		}
-		if wc, wc_ok := newstate["_wc_"]; wc_ok {
-			newstate["iops"] = newstate["iops"] + wc
-		}
-		// meta operations
-		if oc, oc_ok := newstate["_oc_"]; oc_ok {
-			newstate["metaops"] = newstate["metaops"] + oc
-		}
-		if cc, cc_ok := newstate["_cc_"]; cc_ok {
-			newstate["metaops"] = newstate["metaops"] + cc
-		}
-		if dir, dir_ok := newstate["_dir_"]; dir_ok {
-			newstate["metaops"] = newstate["metaops"] + dir
-		}
-		if iu, iu_ok := newstate["_iu_"]; iu_ok {
-			newstate["metaops"] = newstate["metaops"] + iu
-		}
-		// send desired metrics for this filesystem
-		for _, metric := range m.definitions {
-			vold, vold_ok := m.lastState[filesystem][metric.prefix]
-			vnew, vnew_ok := newstate[metric.prefix]
-			var value interface{}
-			value_ok := false
-			switch metric.calc {
-			case "none":
-				if vnew_ok {
-					value = vnew
-					value_ok = true
-				} else if vold_ok {
-					// for absolute values, if the new value is not available, report no change
-					value = vold
-					value_ok = true
-				}
-			case "difference":
-				if vnew_ok && vold_ok {
-					value = vnew - vold
-					if value.(int64) < 0 {
-						value = 0
-					}
-					value_ok = true
-				} else if vold_ok {
-					// if the difference is not computable, return 0
-					value = 0
-					value_ok = true
-				}
-			case "derivative":
-				if vnew_ok && vold_ok && timeDiff > 0 {
-					value = float64(vnew - vold) / timeDiff
-					if value.(float64) < 0 {
-						value = 0
-					}
-					value_ok = true
-				} else if vold_ok {
-					// if the difference is not computable, return 0
-					value = 0
-					value_ok = true
-				}
-			}
-			if value_ok {
-				y, err := lp.NewMetric(metric.name, m.tags, m.meta, value, timestamp)
-				if err == nil {
-					if len(metric.unit) > 0 {
-						y.AddMeta("unit", metric.unit)
-					}
+		if m.config.SendBandwidths {
+			if lastBytesRead := m.lastState[filesystem].bytesRead; lastBytesRead >= 0 {
+				bwRead := float64(bytesRead-lastBytesRead) / timeDiff
+				if y, err :=
+					lp.NewMessage(
+						"gpfs_bw_read",
+						m.tags,
+						m.meta,
+						map[string]interface{}{
+							"value": bwRead,
+						},
+						timestamp,
+					); err == nil {
+					y.AddMeta("unit", "bytes/sec")
 					output <- y
 				}
-			} else {
-				// the value could not be computed correctly
-				cclog.ComponentWarn(m.name, fmt.Sprintf("Read(): Could not compute value for filesystem %s of metric %s: vold_ok = %t, vnew_ok = %t", filesystem, metric.name, vold_ok, vnew_ok))
 			}
 		}

-		// Save new state, if it contains proper values
-		if len(newstate) > 0 {
-			m.lastState[filesystem] = newstate
-			m.lastTimestamp[filesystem] = timestamp
+		// bytes written
+		bytesWritten, err := strconv.ParseInt(key_value["_bw_"], 10, 64)
+		if err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to convert bytes written '%s' to int64: %v", key_value["_bw_"], err))
+			continue
 		}
+		if y, err :=
+			lp.NewMessage(
+				"gpfs_bytes_written",
+				m.tags,
+				m.meta,
+				map[string]interface{}{
+					"value": bytesWritten,
+				},
+				timestamp,
+			); err == nil {
+			y.AddMeta("unit", "bytes")
+			output <- y
+		}
+		if m.config.SendBandwidths {
+			if lastBytesWritten := m.lastState[filesystem].bytesWritten; lastBytesWritten >= 0 {
+				bwWrite := float64(bytesWritten-lastBytesWritten) / timeDiff
+				if y, err :=
+					lp.NewMessage(
+						"gpfs_bw_write",
+						m.tags,
+						m.meta,
+						map[string]interface{}{
+							"value": bwWrite,
+						},
+						timestamp,
+					); err == nil {
+					y.AddMeta("unit", "bytes/sec")
+					output <- y
+				}
+			}
+		}
+
+		// number of opens
+		numOpens, err := strconv.ParseInt(key_value["_oc_"], 10, 64)
+		if err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to convert number of opens '%s' to int64: %v", key_value["_oc_"], err))
+			continue
+		}
+		if y, err := lp.NewMessage("gpfs_num_opens", m.tags, m.meta, map[string]interface{}{"value": numOpens}, timestamp); err == nil {
+			output <- y
+		}
+		if m.config.SendDerivedValues {
+			if lastNumOpens := m.lastState[filesystem].numOpens; lastNumOpens >= 0 {
+				opensRate := float64(numOpens-lastNumOpens) / timeDiff
+				if y, err :=
+					lp.NewMessage(
+						"gpfs_opens_rate",
+						m.tags,
+						m.meta,
+						map[string]interface{}{
+							"value": opensRate,
+						},
+						timestamp,
+					); err == nil {
+					y.AddMeta("unit", "requests/sec")
+					output <- y
+				}
+			}
+		}
+
+		// number of closes
+		numCloses, err := strconv.ParseInt(key_value["_cc_"], 10, 64)
+		if err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to convert number of closes: '%s' to int64: %v", key_value["_cc_"], err))
+			continue
+		}
+		if y, err := lp.NewMessage("gpfs_num_closes", m.tags, m.meta, map[string]interface{}{"value": numCloses}, timestamp); err == nil {
+			output <- y
+		}
+		if m.config.SendDerivedValues {
+			if lastNumCloses := m.lastState[filesystem].numCloses; lastNumCloses >= 0 {
+				closesRate := float64(numCloses-lastNumCloses) / timeDiff
+				if y, err :=
+					lp.NewMessage(
+						"gpfs_closes_rate",
+						m.tags,
+						m.meta,
+						map[string]interface{}{
+							"value": closesRate,
+						},
+						timestamp,
+					); err == nil {
+					y.AddMeta("unit", "requests/sec")
+					output <- y
+				}
+			}
+		}
+
+		// number of reads
+		numReads, err := strconv.ParseInt(key_value["_rdc_"], 10, 64)
+		if err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to convert number of reads: '%s' to int64: %v", key_value["_rdc_"], err))
+			continue
+		}
+		if y, err := lp.NewMessage("gpfs_num_reads", m.tags, m.meta, map[string]interface{}{"value": numReads}, timestamp); err == nil {
+			output <- y
+		}
+		if m.config.SendDerivedValues {
+			if lastNumReads := m.lastState[filesystem].numReads; lastNumReads >= 0 {
+				readsRate := float64(numReads-lastNumReads) / timeDiff
+				if y, err :=
+					lp.NewMessage(
+						"gpfs_reads_rate",
+						m.tags,
+						m.meta,
+						map[string]interface{}{
+							"value": readsRate,
+						},
+						timestamp,
+					); err == nil {
+					y.AddMeta("unit", "requests/sec")
+					output <- y
+				}
+			}
+		}
+
+		// number of writes
+		numWrites, err := strconv.ParseInt(key_value["_wc_"], 10, 64)
+		if err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to convert number of writes: '%s' to int64: %v", key_value["_wc_"], err))
+			continue
+		}
+		if y, err := lp.NewMessage("gpfs_num_writes", m.tags, m.meta, map[string]interface{}{"value": numWrites}, timestamp); err == nil {
+			output <- y
+		}
+		if m.config.SendDerivedValues {
+			if lastNumWrites := m.lastState[filesystem].numWrites; lastNumWrites >= 0 {
+				writesRate := float64(numWrites-lastNumWrites) / timeDiff
+				if y, err :=
+					lp.NewMessage(
+						"gpfs_writes_rate",
+						m.tags,
+						m.meta,
+						map[string]interface{}{
+							"value": writesRate,
+						},
+						timestamp,
+					); err == nil {
+					y.AddMeta("unit", "requests/sec")
+					output <- y
+				}
+			}
+		}
+
+		// number of read directories
+		numReaddirs, err := strconv.ParseInt(key_value["_dir_"], 10, 64)
+		if err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to convert number of read directories: '%s' to int64: %v", key_value["_dir_"], err))
+			continue
+		}
+		if y, err := lp.NewMessage("gpfs_num_readdirs", m.tags, m.meta, map[string]interface{}{"value": numReaddirs}, timestamp); err == nil {
+			output <- y
+		}
+		if m.config.SendDerivedValues {
+			if lastNumReaddirs := m.lastState[filesystem].numReaddirs; lastNumReaddirs >= 0 {
+				readdirsRate := float64(numReaddirs-lastNumReaddirs) / timeDiff
+				if y, err :=
+					lp.NewMessage(
+						"gpfs_readdirs_rate",
+						m.tags,
+						m.meta,
+						map[string]interface{}{
+							"value": readdirsRate,
+						},
+						timestamp,
+					); err == nil {
+					y.AddMeta("unit", "requests/sec")
+					output <- y
+				}
+			}
+		}
+
+		// Number of inode updates
+		numInodeUpdates, err := strconv.ParseInt(key_value["_iu_"], 10, 64)
+		if err != nil {
+			cclog.ComponentError(
+				m.name,
+				fmt.Sprintf("Read(): Failed to convert number of inode updates: '%s' to int: %v", key_value["_iu_"], err))
+			continue
+		}
+		if y, err := lp.NewMessage("gpfs_num_inode_updates", m.tags, m.meta, map[string]interface{}{"value": numInodeUpdates}, timestamp); err == nil {
+			output <- y
+		}
+		if m.config.SendDerivedValues {
+			if lastNumInodeUpdates := m.lastState[filesystem].numInodeUpdates; lastNumInodeUpdates >= 0 {
+				inodeUpdatesRate := float64(numInodeUpdates-lastNumInodeUpdates) / timeDiff
+				if y, err :=
+					lp.NewMessage(
+						"gpfs_inode_updates_rate",
+						m.tags,
+						m.meta,
+						map[string]interface{}{
+							"value": inodeUpdatesRate,
+						},
+						timestamp,
+					); err == nil {
+					y.AddMeta("unit", "requests/sec")
+					output <- y
+				}
+			}
+		}
+
+		// Total values
+		bytesTotal := int64(-1);
+		iops := int64(-1);
+		metaops := int64(-1);
+		if m.config.SendTotalValues {
+			bytesTotal = bytesRead + bytesWritten
+			if y, err :=
+				lp.NewMessage("gpfs_bytes_total",
+					m.tags,
+					m.meta,
+					map[string]interface{}{
+						"value": bytesTotal,
+					},
+					timestamp,
+				); err == nil {
+				y.AddMeta("unit", "bytes")
+				output <- y
+			}
+			if m.config.SendBandwidths {
+				if lastBytesTotal := m.lastState[filesystem].bytesTotal; lastBytesTotal >= 0 {
+					bwTotal := float64(bytesTotal-lastBytesTotal) / timeDiff
+					if y, err :=
+						lp.NewMessage(
+							"gpfs_bw_total",
+							m.tags,
+							m.meta,
+							map[string]interface{}{
+								"value": bwTotal,
+							},
+							timestamp,
+						); err == nil {
+						y.AddMeta("unit", "bytes/sec")
+						output <- y
+					}
+				}
+			}
+
+			iops = numReads + numWrites
+			if y, err :=
+				lp.NewMessage("gpfs_iops",
+					m.tags,
+					m.meta,
+					map[string]interface{}{
+						"value": iops,
+					},
+					timestamp,
+				); err == nil {
+				output <- y
+			}
+			if m.config.SendDerivedValues {
+				if lastIops := m.lastState[filesystem].iops; lastIops >= 0 {
+					iopsRate := float64(iops-lastIops) / timeDiff
+					if y, err :=
+						lp.NewMessage(
+							"gpfs_iops_rate",
+							m.tags,
+							m.meta,
+							map[string]interface{}{
+								"value": iopsRate,
+							},
+							timestamp,
+						); err == nil {
+						y.AddMeta("unit", "requests/sec")
+						output <- y
+					}
+				}
+			}
+	
+			metaops = numInodeUpdates + numCloses + numOpens + numReaddirs
+			if y, err :=
+				lp.NewMessage("gpfs_metaops",
+					m.tags,
+					m.meta,
+					map[string]interface{}{
+						"value": metaops,
+					},
+					timestamp,
+				); err == nil {
+				output <- y
+			}
+			if m.config.SendDerivedValues {
+				if lastMetaops := m.lastState[filesystem].metaops; lastMetaops >= 0 {
+					metaopsRate := float64(metaops-lastMetaops) / timeDiff
+					if y, err :=
+						lp.NewMessage(
+							"gpfs_metaops_rate",
+							m.tags,
+							m.meta,
+							map[string]interface{}{
+								"value": metaopsRate,
+							},
+							timestamp,
+						); err == nil {
+						y.AddMeta("unit", "requests/sec")
+						output <- y
+					}
+				}
+			}
+		}
+
+		// Save last state
+		m.lastState[filesystem] = GpfsCollectorLastState{
+			bytesRead:    bytesRead,
+			bytesWritten: bytesWritten,
+			numOpens: numOpens,
+			numCloses: numCloses,
+			numReads: numReads,
+			numWrites: numWrites,
+			numReaddirs: numReaddirs,
+			numInodeUpdates: numInodeUpdates,
+			bytesTotal: bytesTotal,
+			iops: iops,
+			metaops: metaops,
+		}
+
 	}
 }

--- a/collectors/gpfsMetric.md
+++ b/collectors/gpfsMetric.md
@@ -18,14 +18,9 @@ hugo_path: docs/reference/cc-metric-collector/collectors/gpfs.md
    "exclude_filesystem": [
      "fs1"
    ],
-    "exclude_metrics": [
-      "gpfs_bytes_written"
-    ],
-    "send_abs_values": true,
-    "send_diff_values": true,
-    "send_derived_values": true,
+    "send_bandwidths": true,
    "send_total_values": true,
-    "send_bandwidths": true
+    "send_derived_values": true
  }
 ```

@@ -34,50 +29,38 @@ 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, password-less `sudo` can be enabled with `use_sudo`. 
+If cc-metric-collector is run as non-root, `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` (if `send_abs_values == true`)
-* `gpfs_bytes_written` (if `send_abs_values == true`)
-* `gpfs_num_opens` (if `send_abs_values == true`)
-* `gpfs_num_closes` (if `send_abs_values == true`)
-* `gpfs_num_reads` (if `send_abs_values == true`)
-* `gpfs_num_writes` (if `send_abs_values == true`)
-* `gpfs_num_readdirs` (if `send_abs_values == true`)
-* `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_bytes_read`
+* `gpfs_bytes_written`
+* `gpfs_num_opens`
+* `gpfs_num_closes`
+* `gpfs_num_reads`
+* `gpfs_num_writes`
+* `gpfs_num_readdirs`
+* `gpfs_num_inode_updates`
 * `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` and `send_abs_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_bytes_total = gpfs_bytes_read + gpfs_bytes_written` (if `send_total_values == true`)
+* `gpfs_iops = gpfs_num_reads + gpfs_num_writes` (if `send_total_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` and `send_abs_values == true`)
-* `gpfs_metaops_diff` (if `send_total_values == true` and `send_diff_values == true`)
+* `gpfs_metaops = gpfs_num_inode_updates + gpfs_num_closes + gpfs_num_opens + gpfs_num_readdirs` (if `send_total_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
--- a/collectors/nvidiaMetric.go
+++ b/collectors/nvidiaMetric.go
@@ -589,7 +589,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.NewMetric("nv_max_graphics_clock", device.tags, device.meta, float64(max_gclk), time.Now())
+			y, err := lp.NewMessage("nv_max_graphics_clock", device.tags, device.meta, map[string]interface{}{"value": float64(max_gclk)}, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MHz")
 				output <- y
@@ -598,9 +598,9 @@ func readMaxClocks(device *NvidiaCollectorDevice, output chan lp.CCMessage) erro
 	}

 	if !device.excludeMetrics["nv_max_sm_clock"] {
-		maxSmClock, ret := nvml.DeviceGetMaxClockInfo(device.device, nvml.CLOCK_SM)
+		maxSmClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_SM)
 		if ret == nvml.SUCCESS {
-			y, err := lp.NewMetric("nv_max_sm_clock", device.tags, device.meta, float64(maxSmClock), time.Now())
+			y, err := lp.NewMessage("nv_max_sm_clock", device.tags, device.meta, map[string]interface{}{"value": float64(maxSmClock)}, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MHz")
 				output <- y
@@ -609,9 +609,9 @@ func readMaxClocks(device *NvidiaCollectorDevice, output chan lp.CCMessage) erro
 	}

 	if !device.excludeMetrics["nv_max_mem_clock"] {
-		maxMemClock, ret := nvml.DeviceGetMaxClockInfo(device.device, nvml.CLOCK_MEM)
+		maxMemClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_MEM)
 		if ret == nvml.SUCCESS {
-			y, err := lp.NewMetric("nv_max_mem_clock", device.tags, device.meta, float64(maxMemClock), time.Now())
+			y, err := lp.NewMessage("nv_max_mem_clock", device.tags, device.meta, map[string]interface{}{"value": float64(maxMemClock)}, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MHz")
 				output <- y
@@ -620,9 +620,9 @@ func readMaxClocks(device *NvidiaCollectorDevice, output chan lp.CCMessage) erro
 	}

 	if !device.excludeMetrics["nv_max_video_clock"] {
-		maxVideoClock, ret := nvml.DeviceGetMaxClockInfo(device.device, nvml.CLOCK_VIDEO)
+		maxMemClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_VIDEO)
 		if ret == nvml.SUCCESS {
-			y, err := lp.NewMetric("nv_max_video_clock", device.tags, device.meta, float64(maxVideoClock), time.Now())
+			y, err := lp.NewMessage("nv_max_video_clock", device.tags, device.meta, map[string]interface{}{"value": float64(maxMemClock)}, time.Now())
 			if err == nil {
 				y.AddMeta("unit", "MHz")
 				output <- y
--- a/example-configs/config.json
+++ b/example-configs/config.json
--- a/docs/configuration.md
+++ b/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. You can find examples in `example_configs`.
+The global file contains the paths to the other four files and some global options. 

 ```json
 {
--- a/go.mod
+++ b/go.mod
@@ -3,16 +3,16 @@ module github.com/ClusterCockpit/cc-metric-collector
 go 1.24.0

 require (
-	github.com/ClusterCockpit/cc-lib v0.11.0
+	github.com/ClusterCockpit/cc-lib v0.10.1
 	github.com/ClusterCockpit/go-rocm-smi v0.3.0
 	github.com/NVIDIA/go-nvml v0.13.0-1
 	github.com/PaesslerAG/gval v1.2.4
 	github.com/fsnotify/fsnotify v1.9.0
 	github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf
-	github.com/tklauser/go-sysconf v0.3.16
+	github.com/tklauser/go-sysconf v0.3.15
 	golang.design/x/thread v0.0.0-20210122121316-335e9adffdf1
 	golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b
-	golang.org/x/sys v0.38.0
+	golang.org/x/sys v0.37.0
 )

 require (
@@ -24,9 +24,9 @@ require (
 	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/klauspost/compress v1.18.1 // indirect
+	github.com/klauspost/compress v1.18.0 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
-	github.com/nats-io/nats.go v1.47.0 // indirect
+	github.com/nats-io/nats.go v1.46.1 // indirect
 	github.com/nats-io/nkeys v0.4.11 // indirect
 	github.com/nats-io/nuid v1.0.1 // indirect
 	github.com/oapi-codegen/runtime v1.1.1 // indirect
@@ -37,9 +37,9 @@ require (
 	github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 // indirect
 	github.com/shopspring/decimal v1.3.1 // indirect
 	github.com/stmcginnis/gofish v0.20.0 // indirect
-	github.com/tklauser/numcpus v0.11.0 // indirect
+	github.com/tklauser/numcpus v0.10.0 // indirect
 	go.yaml.in/yaml/v2 v2.4.2 // indirect
-	golang.org/x/crypto v0.43.0 // indirect
-	golang.org/x/net v0.45.0 // indirect
+	golang.org/x/crypto v0.42.0 // indirect
+	golang.org/x/net v0.43.0 // indirect
 	google.golang.org/protobuf v1.36.8 // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -1,5 +1,5 @@
-github.com/ClusterCockpit/cc-lib v0.11.0 h1:66YkTOxWUak7nB3r7dJEm2q+B0uPRPGj0mwXZHXpOuA=
-github.com/ClusterCockpit/cc-lib v0.11.0/go.mod h1:0LKjDJs813/NMmaSJXJc11A9rxiFDPV/QdWQbZUp0XY=
+github.com/ClusterCockpit/cc-lib v0.10.1 h1:tjGEH8mFGgznYxO8BKLiiar0eZR1Oytk8x5iIQHZR5s=
+github.com/ClusterCockpit/cc-lib v0.10.1/go.mod h1:nvTZuxFCTwlos8I1rL5O1RPab7vRtkU8E/PGiaF6pQA=
 github.com/ClusterCockpit/go-rocm-smi v0.3.0 h1:1qZnSpG7/NyLtc7AjqnUL9Jb8xtqG1nMVgp69rJfaR8=
 github.com/ClusterCockpit/go-rocm-smi v0.3.0/go.mod h1:+I3UMeX3OlizXDf1WpGD43W4KGZZGVSGmny6rTeOnWA=
 github.com/NVIDIA/go-nvml v0.11.6-0/go.mod h1:hy7HYeQy335x6nEss0Ne3PYqleRa6Ct+VKD9RQ4nyFs=
@@ -35,8 +35,8 @@ github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 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.6 h1:Ku42PT4LmjDu1H5C5ISWLlpI1mj+Zq7sPGKoRw2XROA=
-github.com/google/go-tpm v0.9.6/go.mod h1:h9jEsEECg7gtLis0upRBQU+GhYVH6jMjrFxI8u6bVUY=
+github.com/google/go-tpm v0.9.5 h1:ocUmnDebX54dnW+MQWGQRbdaAcJELsa6PqZhJ48KwVU=
+github.com/google/go-tpm v0.9.5/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=
@@ -53,8 +53,8 @@ github.com/influxdata/line-protocol/v2 v2.1.0/go.mod h1:QKw43hdUBg3GTk2iC3iyCxks
 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.1 h1:bcSGx7UbpBqMChDtsF28Lw6v/G94LPrrbMbdC3JH2co=
-github.com/klauspost/compress v1.18.1/go.mod h1:ZQFFVG+MdnR0P+l6wpXgIL4NTtwiKIdBnrBd8Nrxr+0=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
 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=
@@ -64,16 +64,16 @@ 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.4-0.20251030100505-070ab1a87a76 h1:KGuD/pM2JpL9FAYvBrnBBeENKZNh6eNtjqytV6TYjnk=
-github.com/minio/highwayhash v1.0.4-0.20251030100505-070ab1a87a76/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ=
+github.com/minio/highwayhash v1.0.3 h1:kbnuUMoHYyVl7szWjSxJnxw11k2U709jqFPPmIUyD6Q=
+github.com/minio/highwayhash v1.0.3/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ=
 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.0/go.mod h1:me11pOkwObtcBNR8AiMrUbtVOUGkqYjMQZ6jnSdVUIA=
-github.com/nats-io/nats-server/v2 v2.12.2 h1:4TEQd0Y4zvcW0IsVxjlXnRso1hBkQl3TS0BI+SxgPhE=
-github.com/nats-io/nats-server/v2 v2.12.2/go.mod h1:j1AAttYeu7WnvD8HLJ+WWKNMSyxsqmZ160pNtCQRMyE=
-github.com/nats-io/nats.go v1.47.0 h1:YQdADw6J/UfGUd2Oy6tn4Hq6YHxCaJrVKayxxFqYrgM=
-github.com/nats-io/nats.go v1.47.0/go.mod h1:iRWIPokVIFbVijxuMQq4y9ttaBTMe0SFdlZfMDd+33g=
+github.com/nats-io/nats-server/v2 v2.12.0 h1:OIwe8jZUqJFrh+hhiyKu8snNib66qsx806OslqJuo74=
+github.com/nats-io/nats-server/v2 v2.12.0/go.mod h1:nr8dhzqkP5E/lDwmn+A2CvQPMd1yDKXQI7iGg3lAvww=
+github.com/nats-io/nats.go v1.46.1 h1:bqQ2ZcxVd2lpYI97xYASeRTY3I5boe/IVmuUDPitHfo=
+github.com/nats-io/nats.go v1.46.1/go.mod h1:iRWIPokVIFbVijxuMQq4y9ttaBTMe0SFdlZfMDd+33g=
 github.com/nats-io/nkeys v0.4.11 h1:q44qGV008kYd9W1b1nEBkNzvnWxtRSQ7A8BoqRrcfa0=
 github.com/nats-io/nkeys v0.4.11/go.mod h1:szDimtgmfOi9n25JpfIdGw12tZFYXqhGxjhVxsatHVE=
 github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
@@ -104,27 +104,27 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 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.16 h1:frioLaCQSsF5Cy1jgRBrzr6t502KIIwQ0MArYICU0nA=
-github.com/tklauser/go-sysconf v0.3.16/go.mod h1:/qNL9xxDhc7tx3HSRsLWNnuzbVfh3e7gh/BmM179nYI=
-github.com/tklauser/numcpus v0.11.0 h1:nSTwhKH5e1dMNsCdVBukSZrURJRoHbSEQjdEbY+9RXw=
-github.com/tklauser/numcpus v0.11.0/go.mod h1:z+LwcLq54uWZTX0u/bGobaV34u6V7KNlTZejzM6/3MQ=
+github.com/tklauser/go-sysconf v0.3.15 h1:VE89k0criAymJ/Os65CSn1IXaol+1wrsFHEB8Ol49K4=
+github.com/tklauser/go-sysconf v0.3.15/go.mod h1:Dmjwr6tYFIseJw7a3dRLJfsHAMXZ3nEnL/aZY+0IuI4=
+github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfjso=
+github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ=
 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.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU=
 golang.design/x/thread v0.0.0-20210122121316-335e9adffdf1 h1:P7S/GeHBAFEZIYp0ePPs2kHXoazz8q2KsyxHyQVGCJg=
 golang.design/x/thread v0.0.0-20210122121316-335e9adffdf1/go.mod h1:9CWpnTUmlQkfdpdutA1nNf4iE5lAVt3QZOu0Z6hahBE=
-golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04=
-golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0=
+golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
+golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
 golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b h1:M2rDM6z3Fhozi9O7NWsxAkg/yqS/lQJ6PmkyIV3YP+o=
 golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b/go.mod h1:3//PLf8L/X+8b4vuAfHzxeRUl04Adcb341+IGKfnqS8=
-golang.org/x/net v0.45.0 h1:RLBg5JKixCy82FtLJpeNlVM0nrSqpCRYzVU1n8kj0tM=
-golang.org/x/net v0.45.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
+golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
+golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
 golang.org/x/sys v0.0.0-20210122093101-04d7465088b8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
-golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
-golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
+golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
+golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/time v0.13.0 h1:eUlYslOIt32DgYD6utsuUeHs4d7AsEYLuIAdg7FlYgI=
+golang.org/x/time v0.13.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
 google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
--- a/example-configs/receivers.json
+++ b/example-configs/receivers.json
--- a/example-configs/router.json
+++ b/example-configs/router.json
--- a/example-configs/sinks.json
+++ b/example-configs/sinks.json