Skip metrics when standby JSON cached

When smartctl returns standby (exit status bit 1), we cache the minimal JSON so power_mode can still be exported. That JSON omits capacity, block size, device info, and NVMe health fields, so collectors must skip those metrics when fields are missing to avoid emitting zeros or empty-label series.

Signed-off-by: Yonathan Randolph <yonathan@gmail.com>

Author: yonran

main.go

@@ -57,7 +57,9 @@ type SMARTctlManagerCollector struct {
 
 // Describe sends the super-set of all possible descriptors of metrics
 func (i *SMARTctlManagerCollector) Describe(ch chan<- *prometheus.Desc) {
-	prometheus.DescribeByCollect(i, ch)
+	for _, desc := range allMetricDescs {
+		ch <- desc
+	}
 }
 
 // Collect is called by the Prometheus registry when collecting metrics.

metrics.go

@@ -362,4 +362,45 @@ var (
 		},
 		nil,
 	)
+	allMetricDescs = []*prometheus.Desc{
+		metricSmartctlVersion,
+		metricDeviceModel,
+		metricDeviceCount,
+		metricDeviceCapacityBlocks,
+		metricDeviceCapacityBytes,
+		metricDeviceTotalCapacityBytes,
+		metricDeviceBlockSize,
+		metricDeviceInterfaceSpeed,
+		metricDeviceAttribute,
+		metricDevicePowerOnSeconds,
+		metricDeviceRotationRate,
+		metricDeviceTemperature,
+		metricDevicePowerCycleCount,
+		metricDevicePercentageUsed,
+		metricDeviceAvailableSpare,
+		metricDeviceAvailableSpareThreshold,
+		metricDeviceCriticalWarning,
+		metricDeviceMediaErrors,
+		metricDeviceNumErrLogEntries,
+		metricDeviceBytesRead,
+		metricDeviceBytesWritten,
+		metricDeviceSmartStatus,
+		metricDeviceExitStatus,
+		metricDeviceState,
+		metricDevicePowerMode,
+		metricDeviceStatistics,
+		metricDeviceErrorLogCount,
+		metricDeviceSelfTestLogCount,
+		metricDeviceSelfTestLogErrorCount,
+		metricDeviceERCSeconds,
+		metricSCSIGrownDefectList,
+		metricReadErrorsCorrectedByRereadsRewrites,
+		metricReadErrorsCorrectedByEccFast,
+		metricReadErrorsCorrectedByEccDelayed,
+		metricReadTotalUncorrectedErrors,
+		metricWriteErrorsCorrectedByRereadsRewrites,
+		metricWriteErrorsCorrectedByEccFast,
+		metricWriteErrorsCorrectedByEccDelayed,
+		metricWriteTotalUncorrectedErrors,
+	}
 )

smartctl.go

@@ -132,6 +132,23 @@ func (smart *SMARTctl) mineExitStatus() {
 }
 
 func (smart *SMARTctl) mineDevice() {
+	hasInfo := false
+	for _, key := range []string{
+		"model_name",
+		"scsi_vendor",
+		"scsi_product",
+		"serial_number",
+		"firmware_version",
+		"model_family",
+	} {
+		if smart.json.Get(key).Exists() {
+			hasInfo = true
+			break
+		}
+	}
+	if !hasInfo {
+		return
+	}
 	smart.ch <- prometheus.MustNewConstMetric(
 		metricDeviceModel,
 		prometheus.GaugeValue,
@@ -171,18 +188,27 @@ func (smart *SMARTctl) mineCapacity() {
 	// The user_capacity exists only when NVMe have single namespace. Otherwise,
 	// for NVMe devices with multiple namespaces, when device name used without
 	// namespace number (exporter case) user_capacity will be absent
-	smart.ch <- prometheus.MustNewConstMetric(
-		metricDeviceCapacityBlocks,
-		prometheus.GaugeValue,
-		smart.json.Get("user_capacity.blocks").Float(),
-		smart.device.device,
-	)
-	smart.ch <- prometheus.MustNewConstMetric(
-		metricDeviceCapacityBytes,
-		prometheus.GaugeValue,
-		smart.json.Get("user_capacity.bytes").Float(),
-		smart.device.device,
-	)
+	userCapacity := smart.json.Get("user_capacity")
+	if userCapacity.Exists() {
+		blocks := userCapacity.Get("blocks")
+		if blocks.Exists() {
+			smart.ch <- prometheus.MustNewConstMetric(
+				metricDeviceCapacityBlocks,
+				prometheus.GaugeValue,
+				blocks.Float(),
+				smart.device.device,
+			)
+		}
+		bytes := userCapacity.Get("bytes")
+		if bytes.Exists() {
+			smart.ch <- prometheus.MustNewConstMetric(
+				metricDeviceCapacityBytes,
+				prometheus.GaugeValue,
+				bytes.Float(),
+				smart.device.device,
+			)
+		}
+	}
 	nvme_total_capacity := smart.json.Get("nvme_total_capacity")
 	if nvme_total_capacity.Exists() {
 		smart.ch <- prometheus.MustNewConstMetric(
@@ -196,10 +222,14 @@ func (smart *SMARTctl) mineCapacity() {
 
 func (smart *SMARTctl) mineBlockSize() {
 	for _, blockType := range []string{"logical", "physical"} {
+		blockSize := smart.json.Get(fmt.Sprintf("%s_block_size", blockType))
+		if !blockSize.Exists() {
+			continue
+		}
 		smart.ch <- prometheus.MustNewConstMetric(
 			metricDeviceBlockSize,
 			prometheus.GaugeValue,
-			smart.json.Get(fmt.Sprintf("%s_block_size", blockType)).Float(),
+			blockSize.Float(),
 			smart.device.device,
 			blockType,
 		)
@@ -342,55 +372,79 @@ func (smart *SMARTctl) mineDeviceSCTStatus() {
 }
 
 func (smart *SMARTctl) mineNvmePercentageUsed() {
+	percentageUsed := smart.json.Get("nvme_smart_health_information_log.percentage_used")
+	if !percentageUsed.Exists() {
+		return
+	}
 	smart.ch <- prometheus.MustNewConstMetric(
 		metricDevicePercentageUsed,
 		prometheus.CounterValue,
-		smart.json.Get("nvme_smart_health_information_log.percentage_used").Float(),
+		percentageUsed.Float(),
 		smart.device.device,
 	)
 }
 
 func (smart *SMARTctl) mineNvmeAvailableSpare() {
+	availableSpare := smart.json.Get("nvme_smart_health_information_log.available_spare")
+	if !availableSpare.Exists() {
+		return
+	}
 	smart.ch <- prometheus.MustNewConstMetric(
 		metricDeviceAvailableSpare,
 		prometheus.CounterValue,
-		smart.json.Get("nvme_smart_health_information_log.available_spare").Float(),
+		availableSpare.Float(),
 		smart.device.device,
 	)
 }
 
 func (smart *SMARTctl) mineNvmeAvailableSpareThreshold() {
+	availableSpareThreshold := smart.json.Get("nvme_smart_health_information_log.available_spare_threshold")
+	if !availableSpareThreshold.Exists() {
+		return
+	}
 	smart.ch <- prometheus.MustNewConstMetric(
 		metricDeviceAvailableSpareThreshold,
 		prometheus.CounterValue,
-		smart.json.Get("nvme_smart_health_information_log.available_spare_threshold").Float(),
+		availableSpareThreshold.Float(),
 		smart.device.device,
 	)
 }
 
 func (smart *SMARTctl) mineNvmeCriticalWarning() {
+	criticalWarning := smart.json.Get("nvme_smart_health_information_log.critical_warning")
+	if !criticalWarning.Exists() {
+		return
+	}
 	smart.ch <- prometheus.MustNewConstMetric(
 		metricDeviceCriticalWarning,
 		prometheus.CounterValue,
-		smart.json.Get("nvme_smart_health_information_log.critical_warning").Float(),
+		criticalWarning.Float(),
 		smart.device.device,
 	)
 }
 
 func (smart *SMARTctl) mineNvmeMediaErrors() {
+	mediaErrors := smart.json.Get("nvme_smart_health_information_log.media_errors")
+	if !mediaErrors.Exists() {
+		return
+	}
 	smart.ch <- prometheus.MustNewConstMetric(
 		metricDeviceMediaErrors,
 		prometheus.CounterValue,
-		smart.json.Get("nvme_smart_health_information_log.media_errors").Float(),
+		mediaErrors.Float(),
 		smart.device.device,
 	)
 }
 
 func (smart *SMARTctl) mineNvmeNumErrLogEntries() {
+	numErrLogEntries := smart.json.Get("nvme_smart_health_information_log.num_err_log_entries")
+	if !numErrLogEntries.Exists() {
+		return
+	}
 	smart.ch <- prometheus.MustNewConstMetric(
 		metricDeviceNumErrLogEntries,
 		prometheus.CounterValue,
-		smart.json.Get("nvme_smart_health_information_log.num_err_log_entries").Float(),
+		numErrLogEntries.Float(),
 		smart.device.device,
 	)
 }

smartctl_test.go

@@ -14,7 +14,14 @@
 package main
 
 import (
+	"io"
+	"log/slog"
+	"os"
+	"strings"
 	"testing"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/tidwall/gjson"
 )
 
 func TestBuildDeviceLabel(t *testing.T) {
@@ -42,3 +49,69 @@ func TestBuildDeviceLabel(t *testing.T) {
 		}
 	}
 }
+
+func TestStandbyJSONSkipsMissingMetrics(t *testing.T) {
+	names := collectMetricNames(t, "testdata/standby-sdc.json")
+	expected := map[string]struct{}{
+		"smartctl_device_power_mode":           {},
+		"smartctl_device_smartctl_exit_status": {},
+	}
+
+	if len(names) != len(expected) {
+		t.Fatalf("expected %d metrics, got %d: %v", len(expected), len(names), names)
+	}
+	for name := range expected {
+		if _, ok := names[name]; !ok {
+			t.Fatalf("missing metric %q", name)
+		}
+	}
+	for name := range names {
+		if _, ok := expected[name]; !ok {
+			t.Fatalf("unexpected metric %q", name)
+		}
+	}
+}
+
+func collectMetricNames(t *testing.T, jsonPath string) map[string]struct{} {
+	t.Helper()
+
+	data, err := os.ReadFile(jsonPath)
+	if err != nil {
+		t.Fatalf("read json: %v", err)
+	}
+	json := gjson.ParseBytes(data)
+
+	ch := make(chan prometheus.Metric)
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+	smart := NewSMARTctl(logger, json, ch)
+
+	go func() {
+		smart.Collect()
+		close(ch)
+	}()
+
+	names := make(map[string]struct{})
+	for metric := range ch {
+		name := metricName(metric)
+		if name == "" {
+			t.Fatalf("missing metric name for %v", metric)
+		}
+		names[name] = struct{}{}
+	}
+	return names
+}
+
+func metricName(metric prometheus.Metric) string {
+	desc := metric.Desc().String()
+	const prefix = `fqName: "`
+	start := strings.Index(desc, prefix)
+	if start == -1 {
+		return ""
+	}
+	start += len(prefix)
+	end := strings.Index(desc[start:], `"`)
+	if end == -1 {
+		return ""
+	}
+	return desc[start : start+end]
+}