fix: use monotonic clock for elapsed time and handle nil max_elapsed_time (#122)

* fix: use monotonic clock for elapsed time and handle nil max_elapsed_time

- Replace Time.now with Process.clock_gettime(CLOCK_MONOTONIC) so retry
  timing is immune to wall-clock adjustments (NTP, manual changes).
- Guard can_retry? against max_elapsed_time: nil, which previously raised
  NoMethodError on the comparison path.
- Remove dead '* 1.0' in ExponentialBackoff#randomize (rand_factor is
  already a float).
- Add regression tests for both fixes.

* address PR review: fix float coercion, strengthen tests, document nil max_elapsed_time

* docs: add changelog entries for monotonic clock and nil max_elapsed_time fixes

Author: kamui

CHANGELOG.md

@@ -1,5 +1,9 @@
 # HEAD
 
+- Fix: Use `Process.clock_gettime(CLOCK_MONOTONIC)` for elapsed time tracking so retry timing is immune to wall-clock adjustments (NTP, manual changes).
+- Fix: Handle `max_elapsed_time: nil` gracefully instead of raising `NoMethodError`.
+- Remove dead `* 1.0` float coercion in `ExponentialBackoff#randomize`.
+
 ## 3.4.0
 
 - Add `retry_if` option to support custom retry predicates, including checks against wrapped `exception.cause` values.

README.md

@@ -87,7 +87,7 @@ Here are the available options, in some vague order of relevance to most common
 | **`on_retry`**         | `nil`             | `Proc` to call after each try is rescued. [Read more](#callbacks).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | **`sleep_disabled`**   | `false`           | When true, disable exponential backoff and attempt retries immediately.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | **`base_interval`**    | `0.5`             | The initial interval in seconds between tries.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| **`max_elapsed_time`** | `900` (15 min)    | The maximum amount of total time in seconds that code is allowed to keep being retried.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| **`max_elapsed_time`** | `900` (15 min)    | The maximum amount of total time in seconds that code is allowed to keep being retried. Set to `nil` to disable the time limit and retry based solely on `tries`.                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | **`max_interval`**     | `60`              | The maximum interval in seconds that any individual retry can reach.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | **`multiplier`**       | `1.5`             | Each successive interval grows by this factor. A multipler of 1.5 means the next interval will be 1.5x the current interval.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | **`rand_factor`**      | `0.5`             | The percentage to randomize the next retry interval time. The next interval calculation is `randomized_interval = retry_interval * (random value in range [1 - randomization_factor, 1 + randomization_factor])`                                                                                                                                                                                                                                                                                                                                                                                                      |

lib/retriable.rb

@@ -41,8 +41,8 @@ def retriable(opts = {}, &block)
 
     exception_list = on.is_a?(Hash) ? on.keys : on
     exception_list = [*exception_list]
-    start_time = Time.now
-    elapsed_time = -> { Time.now - start_time }
+    start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    elapsed_time = -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time }
 
     tries = intervals.size + 1
 
@@ -101,7 +101,10 @@ def call_on_retry(on_retry, exception, try, elapsed_time, interval)
   end
 
   def can_retry?(try, tries, elapsed_time, interval, max_elapsed_time)
-    try < tries && (elapsed_time + interval) <= max_elapsed_time
+    return false unless try < tries
+    return true if max_elapsed_time.nil?
+
+    (elapsed_time + interval) <= max_elapsed_time
   end
 
   # When `on` is a Hash, we need to verify the exception matches a pattern.

lib/retriable/exponential_backoff.rb

@@ -28,7 +28,7 @@ def initialize(opts = {})
 
     def intervals
       intervals = Array.new(tries) do |iteration|
-        [base_interval * multiplier**iteration, max_interval].min
+        [base_interval * (multiplier**iteration), max_interval].min
       end
 
       return intervals if rand_factor.zero?
@@ -39,7 +39,7 @@ def intervals
     private
 
     def randomize(interval)
-      delta = rand_factor * interval * 1.0
+      delta = rand_factor * interval.to_f
       min = interval - delta
       max = interval + delta
       rand(min..max)

spec/retriable_spec.rb

@@ -315,6 +315,38 @@ def increment_tries_with_exception(exception_class = nil)
       expect(@tries).to eq(2)
     end
 
+    it "retries up to tries limit when max_elapsed_time is nil" do
+      expect do
+        described_class.retriable(tries: 4, max_elapsed_time: nil) { increment_tries_with_exception }
+      end.to raise_error(StandardError)
+
+      expect(@tries).to eq(4)
+    end
+
+    it "uses monotonic clock for elapsed time tracking" do
+      # Stub Process.clock_gettime to return controlled values so we can
+      # verify elapsed_time passed to on_retry is derived from the monotonic clock.
+      clock_calls = 0
+      allow(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC) do
+        value = clock_calls.to_f
+        clock_calls += 1
+        value
+      end
+
+      elapsed_times = []
+      on_retry = ->(_exception, _try, elapsed_time, _next_interval) { elapsed_times << elapsed_time }
+
+      expect do
+        described_class.retriable(tries: 3, on_retry: on_retry) { increment_tries_with_exception }
+      end.to raise_error(StandardError)
+
+      # start_time (call 0) + at least one elapsed_time computation per retry
+      expect(clock_calls).to be >= 3
+      # elapsed_time values should be positive and non-decreasing
+      expect(elapsed_times).to all(be > 0)
+      expect(elapsed_times).to eq(elapsed_times.sort)
+    end
+
     it "raises ArgumentError on invalid options" do
       expect { described_class.retriable(does_not_exist: 123) { increment_tries } }.to raise_error(ArgumentError)
     end