Add graph CDEF metric scaling and normalize metrics as int64s (#26)

Author: kylerisse

pkg/check/descriptor.go

@@ -13,6 +13,12 @@ type MetricDef struct {
 
 	// Unit is the unit of measurement for graphs and display (e.g. "ms").
 	Unit string
+
+	// Scale is the divisor applied to convert the raw stored value to
+	// the display unit. For example, ping stores microseconds but
+	// displays milliseconds, so Scale is 1000.
+	// A value of 0 or 1 means no scaling is applied.
+	Scale int
 }
 
 // Descriptor declares static metadata about a check type, including

pkg/check/descriptor_test.go

@@ -14,7 +14,7 @@ func TestDescriptor_ZeroValue(t *testing.T) {
 func TestDescriptor_WithMetrics(t *testing.T) {
 	d := Descriptor{
 		Metrics: []MetricDef{
-			{ResultKey: "latency_us", DSName: "latency", Label: "latency", Unit: "ms"},
+			{ResultKey: "latency_us", DSName: "latency", Label: "latency", Unit: "ms", Scale: 1000},
 			{ResultKey: "rx_bytes", DSName: "rx", Label: "received", Unit: "bytes"},
 		},
 	}
@@ -24,7 +24,24 @@ func TestDescriptor_WithMetrics(t *testing.T) {
 	if d.Metrics[0].ResultKey != "latency_us" {
 		t.Errorf("expected first ResultKey 'latency_us', got %q", d.Metrics[0].ResultKey)
 	}
+	if d.Metrics[0].Scale != 1000 {
+		t.Errorf("expected first Scale 1000, got %d", d.Metrics[0].Scale)
+	}
 	if d.Metrics[1].DSName != "rx" {
 		t.Errorf("expected second DSName 'rx', got %q", d.Metrics[1].DSName)
 	}
 }
+
+func TestDescriptor_ScaleZeroMeansNoScaling(t *testing.T) {
+	d := MetricDef{ResultKey: "rtt_ms", DSName: "rtt", Label: "rtt", Unit: "ms", Scale: 0}
+	if d.Scale != 0 {
+		t.Errorf("expected Scale 0, got %d", d.Scale)
+	}
+}
+
+func TestDescriptor_ScaleOneMeansNoScaling(t *testing.T) {
+	d := MetricDef{ResultKey: "rtt_ms", DSName: "rtt", Label: "rtt", Unit: "ms", Scale: 1}
+	if d.Scale != 1 {
+		t.Errorf("expected Scale 1, got %d", d.Scale)
+	}
+}

pkg/check/ping/ping.go

@@ -30,7 +30,7 @@ const (
 // Desc describes the metrics produced by a ping check.
 var Desc = check.Descriptor{
 	Metrics: []check.MetricDef{
-		{ResultKey: "latency_us", DSName: "latency", Label: "latency", Unit: "ms"},
+		{ResultKey: "latency_us", DSName: "latency", Label: "latency", Unit: "ms", Scale: 1000},
 	},
 }
 
@@ -126,8 +126,8 @@ func (p *Ping) Run(ctx context.Context) check.Result {
 	return check.Result{
 		Timestamp: now,
 		Success:   true,
-		Metrics: map[string]float64{
-			"latency_us": float64(latency.Microseconds()),
+		Metrics: map[string]int64{
+			"latency_us": int64(latency.Microseconds()),
 		},
 	}
 }

pkg/check/ping/ping_test.go

@@ -267,6 +267,9 @@ func TestDesc(t *testing.T) {
 	if m.Unit != "ms" {
 		t.Errorf("expected Unit 'ms', got %q", m.Unit)
 	}
+	if m.Scale != 1000 {
+		t.Errorf("expected Scale 1000, got %d", m.Scale)
+	}
 }
 
 func TestRegistryIntegration(t *testing.T) {
@@ -291,6 +294,9 @@ func TestRegistryIntegration(t *testing.T) {
 	if len(desc.Metrics) != 1 || desc.Metrics[0].ResultKey != "latency_us" {
 		t.Errorf("unexpected descriptor: %+v", desc)
 	}
+	if desc.Metrics[0].Scale != 1000 {
+		t.Errorf("expected Scale 1000, got %d", desc.Metrics[0].Scale)
+	}
 }
 
 // TestRun_Localhost actually pings localhost. Requires ping binary on PATH.
@@ -317,7 +323,7 @@ func TestRun_Localhost(t *testing.T) {
 		t.Fatal("expected latency_us metric")
 	}
 	if latency <= 0 {
-		t.Errorf("expected positive latency, got %f", latency)
+		t.Errorf("expected positive latency, got %d", latency)
 	}
 }
 

pkg/check/result.go

@@ -15,7 +15,7 @@ type Result struct {
 	// Metrics holds named measurements from the check execution.
 	// For example, a ping check might set {"latency_us": 1234.0}.
 	// An empty or nil map is valid for checks that only report success/failure.
-	Metrics map[string]float64
+	Metrics map[string]int64
 
 	// Err holds any error encountered during check execution.
 	// A non-nil Err generally corresponds to Success being false,

pkg/check/result_test.go

@@ -25,12 +25,12 @@ func TestResult_WithMetrics(t *testing.T) {
 	r := Result{
 		Timestamp: time.Now(),
 		Success:   true,
-		Metrics:   map[string]float64{"latency_us": 1234.5},
+		Metrics:   map[string]int64{"latency_us": 12345},
 	}
 	if !r.Success {
 		t.Error("expected success")
 	}
-	if v, ok := r.Metrics["latency_us"]; !ok || v != 1234.5 {
-		t.Errorf("expected latency_us=1234.5, got %v", v)
+	if v, ok := r.Metrics["latency_us"]; !ok || v != 12345 {
+		t.Errorf("expected latency_us=12345, got %v", v)
 	}
 }

pkg/check/status.go

@@ -28,7 +28,7 @@ func (s *Status) Alive() bool {
 // Metric returns the value of a named metric from the last result.
 // Returns the value and true if found, or 0 and false if not present
 // or the last check failed.
-func (s *Status) Metric(key string) (float64, bool) {
+func (s *Status) Metric(key string) (int64, bool) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	if !s.lastResult.Success || s.lastResult.Metrics == nil {
@@ -66,9 +66,9 @@ func (s *Status) Snapshot() StatusSnapshot {
 	defer s.mu.RUnlock()
 
 	// Deep copy the metrics map so the snapshot is independent
-	var metrics map[string]float64
+	var metrics map[string]int64
 	if s.lastResult.Metrics != nil {
-		metrics = make(map[string]float64, len(s.lastResult.Metrics))
+		metrics = make(map[string]int64, len(s.lastResult.Metrics))
 		for k, v := range s.lastResult.Metrics {
 			metrics[k] = v
 		}
@@ -84,6 +84,6 @@ func (s *Status) Snapshot() StatusSnapshot {
 // StatusSnapshot is a point-in-time copy of Status fields.
 type StatusSnapshot struct {
 	Alive      bool
-	Metrics    map[string]float64
+	Metrics    map[string]int64
 	LastUpdate int64
 }

pkg/check/status_test.go

@@ -11,7 +11,7 @@ func TestNewStatus_ZeroValues(t *testing.T) {
 		t.Error("new status should not be alive")
 	}
 	if v, ok := s.Metric("latency_us"); ok {
-		t.Errorf("new status should have no metrics, got latency_us=%f", v)
+		t.Errorf("new status should have no metrics, got latency_us=%d", v)
 	}
 	if s.LastUpdate() != 0 {
 		t.Errorf("new status should have zero last update, got %d", s.LastUpdate())
@@ -22,7 +22,7 @@ func TestStatus_SetResult_Success(t *testing.T) {
 	s := NewStatus()
 	s.SetResult(Result{
 		Success: true,
-		Metrics: map[string]float64{"latency_us": 1234.0},
+		Metrics: map[string]int64{"latency_us": 1234},
 	})
 
 	if !s.Alive() {
@@ -32,8 +32,8 @@ func TestStatus_SetResult_Success(t *testing.T) {
 	if !ok {
 		t.Fatal("expected latency_us metric to be present")
 	}
-	if v != 1234.0 {
-		t.Errorf("expected latency_us=1234.0, got %f", v)
+	if v != 1234 {
+		t.Errorf("expected latency_us=1234.0, got %d", v)
 	}
 }
 
@@ -42,7 +42,7 @@ func TestStatus_SetResult_Failure(t *testing.T) {
 	// First set it alive
 	s.SetResult(Result{
 		Success: true,
-		Metrics: map[string]float64{"latency_us": 1000.0},
+		Metrics: map[string]int64{"latency_us": 1000},
 	})
 	// Then fail
 	s.SetResult(Result{
@@ -61,7 +61,7 @@ func TestStatus_SetResult_SuccessWithoutMetrics(t *testing.T) {
 	s := NewStatus()
 	s.SetResult(Result{
 		Success: true,
-		Metrics: map[string]float64{},
+		Metrics: map[string]int64{},
 	})
 
 	if !s.Alive() {
@@ -76,19 +76,19 @@ func TestStatus_Metric_MultipleMetrics(t *testing.T) {
 	s := NewStatus()
 	s.SetResult(Result{
 		Success: true,
-		Metrics: map[string]float64{
-			"latency_us":    1234.0,
-			"response_code": 200.0,
+		Metrics: map[string]int64{
+			"latency_us":    12340,
+			"response_code": 2000,
 		},
 	})
 
 	v, ok := s.Metric("latency_us")
-	if !ok || v != 1234.0 {
-		t.Errorf("expected latency_us=1234.0, got %f (ok=%v)", v, ok)
+	if !ok || v != 12340 {
+		t.Errorf("expected latency_us=12340, got %d (ok=%v)", v, ok)
 	}
 	v, ok = s.Metric("response_code")
-	if !ok || v != 200.0 {
-		t.Errorf("expected response_code=200.0, got %f (ok=%v)", v, ok)
+	if !ok || v != 2000 {
+		t.Errorf("expected response_code=2000, got %d (ok=%v)", v, ok)
 	}
 	if _, ok := s.Metric("nonexistent"); ok {
 		t.Error("expected nonexistent metric to not be found")
@@ -108,7 +108,7 @@ func TestStatus_Snapshot(t *testing.T) {
 	s := NewStatus()
 	s.SetResult(Result{
 		Success: true,
-		Metrics: map[string]float64{"latency_us": 5678.0},
+		Metrics: map[string]int64{"latency_us": 5678},
 	})
 	s.SetLastUpdate(1700000000)
 
@@ -117,8 +117,8 @@ func TestStatus_Snapshot(t *testing.T) {
 	if !snap.Alive {
 		t.Error("snapshot should be alive")
 	}
-	if v, ok := snap.Metrics["latency_us"]; !ok || v != 5678.0 {
-		t.Errorf("snapshot metrics: expected latency_us=5678.0, got %v (ok=%v)", v, ok)
+	if v, ok := snap.Metrics["latency_us"]; !ok || v != 5678 {
+		t.Errorf("snapshot metrics: expected latency_us=5678, got %v (ok=%v)", v, ok)
 	}
 	if snap.LastUpdate != 1700000000 {
 		t.Errorf("snapshot last update: expected 1700000000, got %d", snap.LastUpdate)
@@ -129,7 +129,7 @@ func TestStatus_Snapshot_Independent(t *testing.T) {
 	s := NewStatus()
 	s.SetResult(Result{
 		Success: true,
-		Metrics: map[string]float64{"latency_us": 1000.0},
+		Metrics: map[string]int64{"latency_us": 1000},
 	})
 
 	snap := s.Snapshot()
@@ -150,18 +150,18 @@ func TestStatus_Snapshot_MetricsMapIndependent(t *testing.T) {
 	s := NewStatus()
 	s.SetResult(Result{
 		Success: true,
-		Metrics: map[string]float64{"latency_us": 1000.0},
+		Metrics: map[string]int64{"latency_us": 1000},
 	})
 
 	snap := s.Snapshot()
 
 	// Mutate the snapshot's metrics map
-	snap.Metrics["latency_us"] = 9999.0
+	snap.Metrics["latency_us"] = 9999
 
 	// Status should be unaffected
 	v, ok := s.Metric("latency_us")
-	if !ok || v != 1000.0 {
-		t.Errorf("mutating snapshot should not affect status, got %f", v)
+	if !ok || v != 1000 {
+		t.Errorf("mutating snapshot should not affect status, got %d", v)
 	}
 }
 
@@ -176,7 +176,7 @@ func TestStatus_ConcurrentAccess(t *testing.T) {
 			defer wg.Done()
 			s.SetResult(Result{
 				Success: true,
-				Metrics: map[string]float64{"latency_us": float64(n)},
+				Metrics: map[string]int64{"latency_us": int64(n)},
 			})
 			s.SetLastUpdate(int64(n))
 		}(i)

pkg/rrd/graph.go

@@ -18,6 +18,7 @@ type graph struct {
 	timeLength            string // Time length for the graph (e.g., "4h" "1d")
 	dsName                string // RRD data source name (e.g., "latency")
 	unit                  string // Unit of measurement (e.g., "ms")
+	scale                 int    // Divisor to convert raw value to display unit (0 or 1 = no scaling)
 	consolidationFunction string // Consolidation function (e.g., "AVERAGE" "MAX")
 	color                 string // Metric color (e.g., "#FF0001" (red))
 	comment               string // Comment at bottom of graph
@@ -36,12 +37,13 @@ type graph struct {
 //   - dsName: The RRD data source name (e.g., "latency").
 //   - label: The human-readable label for the metric (e.g., "latency").
 //   - unit: The unit of measurement (e.g., "ms").
+//   - scale: The divisor to convert the raw stored value to display unit (0 or 1 = no scaling).
 //   - logger: The logger instance.
 //
 // Returns:
 //   - *Graph: A pointer to the newly created Graph struct.
 //   - error: An error if something went wrong during the initialization.
-func newGraph(host string, graphDir string, rrdPath string, timeLength string, consolidationFunction string, checkType string, dsName string, label string, unit string, logger *logrus.Logger) (*graph, error) {
+func newGraph(host string, graphDir string, rrdPath string, timeLength string, consolidationFunction string, checkType string, dsName string, label string, unit string, scale int, logger *logrus.Logger) (*graph, error) {
 
 	// Define directory and file paths
 	dirPath := fmt.Sprintf("%s/imgs/%s", graphDir, host)
@@ -63,6 +65,7 @@ func newGraph(host string, graphDir string, rrdPath string, timeLength string, c
 		timeLength:            timeLength,
 		dsName:                dsName,
 		unit:                  unit,
+		scale:                 scale,
 		consolidationFunction: consolidationFunction,
 		color:                 GREEN,
 		comment:               comment,
@@ -78,6 +81,21 @@ func newGraph(host string, graphDir string, rrdPath string, timeLength string, c
 	return graph, nil
 }
 
+// displayVarName returns the RRD variable name used for display.
+// When scaling is applied, the variable includes the unit suffix (e.g., "latency_ms").
+// When no scaling is needed, it uses the raw variable directly (e.g., "latency_raw").
+func (g *graph) displayVarName() string {
+	if g.needsScaling() {
+		return fmt.Sprintf("%s_%s", g.dsName, g.unit)
+	}
+	return fmt.Sprintf("%s_raw", g.dsName)
+}
+
+// needsScaling returns true if the raw value needs to be divided by a scale factor for display.
+func (g *graph) needsScaling() bool {
+	return g.scale > 1
+}
+
 // draw draws a graph based on the current parameters of the Graph struct.
 // It returns an error if the graph generation fails.
 func (g *graph) draw() error {
@@ -102,33 +120,37 @@ func (g *graph) draw() error {
 			COMMENT:"\MAX latency over last 4h"
 	*/
 
-	// Prepare the DEF and CDEF strings for each metric.
-	defs := []string{}
-	def := fmt.Sprintf("DEF:%s_raw=%s:%s:%s", g.dsName, g.rrdPath, g.dsName, g.consolidationFunction)
-	defs = append(defs, def)
+	displayVar := g.displayVarName()
 
-	cdefs := []string{}
-	cdef := fmt.Sprintf("CDEF:%s_%s=%s_raw,1000,/", g.dsName, g.unit, g.dsName)
-	cdefs = append(cdefs, cdef)
+	// Prepare the DEF string for the raw data source.
+	defs := []string{
+		fmt.Sprintf("DEF:%s_raw=%s:%s:%s", g.dsName, g.rrdPath, g.dsName, g.consolidationFunction),
+	}
+
+	// Prepare the CDEF string: apply scaling if needed, otherwise alias raw to display var.
+	var cdefs []string
+	if g.needsScaling() {
+		cdefs = append(cdefs, fmt.Sprintf("CDEF:%s=%s_raw,%d,/", displayVar, g.dsName, g.scale))
+	}
+	// When no scaling is needed, displayVar is already "dsName_raw" which is the DEF name,
+	// so no CDEF is required.
 
 	lines := []string{
-		fmt.Sprintf("AREA:%s_%s#%s:%s", g.dsName, g.unit, g.color, g.label),
+		fmt.Sprintf("AREA:%s#%s:%s", displayVar, g.color, g.label),
 	}
 
-	gprints := []string{}
 	gfmt := "%.2lf"
-	gprintsMinval := fmt.Sprintf("Min\\: %s %s", gfmt, g.unit)
-	gprints = append(gprints, fmt.Sprintf("GPRINT:%s_%s:MIN:%s", g.dsName, g.unit, gprintsMinval))
-	gprintsMaxval := fmt.Sprintf("Max\\: %s %s", gfmt, g.unit)
-	gprints = append(gprints, fmt.Sprintf("GPRINT:%s_%s:MAX:%s", g.dsName, g.unit, gprintsMaxval))
-	gprintsAverageval := fmt.Sprintf("Average\\: %s %s", gfmt, g.unit)
-	gprints = append(gprints, fmt.Sprintf("GPRINT:%s_%s:AVERAGE:%s", g.dsName, g.unit, gprintsAverageval))
-	gprintsLastval := fmt.Sprintf("Last\\: %s %s", gfmt, g.unit)
-	gprints = append(gprints, fmt.Sprintf("GPRINT:%s_%s:LAST:%s", g.dsName, g.unit, gprintsLastval))
-
-	commentStrings := []string{}
-	commentStrings = append(commentStrings, "COMMENT:\\n")
-	commentStrings = append(commentStrings, fmt.Sprintf("COMMENT:%s", g.comment))
+	gprints := []string{
+		fmt.Sprintf("GPRINT:%s:MIN:Min\\: %s %s", displayVar, gfmt, g.unit),
+		fmt.Sprintf("GPRINT:%s:MAX:Max\\: %s %s", displayVar, gfmt, g.unit),
+		fmt.Sprintf("GPRINT:%s:AVERAGE:Average\\: %s %s", displayVar, gfmt, g.unit),
+		fmt.Sprintf("GPRINT:%s:LAST:Last\\: %s %s", displayVar, gfmt, g.unit),
+	}
+
+	commentStrings := []string{
+		"COMMENT:\\n",
+		fmt.Sprintf("COMMENT:%s", g.comment),
+	}
 
 	// Prepare the command for generating the graph.
 	args := []string{