Use int64 for computeJitterUpperBoundMs (#426)

lib/jitter/sleep.go

@@ -7,26 +7,28 @@ import (
 
 const DefaultMaxMs = 3500
 
-func computeJitterUpperBoundMs(baseMs, maxMs, attempts int) int {
-	// https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
-	// sleep = random_between(0, min(cap, base * 2 ** attempt))
-	// 2 ** x == 1 << x
+// computeJitterUpperBoundMs calculates min(maxMs, baseMs * 2 ** attempt).
+func computeJitterUpperBoundMs(baseMs, maxMs, attempts int64) int64 {
 	if maxMs <= 0 {
 		return 0
 	}
 
 	// Check for overflows when computing base * 2 ** attempts.
+	// 2 ** x == 1 << x
 	if attemptsMaxMs := baseMs * (1 << attempts); attemptsMaxMs > 0 {
 		maxMs = min(maxMs, attemptsMaxMs)
 	}
 
 	return maxMs
 }
 
+// Jitter implements exponential backoff + jitter.
+// See: https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
+// Algorithm: sleep = random_between(0, min(cap, base * 2 ** attempt))
 func Jitter(baseMs, maxMs, attempts int) time.Duration {
-	upperBoundMs := computeJitterUpperBoundMs(baseMs, maxMs, attempts)
+	upperBoundMs := computeJitterUpperBoundMs(int64(baseMs), int64(maxMs), int64(attempts))
 	if upperBoundMs <= 0 {
 		return time.Duration(0)
 	}
-	return time.Duration(rand.Intn(upperBoundMs)) * time.Millisecond
+	return time.Duration(rand.Int63n(upperBoundMs)) * time.Millisecond
 }

lib/jitter/sleep_test.go

@@ -10,23 +10,23 @@ import (
 
 func TestComputeJitterUpperBoundMs(t *testing.T) {
 	// A maxMs that is <= 0 returns 0.
-	assert.Equal(t, 0, computeJitterUpperBoundMs(0, 0, 0))
-	assert.Equal(t, 0, computeJitterUpperBoundMs(10, 0, 0))
-	assert.Equal(t, 0, computeJitterUpperBoundMs(10, 0, 100))
-	assert.Equal(t, 0, computeJitterUpperBoundMs(10, -1, 0))
-	assert.Equal(t, 0, computeJitterUpperBoundMs(10, -1, 100))
+	assert.Equal(t, int64(0), computeJitterUpperBoundMs(0, 0, 0))
+	assert.Equal(t, int64(0), computeJitterUpperBoundMs(10, 0, 0))
+	assert.Equal(t, int64(0), computeJitterUpperBoundMs(10, 0, 100))
+	assert.Equal(t, int64(0), computeJitterUpperBoundMs(10, -1, 0))
+	assert.Equal(t, int64(0), computeJitterUpperBoundMs(10, -1, 100))
 
 	// Increasing attempts with a baseMs of 10 and essentially no maxMs.
-	assert.Equal(t, 10, computeJitterUpperBoundMs(10, math.MaxInt, 0))
-	assert.Equal(t, 20, computeJitterUpperBoundMs(10, math.MaxInt, 1))
-	assert.Equal(t, 40, computeJitterUpperBoundMs(10, math.MaxInt, 2))
-	assert.Equal(t, 80, computeJitterUpperBoundMs(10, math.MaxInt, 3))
-	assert.Equal(t, 160, computeJitterUpperBoundMs(10, math.MaxInt, 4))
+	assert.Equal(t, int64(10), computeJitterUpperBoundMs(10, math.MaxInt64, 0))
+	assert.Equal(t, int64(20), computeJitterUpperBoundMs(10, math.MaxInt64, 1))
+	assert.Equal(t, int64(40), computeJitterUpperBoundMs(10, math.MaxInt64, 2))
+	assert.Equal(t, int64(80), computeJitterUpperBoundMs(10, math.MaxInt64, 3))
+	assert.Equal(t, int64(160), computeJitterUpperBoundMs(10, math.MaxInt64, 4))
 
 	// Large inputs do not panic.
-	assert.Equal(t, 100, computeJitterUpperBoundMs(10, 100, 200))
-	assert.Equal(t, 100, computeJitterUpperBoundMs(10, 100, math.MaxInt))
-	assert.Equal(t, math.MaxInt, computeJitterUpperBoundMs(math.MaxInt, math.MaxInt, math.MaxInt))
+	assert.Equal(t, int64(100), computeJitterUpperBoundMs(10, 100, 200))
+	assert.Equal(t, int64(100), computeJitterUpperBoundMs(10, 100, math.MaxInt64))
+	assert.Equal(t, int64(math.MaxInt64), computeJitterUpperBoundMs(math.MaxInt64, math.MaxInt64, math.MaxInt64))
 }
 
 func TestJitter(t *testing.T) {