docker: calculate zero cpu percent correctly (#26902) (#26915)

* docker: calculate zero cpu percent correctly

Corrects the guard clause in the docker driver `CalculateCPUPercent` to
return zero if the two uint64 values can't be subtracted, by checking if
the value being subtracted isn't larger than the other. This has to be
done prior to subtracting the values, because subtracting two uint64
values will never result in a value lower than zero, which is what the
original clause checked, but instead wraps around on itself.

These values are used in metrics, where it would appear that a docker
container/alloc that was shutting down would use all of the cpu at the
time of shutdown. This was manifesting in strange DAS autoscaling
behavior during development while deploying new jobs.

* add changelog

Co-authored-by: Allison Larson <[email protected]>

Author: hc-github-team-nomad-core

.changelog/26902.txt

@@ -0,0 +1,3 @@
+```release-note:bug
+docker: Fixed a bug where cpu usage percentage was incorrectly measured when container was stopped
+```

drivers/docker/util/util.go

@@ -4,11 +4,11 @@
 package util
 
 func CalculateCPUPercent(newSample, oldSample, newTotal, oldTotal uint64, cores int) float64 {
-	numerator := newSample - oldSample
-	denom := newTotal - oldTotal
-	if numerator <= 0 || denom <= 0 {
+	if (newSample <= oldSample) || (newTotal <= oldTotal) {
 		return 0.0
 	}
+	numerator := newSample - oldSample
+	denom := newTotal - oldTotal
 
 	return (float64(numerator) / float64(denom)) * float64(cores) * 100.0
 }

drivers/docker/util/util_test.go

@@ -0,0 +1,66 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package util
+
+import (
+	"testing"
+
+	"github.com/shoenig/test/must"
+)
+
+func TestCalculateCPUPercent(t *testing.T) {
+	tests := []struct {
+		name      string
+		newSample uint64
+		oldSample uint64
+		newTotal  uint64
+		oldTotal  uint64
+		cores     int
+		expected  float64
+	}{
+		{
+			name:      "valid case",
+			newSample: 100,
+			oldSample: 50,
+			newTotal:  200,
+			oldTotal:  100,
+			cores:     4,
+			expected:  200.0,
+		},
+		{
+			name:      "zero denominator",
+			newSample: 100,
+			oldSample: 50,
+			newTotal:  100,
+			oldTotal:  100,
+			cores:     4,
+			expected:  0.0,
+		},
+		{
+			name:      "zero numerator",
+			newSample: 100,
+			oldSample: 100,
+			newTotal:  100,
+			oldTotal:  50,
+			cores:     4,
+			expected:  0.0,
+		},
+		{
+			name:      "negative case",
+			newSample: 50,
+			oldSample: 100,
+			newTotal:  100,
+			oldTotal:  200,
+			cores:     4,
+			expected:  0.0,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := CalculateCPUPercent(tt.newSample, tt.oldSample, tt.newTotal, tt.oldTotal, tt.cores)
+			must.Eq(t, tt.expected, result)
+		})
+	}
+}