prometheus-node-exporter-ucode: new modules & info

-thermal management (temp and cooling devices)
-uname amendment to oneline and help string
-realtek-poe
-odhcp6c
-entropy help strings
-time help string
-hwmon
-time clocksources
-watchdog
-metrics help strings

Signed-off-by: Paul Donald <[email protected]>

Author: systemcrash

utils/prometheus-node-exporter-ucode/Makefile

@@ -3,8 +3,8 @@
 include $(TOPDIR)/rules.mk
 
 PKG_NAME:=prometheus-node-exporter-ucode
-PKG_VERSION:=2024.02.07
-PKG_RELEASE:=2
+PKG_VERSION:=2025.12.04
+PKG_RELEASE:=1
 
 PKG_MAINTAINER:=Andre Heider <[email protected]>
 PKG_LICENSE:=Apache-2.0
@@ -65,10 +65,14 @@ define Collector
 endef
 
 $(eval $(call Collector,dnsmasq,Dnsmasq collector,@dnsmasq))
+$(eval $(call Collector,hwmon,hwmon collector,))
 $(eval $(call Collector,ltq-dsl,Lantiq/Intel/MaxLinear DSL collector,@ltq-dsl-app))
 $(eval $(call Collector,netstat,netstat collector,))
+$(eval $(call Collector,odhcp6c,odhcp6c statistics collector,@odhcp6c))
 $(eval $(call Collector,openwrt,OpenWrt collector,))
+$(eval $(call Collector,realtek-poe,RealTek PoE collector,@realtek-poe))
 $(eval $(call Collector,snmp6,snmp6 collector,))
+$(eval $(call Collector,thermal,thermal collector,))
 $(eval $(call Collector,uci_dhcp_host,UCI DHCP host collector,))
 $(eval $(call Collector,wifi,Wi-Fi collector,+ucode-mod-nl80211))
 $(eval $(call Collector,wireguard,Wireguard collector,+rpcd-mod-wireguard))

utils/prometheus-node-exporter-ucode/files/base/entropy.uc

@@ -1,4 +1,4 @@
-gauge("node_entropy_available_bits")
+gauge("node_entropy_available_bits", "Bits of available entropy.")
 	(null, oneline("/proc/sys/kernel/random/entropy_avail"));
-gauge("node_entropy_pool_size_bits")
+gauge("node_entropy_pool_size_bits", "Bits of entropy pool.")
 	(null, oneline("/proc/sys/kernel/random/poolsize"));

utils/prometheus-node-exporter-ucode/files/base/time.uc

@@ -1 +1,34 @@
-gauge("node_time_seconds")(null, time());
+gauge("node_time_seconds", "System time in seconds since epoch (1970).")(null, time());
+
+// based loosely on https://github.com/prometheus/node_exporter/blob/master/collector/time.go
+
+const SDS_CLOCK_PATH = "/sys/devices/system/clocksource/";
+
+const avail_gauge = gauge("node_time_clocksource_available_info",
+	"Available clocksources read from '/sys/devices/system/clocksource'.");
+const current_gauge = gauge("node_time_clocksource_current_info",
+	"Current clocksource read from '/sys/devices/system/clocksource'.");
+
+const current_sources = [];
+
+for (let clock_src_path in fs.lsdir(SDS_CLOCK_PATH, "clocksource*")) {
+
+	const csp_match = match(clock_src_path, /clocksource(\d+)/);
+	if (!csp_match)
+		continue;
+
+	const sources = split(oneline(`${SDS_CLOCK_PATH}/${clock_src_path}/available_clocksource`), ' ');
+	const current = oneline(`${SDS_CLOCK_PATH}/${clock_src_path}/current_clocksource`);
+	const device = csp_match?.[1];
+
+	for (let source in sources) {
+		if (!source) continue;
+		avail_gauge({ clocksource: source, device: `${device}` }, 1)
+	}
+
+	push(current_sources, { clocksource: current, device: `${device}` });
+}
+
+for (let cs in current_sources) {
+	current_gauge(cs, 1);
+}

utils/prometheus-node-exporter-ucode/files/base/uname.uc

@@ -1,8 +1,8 @@
-gauge("node_uname_info")({
+gauge("node_uname_info", "Labelled system information as provided by the uname system call.")({
 	sysname:	oneline("/proc/sys/kernel/ostype"),
 	nodename:	oneline("/proc/sys/kernel/hostname"),
 	release:	oneline("/proc/sys/kernel/osrelease"),
 	version:	oneline("/proc/sys/kernel/version"),
-	machine:	poneline("uname -m"), // TODO lame
+	machine:	oneline("/proc/sys/kernel/arch"),
 	domainname:	oneline("/proc/sys/kernel/domainname"),
 }, 1);

utils/prometheus-node-exporter-ucode/files/base/watchdog.uc

@@ -0,0 +1,59 @@
+// based loosely on https://github.com/prometheus/node_exporter/blob/master/collector/watchdog.go
+
+const SC_WATCHDOG_PATH = "/sys/class/watchdog/";
+
+const metrics = {
+	bootstatus: gauge("node_watchdog_bootstatus",
+		"Value of /sys/class/watchdog/<watchdog>/bootstatus"),
+	fw_version: gauge("node_watchdog_fw_version",
+		"Value of /sys/class/watchdog/<watchdog>/fw_version"),
+	nowayout: gauge("node_watchdog_nowayout",
+		"Value of /sys/class/watchdog/<watchdog>/nowayout"),
+	timeleft: gauge("node_watchdog_timeleft_seconds",
+		"Value of /sys/class/watchdog/<watchdog>/timeleft"),
+	timeout: gauge("node_watchdog_timeout_seconds",
+		"Value of /sys/class/watchdog/<watchdog>/timeout"),
+	pretimeout: gauge("node_watchdog_pretimeout_seconds",
+		"Value of /sys/class/watchdog/<watchdog>/pretimeout"),
+	access_cs0: gauge("node_watchdog_access_cs0",
+		"Value of /sys/class/watchdog/<watchdog>/access_cs0"),
+};
+
+const info_gauge = gauge("node_watchdog_info",
+	"Info of /sys/class/watchdog/<watchdog>");
+const avail_gauge = gauge("node_watchdog_available",
+	"Info of /sys/class/watchdog/<watchdog>/pretimeout_available_governors");
+
+
+const wd_paths = [];
+
+for (let wd_path in fs.lsdir(SC_WATCHDOG_PATH, "watchdog*")) {
+	push(wd_paths, wd_path);
+}
+
+// watchdog metrics
+for (let m in metrics) {
+	for (let wd_path in wd_paths)
+		metrics[m]({ name: `${wd_path}` }, oneline(`${SC_WATCHDOG_PATH}/${wd_path}/${m}`));
+}
+
+// watchdog summary info properties
+for (let wd_path in wd_paths) {
+	const path = `${SC_WATCHDOG_PATH}/${wd_path}`;
+	info_gauge({ 
+		name:		`${wd_path}`,
+		options:	`${oneline(`${path}/options`)}`,
+		identity:	`${oneline(`${path}/identity`)}`,
+		state:		`${oneline(`${path}/state`)}`,
+		status:		`${oneline(`${path}/status`)}`,
+		pretimeout_governor: `${oneline(`${path}/pretimeout_governor`)}`,
+	}, 1);
+}
+
+for (let wd_path in wd_paths) {
+	const pa = split(oneline(`${SC_WATCHDOG_PATH}/${wd_path}/pretimeout_available_governors`), ' ');
+	for (let gov in pa) {
+		if (!gov) continue;
+		avail_gauge({ available: gov, device: `${wd_path}` }, 1)
+	}
+}

utils/prometheus-node-exporter-ucode/files/extra/hwmon.uc

@@ -0,0 +1,79 @@
+
+const metric_chip_names = gauge("node_hwmon_chip_names", "Annotation metric for human-readable chip names");
+const metric_sensor_label = gauge("node_hwmon_sensor_label", "Label for given chip and sensor");
+const metric_temp_celsius = gauge("node_hwmon_temp_celsius", "Hardware monitor for temperature");
+const metric_pwm = gauge("node_hwmon_pwm", "Pulse Width Modulation control");
+
+const hwmon_paths = [];
+const chip_names = [];
+
+const SC_HWMON_PATH = "/sys/class/hwmon/";
+
+for (let hwmon_path in fs.lsdir(SC_HWMON_PATH, "hwmon*")) {
+	const full_path = `${SC_HWMON_PATH}${hwmon_path}`;
+	push(hwmon_paths, full_path);
+
+	// Produce node_hwmon_chip_names
+	// See https://github.com/prometheus/node_exporter/blob/7c564bcbeffade3dacac43b07c2eeca4957ca71d/collector/hwmon_linux.go#L415
+	const chip_name = oneline(`${full_path}/name`) || hwmon_path;
+
+	// See https://github.com/prometheus/node_exporter/blob/7c564bcbeffade3dacac43b07c2eeca4957ca71d/collector/hwmon_linux.go#L355
+	let chip = chip_name;
+	const real_dev_path = fs.realpath(`${full_path}/device`);
+
+	if (real_dev_path) {
+		const dev_name = fs.basename(real_dev_path);
+		const dev_type = fs.basename(fs.dirname(real_dev_path));
+
+		chip = `${dev_type}_${dev_name}`;
+
+	}
+	push(chip_names, chip);
+
+	metric_chip_names({ chip: chip, chip_name: chip_name }, 1);
+}
+
+
+map(hwmon_paths, function(path, index) {
+	for (let sensor_path in fs.lsdir(path, "*_label")) {
+		// Produce node_hwmon_sensor_label
+		if (match(sensor_path, /_label$/)) {
+
+			const sensor = rtrim(sensor_path, "_label");
+			const sensor_label = oneline(`${path}/${sensor_path}`);
+
+			metric_sensor_label({ chip: chip_names[index], sensor: sensor, label: sensor_label }, 1);
+
+		}
+	}
+});
+
+// for (let path in hwmon_paths) {
+map(hwmon_paths, function(path, index) {
+	for (let sensor_path in fs.lsdir(path, "temp*_input")) {
+
+		// Produce node_hwmon_temp_celsius
+		if (match(sensor_path, /^temp\d+_input$/)) {
+
+			const sensor = rtrim(sensor_path, "_input");
+			const temp = oneline(`${path}/${sensor_path}`) / 1000.00;
+
+			metric_temp_celsius({ chip: chip_names[index], sensor: sensor }, temp);
+
+		}
+	}
+});
+
+map(hwmon_paths, function(path, index) {
+	for (let sensor_path in fs.lsdir(path, "pwm*")) {
+
+		// Produce node_hwmon_pwm
+		if (match(sensor_path, /^pwm[0-9]+$/)) {
+
+			const pwm = oneline(`${path}/${sensor_path}`);
+
+			metric_pwm({ chip: chip_names[index], sensor: sensor_path }, pwm);
+
+		}
+	}
+});

utils/prometheus-node-exporter-ucode/files/extra/odhcp6c.uc

@@ -0,0 +1,16 @@
+const devs = ubus.call("network.device", "status");
+
+if (!devs)
+	return false;
+
+for (let dev in devs) {
+	const m = ubus.call(`odhcp6c.${dev}`, "get_statistics");
+
+	// not all interfaces are exposed unless odhcp6c runs on it
+	if (!m)
+		continue;
+
+	for (let i in m)
+		gauge(`node_odhcp6c_${i}`, `Total DHCPv6 messages of type ${i}`)({ dev: dev }, m[i]);
+
+}

utils/prometheus-node-exporter-ucode/files/extra/realtek_poe.uc

@@ -0,0 +1,72 @@
+const poe_info = ubus.call("poe", "info");
+
+if (!poe_info)
+	return false;
+
+// possible poe modes for a port
+//   realtek-poe/src/main.c
+//   static int poe_reply_port_ext_config()
+const POE_MODES = [
+	"PoE",
+	"Legacy",
+	"pre-PoE+",
+	"PoE+",
+];
+
+// possible poe states for a port
+//   realtek-poe/src/main.c
+//   static int poe_reply_4_port_status()
+const POE_STATES = [
+	"Disabled",
+	"Searching",
+	"Delivering power",
+	"Fault",
+	"Other fault",
+	"Requesting power",
+];
+
+
+// start main scraping function:
+
+
+// helper vars
+const mcu         = poe_info["mcu"];
+const ports       = poe_info["ports"];
+const budget      = poe_info["budget"];
+const firmware    = poe_info["firmware"];
+const consumption = poe_info["consumption"];
+
+// push info, budget and consumption metric
+gauge(`realtek_poe_switch_info`)({ mcu: mcu, firmware: firmware }, 1);
+gauge(`realtek_poe_switch_budget_watts`)(null, budget);
+gauge(`realtek_poe_switch_consumption_watts`)(null, consumption);
+
+// push per port priority metrics
+const priority_metric = gauge(`realtek_poe_port_priority`);
+for (port, values in ports) {
+	priority_metric({ device: port }, values["priority"]);
+}
+
+// push per port consumption metrics
+const consumption_metric = gauge(`realtek_poe_port_consumption_watts`);
+for (port, values in ports) {
+	consumption_metric({ device: port }, (values["consumption"] || 0));
+}
+
+// push per port state metrics
+const state_metric = gauge(`realtek_poe_port_state`);
+for (let state in POE_STATES) {
+	for (port, values in ports) {
+		state_metric({ device: port, state: state }, (values["status"] == state) ? 1 : 0);
+	}
+}
+
+// push per port mode metrics
+const mode_metric = gauge(`realtek_poe_port_mode`);
+for (let mode in POE_MODES) {
+	for (port, values in ports) {
+		mode_metric({ device: port, mode: mode }, (values["mode"] == mode) ? 1 : 0);
+	}
+}
+
+

utils/prometheus-node-exporter-ucode/files/extra/thermal.uc

@@ -0,0 +1,73 @@
+
+// modelled after: https://github.com/prometheus/node_exporter/blob/master/collector/thermal_zone_linux.go
+// See also: https://docs.kernel.org/driver-api/thermal/sysfs-api.html
+
+// thermal collector
+const thermal_devs = [];
+
+for (let idx = 0; ; idx++) {
+	const devPath = `/sys/class/thermal/thermal_zone${idx}`;
+	const typ = oneline(devPath + "/type");
+	if (!typ) break;
+
+	const policy = oneline(devPath + "/policy");
+	if (!policy) break;
+
+	const temp = oneline(devPath + "/temp");
+	if (!temp) break;
+
+	push(thermal_devs, {
+		idx,
+		typ,
+		policy,
+		temp,
+		mode: oneline(devPath + "/mode"),
+		passive: oneline(devPath + "/passive"),
+	});
+}
+
+if (length(thermal_devs) > 0) {	
+	const temp_metric = gauge("node_thermal_zone_temp", "Zone temperature in Celsius");
+
+	for (let d in thermal_devs) {
+		const labels = { zone: `${d.idx}`, type: d.typ, policy: d.policy };
+		if (d.passive) labels.passive = d.passive;
+
+		temp_metric(labels, d.temp / 1000.00);
+	}
+}
+
+// cooling collector
+const cooling_devs = [];
+
+for (let idx = 0; ; idx++) {
+	const devPath = `/sys/class/thermal/cooling_device${idx}`;
+	const typ = oneline(devPath + "/type");
+	if (!typ) break;
+
+	push(cooling_devs, {
+		idx,
+		typ,
+		cur: oneline(devPath + "/cur_state"),
+		max: oneline(devPath + "/max_state"),
+	});
+}
+
+if (length(cooling_devs) > 0) {	
+
+	const cur_throttle = gauge("node_cooling_device_cur_state", "Current throttle state of the cooling device");
+
+	for (let d in cooling_devs) {
+		const labels = { name: `${d.idx}`, type: d.typ };
+
+		cur_throttle(labels, d.cur);
+	}
+
+	const max_throttle = gauge("node_cooling_device_max_state", "Maximum throttle state of the cooling device");
+
+	for (let d in cooling_devs) {
+		const labels = { name: `${d.idx}`, type: d.typ };
+
+		max_throttle(labels, d.max);
+	}
+}

utils/prometheus-node-exporter-ucode/files/metrics.uc

@@ -156,8 +156,10 @@ global.handle_request = function(env) {
 
 	httpstatus("200 OK");
 
-	let duration = gauge("node_scrape_collector_duration_seconds");
-	let success = gauge("node_scrape_collector_success");
+	let duration = gauge("node_scrape_collector_duration_seconds",
+		"node_exporter: Duration of a collector scrape.");
+	let success = gauge("node_scrape_collector_success",
+		"node_exporter: Whether a collector succeeded.");
 
 	for (let col in cols) {
 		let ok = false;