chrono_machines 0.12.1 → 0.12.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8156e7b1ab77d65376f6513e97e068e069aae17600e16167d0693226016107e5
-  data.tar.gz: d2d1996ed01a736d8e00b0e837ebde668766dbe123a123e5f2a9e52958a8b3b7
+  metadata.gz: 3ca1865b7e43357e52ad15d937ce6f55670440f01dafccd23aedf7f630227390
+  data.tar.gz: 741a3362ab90bc6c0e92a84adf4d61f96b77e7de0ec06fed6d5c460345e441cb
 SHA512:
-  metadata.gz: c77ddf57c2750d96e4b90a59978cb1a33be1a4b72967e36578cd10aed1f7394068a6a84af572a20f3b459c77898f22454c38d321956818057be6084e7e3d6a48
-  data.tar.gz: 3ef5f8b95eac8491004128c7a2ce64e556c3e2284928c33295adea25b09cd0950af5afc1e88ddee293dee3d4eb9ff7317a88b08951e384d853ac9208b5404ee3
+  metadata.gz: 102e6a17a28c093ab80566e9535416ee7b5c944774026125d8e33dc4574185ddf59779f06d1898a3c8d74642adea88a83c4fb29a05713f14b4c9e406d008035c
+  data.tar.gz: 45e6645f7072ccca139cfe422b9e32c85c87518e45a61631c24cd5c725a6f88b49c0403cdb8d5c9e4ad41e0d90ea379c823f926b870769f8142bf7eb5ae2fdc5

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 ## [Unreleased]
 
+## [0.12.3](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.12.2...chrono_machines/v0.12.3) (2026-11-06)
+
+
+### Bug Fixes
+
+* dedup retry builder failure path and test closures ([846ed9c](https://github.com/seuros/chrono_machines/commit/846ed9cf852a383ea4c5b341162685f243bd7c69))
+
+## [0.12.2](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.12.1...chrono_machines/v0.12.2) (2026-11-06)
+
+
+### Features
+
+* Backoff tracker for loops that back off on failure and reset on success ([a415dcb](https://github.com/seuros/chrono_machines/commit/a415dcbfc4e11a038049d166fc1cfcdf60917294))
+
+
+### Bug Fixes
+
+* keep test modules out of the packaged crate ([fa18ff0](https://github.com/seuros/chrono_machines/commit/fa18ff0f9a0980d9fdcb805ae007ecff5cbac553))
+
 ## [0.12.1](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.12.0...chrono_machines/v0.12.1) (2026-11-01)
 
 

data/Cargo.lock

@@ -69,7 +69,7 @@ dependencies = [
 
 [[package]]
 name = "chrono-machines"
-version = "0.10.0"
+version = "0.11.0"
 dependencies = [
  "rand",
  "tokio",
@@ -77,7 +77,7 @@ dependencies = [
 
 [[package]]
 name = "chrono_machines_native"
-version = "0.10.0"
+version = "0.10.1"
 dependencies = [
  "chrono-machines",
  "magnus",

data/ext/chrono_machines_native/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "chrono-machines"
-version = "0.10.0"
+version = "0.11.1"
 edition.workspace = true
 rust-version.workspace = true
 authors = ["Abdelkader Boudih <terminale@gmail.com>"]
@@ -10,7 +10,7 @@ repository = "https://github.com/seuros/chrono_machines"
 keywords = ["retry", "backoff", "exponential", "jitter", "resilience"]
 categories = ["no-std", "algorithms"]
 readme = "README.md"
-exclude = ["tests/"]
+exclude = ["tests/", "src/**/tests.rs"]
 
 [lib]
 name = "chrono_machines"

data/ext/chrono_machines_native/core/src/lib.rs

@@ -40,6 +40,7 @@ pub mod policy;
 #[cfg(any(feature = "std", feature = "alloc"))]
 pub mod retry;
 pub mod sleep;
+pub mod streak;
 
 /// The `rand` crate this one was built against.
 ///
@@ -89,6 +90,7 @@ pub use sleep::AsyncSleeper;
 #[cfg(feature = "std")]
 pub use sleep::StdSleeper;
 pub use sleep::{FnSleeper, Sleeper};
+pub use streak::Backoff;
 
 #[cfg(feature = "std")]
 use rand::rngs::StdRng;

data/ext/chrono_machines_native/core/src/retry.rs

@@ -42,22 +42,6 @@ pub enum DelayHint {
     Halt,
 }
 
-/// Build a terminal [`RetryError`], firing the `on_failure` callback if present.
-fn finalize_failure<E>(
-    on_failure: Option<&mut FailureCallback<E>>,
-    kind: RetryErrorKind,
-    attempt: u8,
-    max_attempts: u8,
-    cumulative_delay_ms: u64,
-    error: E,
-) -> RetryError<E> {
-    let retry_error = RetryError::new(kind, attempt, max_attempts, cumulative_delay_ms, error);
-    if let Some(callback) = on_failure {
-        callback(&retry_error);
-    }
-    retry_error
-}
-
 /// Reason why a retry operation failed.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum RetryErrorKind {
@@ -259,17 +243,7 @@ where
     F: FnMut() -> Result<T, E>,
 {
     fn retry<B: BackoffStrategy>(self, backoff: B) -> RetryBuilder<Self, B, T, E, fn(&E) -> bool> {
-        RetryBuilder {
-            operation: self,
-            backoff,
-            when: None,
-            delay_from: None,
-            notify: None,
-            on_success: None,
-            on_failure: None,
-            _phantom_t: core::marker::PhantomData,
-            _phantom_e: core::marker::PhantomData,
-        }
+        RetryBuilder::new(self, backoff)
     }
 }
 
@@ -429,6 +403,23 @@ pub struct RetryBuilder<F, B, T, E, W> {
     _phantom_e: core::marker::PhantomData<E>,
 }
 
+impl<F, B, T, E> DefaultRetryBuilder<F, B, T, E> {
+    /// A builder with no predicate, hint hook or callbacks.
+    const fn new(operation: F, backoff: B) -> Self {
+        Self {
+            operation,
+            backoff,
+            when: None,
+            delay_from: None,
+            notify: None,
+            on_success: None,
+            on_failure: None,
+            _phantom_t: core::marker::PhantomData,
+            _phantom_e: core::marker::PhantomData,
+        }
+    }
+}
+
 /// What the retry loop should do after one attempt.
 ///
 /// Produced by [`RetryBuilder::step`], which holds every retry decision —
@@ -581,6 +572,22 @@ where
         self
     }
 
+    /// Build the terminal [`RetryError`], firing `on_failure` if present.
+    fn fail(
+        &mut self,
+        kind: RetryErrorKind,
+        attempt: u8,
+        cumulative_delay_ms: u64,
+        error: E,
+    ) -> Step<T, E> {
+        let max_attempts = self.backoff.max_attempts();
+        let retry_error = RetryError::new(kind, attempt, max_attempts, cumulative_delay_ms, error);
+        if let Some(callback) = self.on_failure.as_mut() {
+            callback(&retry_error);
+        }
+        Step::Fail(retry_error)
+    }
+
     /// Decide what happens after one attempt, firing any callbacks it implies.
     ///
     /// This is the whole retry policy. A driver's only jobs are producing the
@@ -592,8 +599,6 @@ where
         cumulative_delay_ms: u64,
         rng: &mut R,
     ) -> Step<T, E> {
-        let max_attempts = self.backoff.max_attempts();
-
         let error = match result {
             Ok(value) => {
                 if let Some(ref mut callback) = self.on_success {
@@ -615,26 +620,22 @@ where
         if let Some(ref predicate) = self.when
             && !predicate(&error)
         {
-            return Step::Fail(finalize_failure(
-                self.on_failure.as_mut(),
+            return self.fail(
                 RetryErrorKind::PredicateRejected,
                 attempt,
-                max_attempts,
                 cumulative_delay_ms,
                 error,
-            ));
+            );
         }
 
         // Out of attempts? Exhaustion wins over any delay hint.
         if !self.backoff.should_retry(attempt) {
-            return Step::Fail(finalize_failure(
-                self.on_failure.as_mut(),
+            return self.fail(
                 RetryErrorKind::Exhausted,
                 attempt,
-                max_attempts,
                 cumulative_delay_ms,
                 error,
-            ));
+            );
         }
 
         let hint = self
@@ -646,14 +647,12 @@ where
             DelayHint::Backoff => {
                 // The strategy may still decline to produce a delay.
                 let Some(delay_ms) = self.backoff.delay(attempt, rng) else {
-                    return Step::Fail(finalize_failure(
-                        self.on_failure.as_mut(),
+                    return self.fail(
                         RetryErrorKind::Exhausted,
                         attempt,
-                        max_attempts,
                         cumulative_delay_ms,
                         error,
-                    ));
+                    );
                 };
                 delay_ms
             }
@@ -663,26 +662,22 @@ where
                     .max_delay_ms()
                     .is_some_and(|cap| delay_ms > cap)
                 {
-                    return Step::Fail(finalize_failure(
-                        self.on_failure.as_mut(),
+                    return self.fail(
                         RetryErrorKind::HintHalted,
                         attempt,
-                        max_attempts,
                         cumulative_delay_ms,
                         error,
-                    ));
+                    );
                 }
                 delay_ms
             }
             DelayHint::Halt => {
-                return Step::Fail(finalize_failure(
-                    self.on_failure.as_mut(),
+                return self.fail(
                     RetryErrorKind::HintHalted,
                     attempt,
-                    max_attempts,
                     cumulative_delay_ms,
                     error,
-                ));
+                );
             }
         };
 
@@ -869,17 +864,7 @@ where
         self,
         backoff: B,
     ) -> RetryBuilder<Self, B, T, E, fn(&E) -> bool> {
-        RetryBuilder {
-            operation: self,
-            backoff,
-            when: None,
-            delay_from: None,
-            notify: None,
-            on_success: None,
-            on_failure: None,
-            _phantom_t: core::marker::PhantomData,
-            _phantom_e: core::marker::PhantomData,
-        }
+        RetryBuilder::new(self, backoff)
     }
 }
 

data/ext/chrono_machines_native/core/src/streak.rs

@@ -0,0 +1,89 @@
+//! A failure streak and the hold-off it earns, for loops that never give up.
+
+use rand::Rng;
+
+use crate::BackoffStrategy;
+
+/// Failures past this count do not change the delay, so a strategy with
+/// `u8::MAX` attempts never reports itself exhausted.
+const UNBOUNDED: u8 = u8::MAX - 1;
+
+/// Consecutive failures of a repeating operation, and the delay a
+/// [`BackoffStrategy`] assigns before the next try.
+///
+/// [`RetryBuilder`](crate::RetryBuilder) runs one operation until it succeeds
+/// or its attempts run out. A poll loop, a supervised worker or a reconnect is
+/// the other shape: it runs for as long as the process does, holds off longer
+/// while cycles keep failing, and returns to its own cadence on the first
+/// success. This is that bookkeeping, with nothing attached: the caller owns
+/// the loop, the sleep and the stop signal.
+///
+/// ```
+/// use chrono_machines::rand::{SeedableRng, rngs::StdRng};
+/// use chrono_machines::{Backoff, ExponentialBackoff};
+///
+/// let mut rng = StdRng::seed_from_u64(7);
+/// let mut backoff = Backoff::new(
+///     ExponentialBackoff::new()
+///         .max_attempts(u8::MAX)
+///         .base_delay_ms(1_000)
+///         .max_delay_ms(30_000)
+///         .jitter_factor(0.0),
+/// );
+///
+/// assert_eq!(backoff.failed_with_rng(&mut rng), Some(1_000));
+/// assert_eq!(backoff.failed_with_rng(&mut rng), Some(2_000));
+/// backoff.succeeded();
+/// assert_eq!(backoff.failed_with_rng(&mut rng), Some(1_000));
+/// ```
+#[derive(Debug, Clone, Copy)]
+pub struct Backoff<B> {
+    strategy: B,
+    failures: u8,
+}
+
+impl<B: BackoffStrategy> Backoff<B> {
+    /// Track failures under `strategy`, starting from none.
+    #[must_use]
+    pub const fn new(strategy: B) -> Self {
+        Self {
+            strategy,
+            failures: 0,
+        }
+    }
+
+    /// Consecutive failures since the last success.
+    #[must_use]
+    pub const fn failures(&self) -> u8 {
+        self.failures
+    }
+
+    /// The strategy the delays come from.
+    #[must_use]
+    pub const fn strategy(&self) -> &B {
+        &self.strategy
+    }
+
+    /// A cycle completed: the streak ends and the next failure starts a new one.
+    pub const fn succeeded(&mut self) {
+        self.failures = 0;
+    }
+
+    /// A cycle failed: milliseconds to hold off before the next one, or `None`
+    /// once the strategy's attempts are spent. A strategy allowing `u8::MAX`
+    /// attempts is never spent.
+    pub fn failed_with_rng<R: Rng>(&mut self, rng: &mut R) -> Option<u64> {
+        self.failures = self.failures.saturating_add(1).min(UNBOUNDED);
+        self.strategy.delay(self.failures, rng)
+    }
+
+    /// [`failed_with_rng`](Self::failed_with_rng) with the standard RNG.
+    #[cfg(feature = "std")]
+    pub fn failed(&mut self) -> Option<u64> {
+        let mut rng: rand::rngs::StdRng = rand::make_rng();
+        self.failed_with_rng(&mut rng)
+    }
+}
+
+#[cfg(test)]
+mod tests;

data/lib/chrono_machines/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ChronoMachines
-  VERSION = '0.12.1'
+  VERSION = '0.12.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chrono_machines
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.12.3
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -75,6 +75,7 @@ files:
 - ext/chrono_machines_native/core/src/policy.rs
 - ext/chrono_machines_native/core/src/retry.rs
 - ext/chrono_machines_native/core/src/sleep.rs
+- ext/chrono_machines_native/core/src/streak.rs
 - ext/chrono_machines_native/core/src/test_support.rs
 - ext/chrono_machines_native/extconf.rb
 - ext/chrono_machines_native/ffi/Cargo.toml