chrono_machines 0.5.2 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a02c5bea1c05535fe666e96b6dc442318ccbb695145b3fffb3f7c259c9c1233b
-  data.tar.gz: 4a9ad6b5479cfdd7201fa6b52952f4f44743438a2daadd5d12a7e85d76bd3a28
+  metadata.gz: 8784b5114cde3b48cafa9ee9dff5fe69778795235610ecce63a44c73204c28f7
+  data.tar.gz: b87ddb52e946b220b0a2552647c85c928aa6b2a0e65e513005a40f1fbfd9e33a
 SHA512:
-  metadata.gz: b367f7d8a63032b1950e0a120485e87bac44f31d7b6a02caf747fb30135a6b6aad99e4ce04724b01eb74ae9fe5464958f8d015ab88e8d5ac8dece43576b3ebaf
-  data.tar.gz: 42c6b3908d329f78521d073883abb4aefa5dd0d1c53072773ab305daae4f179f9645e5c5eb931ba0c0efb75bb32446501547fd67d3f3baf2f32febe650ae1556
+  metadata.gz: 1c04099978047a09d84ad12e52ec228bf632063f228cc227ca993012044eec481956703bdac03e57a81995ebec87b46c515e3859d2095262c56d866be94b3b64
+  data.tar.gz: 387168ff2aa02a535b1c2e25ce9a2541afa535786b50e8cd28bce5cea56deee20a3fedd9255b74f886948f3b4d567fd1f39a13d0e5b7d13ecab8e67a8a49a7ae

data/CHANGELOG.md

@@ -1,5 +1,91 @@
 ## [Unreleased]
 
+## [0.9.1](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.9.0...chrono_machines/v0.9.1) (2026-10-05)
+
+
+### Bug Fixes
+
+* **build:** skip host compile when packaging a cross gem ([5d5b61d](https://github.com/seuros/chrono_machines/commit/5d5b61da68a0815ef3a30f6fb731af844cbd45ee))
+
+## [0.9.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.8.0...chrono_machines/v0.9.0) (2026-10-05)
+
+
+### Features
+
+* require Ruby 4.0, magnus 0.9, Ractor-safe native ext ([316d6f5](https://github.com/seuros/chrono_machines/commit/316d6f5e3de0f58e33d0a124eec4efafefb78cab))
+
+## [0.8.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.5.0...chrono_machines/v0.8.0) (2026-09-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21))
+
+### Features
+
+* **core:** delay_from - server-hinted retry delays (HTTP Retry-After)  ([#25](https://github.com/seuros/chrono_machines/issues/25)) ([2dcf987](https://github.com/seuros/chrono_machines/commit/2dcf9871939b70c053144e9fc296914a3b6105e5))
+* **core:** re-export rand so BackoffStrategy is implementable downstream ([dc1cf49](https://github.com/seuros/chrono_machines/commit/dc1cf494df0124032bec6aee6e4f6a33e43abbfb))
+* fix release ([ad40d8f](https://github.com/seuros/chrono_machines/commit/ad40d8f5b6629e49ba2d5f0cb7f213a1cc1e30c7))
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21)) ([766f207](https://github.com/seuros/chrono_machines/commit/766f20799bcc0c36f7ca6a904fadff227549fee7))
+
+
+### Bug Fixes
+
+* ignore native_speedup.rb in Zeitwerk loader ([#19](https://github.com/seuros/chrono_machines/issues/19)) ([491cc2d](https://github.com/seuros/chrono_machines/commit/491cc2d3f88786cf6d0c6af68dba7d2511fa3f36))
+* package workspace Cargo manifest so source builds work ([#17](https://github.com/seuros/chrono_machines/issues/17)) ([ac0ddad](https://github.com/seuros/chrono_machines/commit/ac0ddad15d26528771825240a05ed8c84fb61520))
+* trigger release ([02184d5](https://github.com/seuros/chrono_machines/commit/02184d51f6831f53ae6142ea5092710d456363d5))
+
+## [0.5.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.5.0...chrono_machines/v0.5.0) (2026-09-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21))
+
+### Features
+
+* **core:** delay_from - server-hinted retry delays (HTTP Retry-After)  ([#25](https://github.com/seuros/chrono_machines/issues/25)) ([2dcf987](https://github.com/seuros/chrono_machines/commit/2dcf9871939b70c053144e9fc296914a3b6105e5))
+* **core:** re-export rand so BackoffStrategy is implementable downstream ([dc1cf49](https://github.com/seuros/chrono_machines/commit/dc1cf494df0124032bec6aee6e4f6a33e43abbfb))
+* fix release ([ad40d8f](https://github.com/seuros/chrono_machines/commit/ad40d8f5b6629e49ba2d5f0cb7f213a1cc1e30c7))
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21)) ([766f207](https://github.com/seuros/chrono_machines/commit/766f20799bcc0c36f7ca6a904fadff227549fee7))
+
+
+### Bug Fixes
+
+* ignore native_speedup.rb in Zeitwerk loader ([#19](https://github.com/seuros/chrono_machines/issues/19)) ([491cc2d](https://github.com/seuros/chrono_machines/commit/491cc2d3f88786cf6d0c6af68dba7d2511fa3f36))
+* package workspace Cargo manifest so source builds work ([#17](https://github.com/seuros/chrono_machines/issues/17)) ([ac0ddad](https://github.com/seuros/chrono_machines/commit/ac0ddad15d26528771825240a05ed8c84fb61520))
+
+## [0.5.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.5.0...chrono_machines/v0.5.0) (2026-08-23)
+
+
+### ⚠ BREAKING CHANGES
+
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21))
+
+### Features
+
+* **core:** re-export rand so BackoffStrategy is implementable downstream ([dc1cf49](https://github.com/seuros/chrono_machines/commit/dc1cf494df0124032bec6aee6e4f6a33e43abbfb))
+* fix release ([ad40d8f](https://github.com/seuros/chrono_machines/commit/ad40d8f5b6629e49ba2d5f0cb7f213a1cc1e30c7))
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21)) ([766f207](https://github.com/seuros/chrono_machines/commit/766f20799bcc0c36f7ca6a904fadff227549fee7))
+
+
+### Bug Fixes
+
+* ignore native_speedup.rb in Zeitwerk loader ([#19](https://github.com/seuros/chrono_machines/issues/19)) ([491cc2d](https://github.com/seuros/chrono_machines/commit/491cc2d3f88786cf6d0c6af68dba7d2511fa3f36))
+* package workspace Cargo manifest so source builds work ([#17](https://github.com/seuros/chrono_machines/issues/17)) ([ac0ddad](https://github.com/seuros/chrono_machines/commit/ac0ddad15d26528771825240a05ed8c84fb61520))
+
+## [0.5.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.5.2...chrono_machines/v0.5.0) (2026-08-23)
+
+
+### ⚠ BREAKING CHANGES
+
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21))
+
+### Features
+
+* fix release ([ad40d8f](https://github.com/seuros/chrono_machines/commit/ad40d8f5b6629e49ba2d5f0cb7f213a1cc1e30c7))
+* **native:** add async retry driver ([#21](https://github.com/seuros/chrono_machines/issues/21)) ([766f207](https://github.com/seuros/chrono_machines/commit/766f20799bcc0c36f7ca6a904fadff227549fee7))
+
 ## [0.5.2](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.5.1...chrono_machines/v0.5.2) (2026-08-07)
 
 

data/Cargo.lock

@@ -17,17 +17,6 @@ version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
-[[package]]
-name = "async-trait"
-version = "0.1.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "bindgen"
 version = "0.72.1"
@@ -69,9 +58,9 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "chacha20"
-version = "0.10.0"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
+checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"
 dependencies = [
  "cfg-if",
  "cpufeatures",
@@ -80,16 +69,15 @@ dependencies = [
 
 [[package]]
 name = "chrono-machines"
-version = "0.3.2"
+version = "0.8.0"
 dependencies = [
- "async-trait",
  "rand",
  "tokio",
 ]
 
 [[package]]
 name = "chrono_machines_native"
-version = "0.2.3"
+version = "0.9.0"
 dependencies = [
  "chrono-machines",
  "magnus",
@@ -245,9 +233,9 @@ checksum = "953f07c43838f8e6f9758cab68bf5bed85465e7587ebe0b823f1bcd81978ad3a"
 
 [[package]]
 name = "magnus"
-version = "0.8.2"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b36a5b126bbe97eb0d02d07acfeb327036c6319fd816139a49824a83b7f9012"
+checksum = "b9068710e00d21be762edca59b9c4c8946dbdb29820d4f76ad559afea07982c9"
 dependencies = [
  "magnus-macros",
  "rb-sys",
@@ -257,9 +245,9 @@ dependencies = [
 
 [[package]]
 name = "magnus-macros"
-version = "0.8.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47607461fd8e1513cb4f2076c197d8092d921a1ea75bd08af97398f593751892"
+checksum = "9dafde2eeb66f090e0f326112323eb8324b12cb32b5d1210e541d3df6b0ce77e"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -330,9 +318,9 @@ checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
 [[package]]
 name = "rand"
-version = "0.10.1"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
+checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af"
 dependencies = [
  "chacha20",
  "getrandom",

data/README.md

@@ -195,6 +195,32 @@ ChronoMachines.retry(
 end
 ```
 
+### Server-Hinted Delays (`delay_from`)
+
+When the server tells you when to come back - HTTP 429 with `Retry-After` - guessing with exponential backoff is rude. `delay_from` lets the exception dictate the next delay:
+
+```ruby
+ChronoMachines.retry(
+  max_attempts: 5,
+  max_delay: 30,
+  retryable_exceptions: [MyClient::RateLimitError],
+  delay_from: ->(exception:, attempt:) {
+    exception.respond_to?(:retry_after) ? exception.retry_after : nil
+  }
+) do
+  call_rate_limited_api
+end
+```
+
+The hook's return value controls the retry:
+
+- `nil` - no hint; fall back to the policy's backoff strategy
+- `Numeric` - sleep exactly that many seconds (no jitter: the server picked the time, honor it)
+- a `Numeric` **beyond `max_delay`** - halt: the server asked for more patience than this policy allows, so the original exception propagates and the caller decides (background job, `Retry-After` response header, ...)
+- `:halt` or `false` - stop retrying immediately, propagate the original exception
+
+Anything else raises `ArgumentError` - a broken hook fails loudly instead of silently mangling your retry cadence.
+
 ## The Science of Temporal Jitter
 
 ChronoMachines implements **full jitter** exponential backoff:

data/ext/chrono_machines_native/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "chrono-machines"
-version = "0.4.0"
+version = "0.8.0"
 edition = "2024"
 authors = ["Abdelkader Boudih <terminale@gmail.com>"]
 license = "MIT"
@@ -9,6 +9,7 @@ repository = "https://github.com/seuros/chrono_machines"
 keywords = ["retry", "backoff", "exponential", "jitter", "resilience"]
 categories = ["no-std", "algorithms"]
 readme = "README.md"
+exclude = ["tests/", "src/**/tests.rs"]
 
 [lib]
 name = "chrono_machines"
@@ -18,11 +19,13 @@ crate-type = ["lib"]
 default = ["std"]
 std = ["alloc", "rand/std", "rand/thread_rng"]
 alloc = []
-async = ["std", "dep:async-trait"]
+# Async retry driver. Needs `alloc` for the builder's boxed callbacks, but not
+# `std`: the futures are native `async fn` in trait, so there is no runtime
+# dependency and nothing to box per sleep.
+async = ["alloc"]
 
 [dependencies]
 rand = { version = "0.10", default-features = false, features = ["std_rng"] }
-async-trait = { version = "0.1", optional = true }
 
 [dev-dependencies]
-tokio = { version = "1", features = ["rt", "macros", "time"] }
+tokio = { version = "1", features = ["rt", "rt-multi-thread", "macros", "time"] }

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

@@ -55,6 +55,39 @@ fn apply_jitter<R: Rng>(base: f64, jitter_factor: f64, rng: &mut R) -> u64 {
 }
 
 /// Trait for backoff strategies that calculate delays between retry attempts
+///
+/// The three strategies in this module cover the usual shapes. Implement it
+/// yourself when the delay depends on something they cannot see — a server's
+/// `Retry-After`, a token bucket, a circuit breaker's cool-down.
+///
+/// [`delay`](BackoffStrategy::delay) is generic over [`Rng`], so an
+/// implementation has to name that trait. Take it from
+/// [`chrono_machines::rand`](crate::rand) rather than adding your own `rand`
+/// dependency; a version skew between the two yields two distinct `Rng` traits
+/// and a mismatch error that points nowhere near the cause.
+///
+/// ```rust
+/// use chrono_machines::{rand::Rng, BackoffStrategy};
+///
+/// /// Retries as fast as the loop will go — for tests, where sleeping is waste.
+/// struct Immediate {
+///     max_attempts: u8,
+/// }
+///
+/// impl BackoffStrategy for Immediate {
+///     fn delay<R: Rng>(&self, attempt: u8, _rng: &mut R) -> Option<u64> {
+///         self.should_retry(attempt).then_some(0)
+///     }
+///
+///     fn should_retry(&self, attempt: u8) -> bool {
+///         attempt < self.max_attempts
+///     }
+///
+///     fn max_attempts(&self) -> u8 {
+///         self.max_attempts
+///     }
+/// }
+/// ```
 pub trait BackoffStrategy {
     /// Calculate the delay in milliseconds for the given attempt number
     ///
@@ -81,6 +114,14 @@ pub trait BackoffStrategy {
 
     /// Maximum number of retry attempts permitted by this strategy.
     fn max_attempts(&self) -> u8;
+
+    /// Maximum delay this strategy will ever produce, if it has a cap.
+    ///
+    /// A `delay_from` hint beyond this cap halts the retry. `None` (the
+    /// default) means uncapped: every hint is honoured.
+    fn max_delay_ms(&self) -> Option<u64> {
+        None
+    }
 }
 
 /// Exponential backoff strategy with configurable jitter
@@ -182,6 +223,10 @@ impl BackoffStrategy for ExponentialBackoff {
     fn max_attempts(&self) -> u8 {
         self.max_attempts
     }
+
+    fn max_delay_ms(&self) -> Option<u64> {
+        Some(self.max_delay_ms)
+    }
 }
 
 /// Constant backoff strategy with fixed delay
@@ -350,6 +395,10 @@ impl BackoffStrategy for FibonacciBackoff {
     fn max_attempts(&self) -> u8 {
         self.max_attempts
     }
+
+    fn max_delay_ms(&self) -> Option<u64> {
+        Some(self.max_delay_ms)
+    }
 }
 
 /// Backoff policy that can represent any supported strategy.
@@ -401,6 +450,14 @@ impl BackoffStrategy for BackoffPolicy {
             BackoffPolicy::Fibonacci(policy) => policy.max_attempts(),
         }
     }
+
+    fn max_delay_ms(&self) -> Option<u64> {
+        match self {
+            BackoffPolicy::Exponential(policy) => policy.max_delay_ms(),
+            BackoffPolicy::Constant(policy) => policy.max_delay_ms(),
+            BackoffPolicy::Fibonacci(policy) => policy.max_delay_ms(),
+        }
+    }
 }
 
 impl From<ExponentialBackoff> for BackoffPolicy {
@@ -422,95 +479,4 @@ impl From<FibonacciBackoff> for BackoffPolicy {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use rand::rngs::StdRng;
-    use rand::SeedableRng;
-
-    #[test]
-    fn test_exponential_backoff_builder() {
-        let backoff = ExponentialBackoff::new()
-            .base_delay_ms(200)
-            .multiplier(3.0)
-            .max_delay_ms(5000)
-            .max_attempts(5)
-            .jitter_factor(0.5);
-
-        assert_eq!(backoff.base_delay_ms, 200);
-        assert_eq!(backoff.multiplier, 3.0);
-        assert_eq!(backoff.max_delay_ms, 5000);
-        assert_eq!(backoff.max_attempts, 5);
-        assert_eq!(backoff.jitter_factor, 0.5);
-    }
-
-    #[test]
-    fn test_exponential_delays() {
-        let backoff = ExponentialBackoff::new()
-            .base_delay_ms(100)
-            .multiplier(2.0)
-            .jitter_factor(0.0); // No jitter for predictable testing
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        assert_eq!(backoff.delay(1, &mut rng), Some(100));
-        assert_eq!(backoff.delay(2, &mut rng), Some(200));
-        assert_eq!(backoff.delay(3, &mut rng), None); // Exceeds max_attempts (default 3)
-    }
-
-    #[test]
-    fn test_constant_backoff() {
-        let backoff = ConstantBackoff::new()
-            .delay_ms(500)
-            .max_attempts(4)
-            .jitter_factor(0.0);
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        assert_eq!(backoff.delay(1, &mut rng), Some(500));
-        assert_eq!(backoff.delay(2, &mut rng), Some(500));
-        assert_eq!(backoff.delay(3, &mut rng), Some(500));
-        assert_eq!(backoff.delay(4, &mut rng), None);
-    }
-
-    #[test]
-    fn test_fibonacci_sequence() {
-        assert_eq!(fibonacci(1), 1);
-        assert_eq!(fibonacci(2), 1);
-        assert_eq!(fibonacci(3), 2);
-        assert_eq!(fibonacci(4), 3);
-        assert_eq!(fibonacci(5), 5);
-        assert_eq!(fibonacci(6), 8);
-        assert_eq!(fibonacci(7), 13);
-    }
-
-    #[test]
-    fn test_fibonacci_backoff() {
-        let backoff = FibonacciBackoff::new()
-            .base_delay_ms(100)
-            .max_attempts(5)
-            .jitter_factor(0.0);
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        assert_eq!(backoff.delay(1, &mut rng), Some(100)); // 100 * 1
-        assert_eq!(backoff.delay(2, &mut rng), Some(100)); // 100 * 1
-        assert_eq!(backoff.delay(3, &mut rng), Some(200)); // 100 * 2
-        assert_eq!(backoff.delay(4, &mut rng), Some(300)); // 100 * 3
-        assert_eq!(backoff.delay(5, &mut rng), None); // Exceeds max_attempts
-    }
-
-    #[test]
-    fn test_jitter_application() {
-        let backoff = ConstantBackoff::new().delay_ms(1000).jitter_factor(1.0); // Full jitter
-
-        let mut rng = StdRng::seed_from_u64(42);
-        let delays: Vec<u64> = (1..10).filter_map(|i| backoff.delay(i, &mut rng)).collect();
-
-        // With full jitter, delays should vary
-        let all_different = delays.windows(2).any(|w| w[0] != w[1]);
-        assert!(all_different, "Full jitter should produce varying delays");
-
-        // All delays should be <= base delay
-        assert!(delays.iter().all(|&d| d <= 1000));
-    }
-}
+mod tests;

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

@@ -68,41 +68,4 @@ where
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::backoff::{BackoffPolicy, ExponentialBackoff};
-    use crate::policy::{clear_global_policies, register_global_policy};
-
-    #[test]
-    fn test_retry_with_policy_success() {
-        clear_global_policies();
-        register_global_policy(
-            "default",
-            BackoffPolicy::from(ExponentialBackoff::new().max_attempts(2)),
-        );
-
-        let mut attempts = 0;
-        let outcome = retry_with_policy("default", || {
-            attempts += 1;
-            if attempts == 1 {
-                Err::<_, &'static str>("fail")
-            } else {
-                Ok("ok")
-            }
-        })
-        .expect("dsl retry should succeed");
-
-        assert_eq!(attempts, 2);
-        assert_eq!(outcome.into_inner(), "ok");
-    }
-
-    #[test]
-    fn test_retry_with_policy_missing() {
-        clear_global_policies();
-        let result = retry_with_policy::<_, (), &str>("missing", || Ok(()));
-        match result {
-            Err(DslError::PolicyMissing(name)) => assert_eq!(name, "missing"),
-            _ => panic!("expected policy missing error"),
-        }
-    }
-}
+mod tests;