breaker_machines 0.9.2 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d890ea2732633801242760b868020a4ad4d517693a71a91767b27ce8cfde282
-  data.tar.gz: bb5a5b86d182b90cabdf0871d81f2b82ef58218e77613dc5f505067b6a39a63c
+  metadata.gz: cf8ad6f74f26b0e16224162a56d939fe9d74dff96b7d027310df893a4e8a7597
+  data.tar.gz: 36980ead62ae1571972b02f5d32daed76a040c5db26c2199d472482d2b82f553
 SHA512:
-  metadata.gz: b84c67c557a067f768e9b16e73a0e5e9186e909d211632151b79a17558ac56c78d92a67fc9e86b90ef6fb6382eb2f00ab57dc984a7ff64d4e89291341155dbb5
-  data.tar.gz: a1e3853602dab814c12e3581939ba95060e0ded7b023c906833530418a3b5071e3af29083303be06e1f98cf4e96028b4e1a1a9657910e18a0e69543940e2b1c8
+  metadata.gz: e719c01623af883b96dba7041b713e281ea9cc0212574eb0f924cac49e91a136112116ee0fd6930839c123b7822808617381c1b9b4fc7e1b012b6c88dd01bafd
+  data.tar.gz: 07eee7d0b5bbe8ba00abbfac9ce9849bf205b695ba4602c9a98bab477cb56ae9b558b9f1ba168d87cce35ff74d43a6931bfb7eba457ab00c998831fbb7a5376b

data/ext/breaker_machines_native/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "breaker-machines"
-version = "0.6.0"
+version = "0.7.1"
 edition = "2024"
 authors = ["Abdelkader Boudih <terminale@gmail.com>"]
 license = "MIT"

data/ext/breaker_machines_native/core/src/callbacks.rs

@@ -1,5 +1,6 @@
 //! Callback system for circuit breaker state transitions
 
+use std::panic::{AssertUnwindSafe, catch_unwind};
 use std::sync::Arc;
 
 /// Type alias for circuit breaker callback functions
@@ -22,21 +23,30 @@ impl Callbacks {
         }
     }
 
+    /// Trigger the on_open callback safely, catching any panics to prevent
+    /// unwinding across FFI boundaries.
     pub fn trigger_open(&self, circuit: &str) {
         if let Some(ref callback) = self.on_open {
-            callback(circuit);
+            let cb = AssertUnwindSafe(callback);
+            let _ = catch_unwind(|| cb(circuit));
         }
     }
 
+    /// Trigger the on_close callback safely, catching any panics to prevent
+    /// unwinding across FFI boundaries.
     pub fn trigger_close(&self, circuit: &str) {
         if let Some(ref callback) = self.on_close {
-            callback(circuit);
+            let cb = AssertUnwindSafe(callback);
+            let _ = catch_unwind(|| cb(circuit));
         }
     }
 
+    /// Trigger the on_half_open callback safely, catching any panics to prevent
+    /// unwinding across FFI boundaries.
     pub fn trigger_half_open(&self, circuit: &str) {
         if let Some(ref callback) = self.on_half_open {
-            callback(circuit);
+            let cb = AssertUnwindSafe(callback);
+            let _ = catch_unwind(|| cb(circuit));
         }
     }
 }
@@ -56,3 +66,82 @@ impl std::fmt::Debug for Callbacks {
             .finish()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicBool, Ordering};
+
+    #[test]
+    fn test_callback_panic_safety() {
+        // Callbacks that panic should not crash the program
+        let callbacks = Callbacks {
+            on_open: Some(Arc::new(|_| panic!("intentional panic in on_open"))),
+            on_close: Some(Arc::new(|_| panic!("intentional panic in on_close"))),
+            on_half_open: Some(Arc::new(|_| panic!("intentional panic in on_half_open"))),
+        };
+
+        // These should not panic - the panics are caught internally
+        callbacks.trigger_open("test");
+        callbacks.trigger_close("test");
+        callbacks.trigger_half_open("test");
+    }
+
+    #[test]
+    fn test_callback_executes_successfully() {
+        let open_called = Arc::new(AtomicBool::new(false));
+        let close_called = Arc::new(AtomicBool::new(false));
+        let half_open_called = Arc::new(AtomicBool::new(false));
+
+        let open_clone = open_called.clone();
+        let close_clone = close_called.clone();
+        let half_open_clone = half_open_called.clone();
+
+        let callbacks = Callbacks {
+            on_open: Some(Arc::new(move |_| {
+                open_clone.store(true, Ordering::SeqCst);
+            })),
+            on_close: Some(Arc::new(move |_| {
+                close_clone.store(true, Ordering::SeqCst);
+            })),
+            on_half_open: Some(Arc::new(move |_| {
+                half_open_clone.store(true, Ordering::SeqCst);
+            })),
+        };
+
+        callbacks.trigger_open("test");
+        callbacks.trigger_close("test");
+        callbacks.trigger_half_open("test");
+
+        assert!(
+            open_called.load(Ordering::SeqCst),
+            "on_open should be called"
+        );
+        assert!(
+            close_called.load(Ordering::SeqCst),
+            "on_close should be called"
+        );
+        assert!(
+            half_open_called.load(Ordering::SeqCst),
+            "on_half_open should be called"
+        );
+    }
+
+    #[test]
+    fn test_callback_receives_circuit_name() {
+        let received_name = Arc::new(std::sync::Mutex::new(String::new()));
+        let name_clone = received_name.clone();
+
+        let callbacks = Callbacks {
+            on_open: Some(Arc::new(move |name| {
+                *name_clone.lock().unwrap() = name.to_string();
+            })),
+            on_close: None,
+            on_half_open: None,
+        };
+
+        callbacks.trigger_open("my_circuit");
+
+        assert_eq!(*received_name.lock().unwrap(), "my_circuit");
+    }
+}

data/ext/breaker_machines_native/core/src/circuit.rs

@@ -482,11 +482,12 @@ impl CircuitBreaker {
                     // Try to trip the circuit
                     let result = self.machine.handle(CircuitEvent::Trip);
                     if result.is_ok() {
-                        // Transition succeeded - update opened_at timestamp
-                        if let Some(data) = self.machine.open_data_mut() {
-                            data.opened_at = self.context.storage.monotonic_time();
+                        self.mark_open();
+                    } else if self.machine.current_state() == "HalfOpen" {
+                        // Failure did not reopen the circuit; reset consecutive successes
+                        if let Some(data) = self.machine.half_open_data_mut() {
+                            data.consecutive_successes = 0;
                         }
-                        self.callbacks.trigger_open(&self.context.name);
                     }
                 }
 
@@ -495,6 +496,39 @@ impl CircuitBreaker {
         }
     }
 
+    /// Record a successful operation and drive HalfOpen -> Closed transitions
+    pub fn record_success_and_maybe_close(&mut self, duration: f64) {
+        self.context
+            .storage
+            .record_success(&self.context.name, duration);
+
+        if self.machine.current_state() == "HalfOpen" {
+            if let Some(data) = self.machine.half_open_data_mut() {
+                data.consecutive_successes += 1;
+            }
+
+            if self.machine.handle(CircuitEvent::Close).is_ok() {
+                self.callbacks.trigger_close(&self.context.name);
+            }
+        }
+    }
+
+    /// Record a failed operation and attempt to trip the circuit
+    pub fn record_failure_and_maybe_trip(&mut self, duration: f64) {
+        self.context
+            .storage
+            .record_failure(&self.context.name, duration);
+
+        let result = self.machine.handle(CircuitEvent::Trip);
+        if result.is_ok() {
+            self.mark_open();
+        } else if self.machine.current_state() == "HalfOpen"
+            && let Some(data) = self.machine.half_open_data_mut()
+        {
+            data.consecutive_successes = 0;
+        }
+    }
+
     /// Record a successful operation (for manual tracking)
     pub fn record_success(&self, duration: f64) {
         self.context
@@ -512,7 +546,12 @@ impl CircuitBreaker {
     /// Check failure threshold and attempt to trip the circuit
     /// This should be called after record_failure() when not using call()
     pub fn check_and_trip(&mut self) -> bool {
-        self.machine.handle(CircuitEvent::Trip).is_ok()
+        if self.machine.handle(CircuitEvent::Trip).is_ok() {
+            self.mark_open();
+            true
+        } else {
+            false
+        }
     }
 
     /// Check if circuit is open
@@ -536,6 +575,14 @@ impl CircuitBreaker {
         // Recreate machine in Closed state
         self.machine = DynamicCircuit::new(self.context.clone());
     }
+
+    /// Apply Open-state bookkeeping (timestamp + callback)
+    fn mark_open(&mut self) {
+        if let Some(data) = self.machine.open_data_mut() {
+            data.opened_at = self.context.storage.monotonic_time();
+        }
+        self.callbacks.trigger_open(&self.context.name);
+    }
 }
 
 #[cfg(test)]
@@ -1153,4 +1200,237 @@ mod tests {
         let result = circuit.call(|| Ok::<_, String>("should fail"));
         assert!(matches!(result, Err(CircuitError::Open { .. })));
     }
+
+    #[test]
+    fn test_check_and_trip_sets_opened_at_and_callback() {
+        use std::sync::atomic::{AtomicBool, Ordering};
+
+        let opened = Arc::new(AtomicBool::new(false));
+        let opened_clone = opened.clone();
+
+        let mut circuit = CircuitBreaker::builder("test")
+            .failure_threshold(1)
+            .on_open(move |_name| {
+                opened_clone.store(true, Ordering::SeqCst);
+            })
+            .build();
+
+        circuit.record_failure(0.1);
+        let tripped = circuit.check_and_trip();
+
+        assert!(tripped, "Trip should succeed");
+        assert!(circuit.is_open(), "Circuit should be open after trip");
+
+        let opened_at = circuit
+            .machine
+            .open_data()
+            .expect("Open data should be present")
+            .opened_at;
+
+        assert!(opened_at > 0.0, "opened_at should be set");
+        assert!(
+            opened.load(Ordering::SeqCst),
+            "on_open callback should fire"
+        );
+    }
+
+    #[test]
+    fn test_half_open_failure_resets_consecutive_successes() {
+        let mut circuit = CircuitBreaker::builder("test")
+            .failure_threshold(2)
+            .half_open_timeout_secs(0.001)
+            .success_threshold(2)
+            .build();
+
+        // Open the circuit
+        let _ = circuit.call(|| Err::<(), _>("error 1"));
+        let _ = circuit.call(|| Err::<(), _>("error 2"));
+        assert!(circuit.is_open());
+
+        // Move to HalfOpen
+        if let Some(data) = circuit.machine.open_data_mut() {
+            data.opened_at = circuit.context.storage.monotonic_time();
+        }
+        std::thread::sleep(std::time::Duration::from_millis(2));
+        circuit
+            .machine
+            .handle(CircuitEvent::AttemptReset)
+            .expect("Should transition to HalfOpen");
+        assert_eq!(circuit.machine.current_state(), "HalfOpen");
+
+        // Clear counts to simulate expired failure window
+        circuit.context.storage.clear("test");
+
+        // First success increments consecutive count
+        let _ = circuit.call(|| Ok::<_, String>("ok"));
+        assert_eq!(
+            circuit
+                .machine
+                .half_open_data()
+                .expect("HalfOpen data")
+                .consecutive_successes,
+            1
+        );
+
+        // Failure below threshold should not reopen circuit but should reset counter
+        let _ = circuit.call(|| Err::<(), _>("fail"));
+        assert_eq!(circuit.machine.current_state(), "HalfOpen");
+        assert_eq!(
+            circuit
+                .machine
+                .half_open_data()
+                .expect("HalfOpen data")
+                .consecutive_successes,
+            0
+        );
+
+        // Next success starts count from 1 again
+        let _ = circuit.call(|| Ok::<_, String>("ok2"));
+        assert_eq!(
+            circuit
+                .machine
+                .half_open_data()
+                .expect("HalfOpen data")
+                .consecutive_successes,
+            1
+        );
+    }
+
+    #[test]
+    fn test_jitter_distribution_within_bounds() {
+        // Test that jitter produces values within expected bounds
+        // With 25% jitter on 1000ms base, expect 750-1000ms range
+        let storage = Arc::new(crate::MemoryStorage::new());
+        let base_timeout = 1.0; // 1 second
+        let jitter_factor = 0.25;
+
+        let config = Config {
+            failure_threshold: Some(1),
+            half_open_timeout_secs: base_timeout,
+            jitter_factor,
+            ..Default::default()
+        };
+
+        let ctx = CircuitContext {
+            failure_classifier: None,
+            bulkhead: None,
+            name: "jitter_test".to_string(),
+            config,
+            storage: storage.clone(),
+        };
+
+        // Run 50 iterations and collect timeout values
+        let mut min_seen = f64::MAX;
+        let mut max_seen = f64::MIN;
+
+        for _ in 0..50 {
+            storage.record_failure("jitter_test", 0.1);
+            let mut circuit = DynamicCircuit::new(ctx.clone());
+            circuit.handle(CircuitEvent::Trip).expect("Should open");
+
+            if let Some(data) = circuit.open_data_mut() {
+                data.opened_at = storage.monotonic_time();
+            }
+
+            // Calculate what the jittered timeout would be
+            let policy = chrono_machines::Policy {
+                max_attempts: 1,
+                base_delay_ms: (base_timeout * 1000.0) as u64,
+                multiplier: 1.0,
+                max_delay_ms: (base_timeout * 1000.0) as u64,
+            };
+            let timeout_ms = policy.calculate_delay(1, jitter_factor);
+            let timeout_secs = (timeout_ms as f64) / 1000.0;
+
+            min_seen = min_seen.min(timeout_secs);
+            max_seen = max_seen.max(timeout_secs);
+
+            storage.clear("jitter_test");
+        }
+
+        // With 25% jitter, minimum should be ~0.75s (75% of base)
+        // Maximum should be ~1.0s (100% of base)
+        let min_expected = base_timeout * (1.0 - jitter_factor);
+        let max_expected = base_timeout;
+
+        assert!(
+            min_seen >= min_expected - 0.01,
+            "Minimum jittered timeout {} should be >= {}",
+            min_seen,
+            min_expected
+        );
+        assert!(
+            max_seen <= max_expected + 0.01,
+            "Maximum jittered timeout {} should be <= {}",
+            max_seen,
+            max_expected
+        );
+    }
+
+    #[test]
+    fn test_jitter_produces_variance() {
+        // Test that jitter actually produces different values (not all same)
+        let storage = Arc::new(crate::MemoryStorage::new());
+
+        let config = Config {
+            failure_threshold: Some(1),
+            half_open_timeout_secs: 1.0,
+            jitter_factor: 0.5, // 50% jitter for more variance
+            ..Default::default()
+        };
+
+        let ctx = CircuitContext {
+            failure_classifier: None,
+            bulkhead: None,
+            name: "jitter_variance".to_string(),
+            config,
+            storage: storage.clone(),
+        };
+
+        let mut values = std::collections::HashSet::new();
+
+        for _ in 0..20 {
+            let policy = chrono_machines::Policy {
+                max_attempts: 1,
+                base_delay_ms: 1000,
+                multiplier: 1.0,
+                max_delay_ms: 1000,
+            };
+            let timeout_ms = policy.calculate_delay(1, 0.5);
+            values.insert(timeout_ms);
+        }
+
+        // With 50% jitter over 20 iterations, we should see at least 2 different values
+        // (statistically, seeing all same values is extremely unlikely)
+        assert!(
+            values.len() >= 2,
+            "Jitter should produce variance, got {} unique values",
+            values.len()
+        );
+    }
+
+    #[test]
+    fn test_zero_jitter_produces_constant_timeout() {
+        // Test that 0% jitter always produces the same timeout
+        let policy = chrono_machines::Policy {
+            max_attempts: 1,
+            base_delay_ms: 1000,
+            multiplier: 1.0,
+            max_delay_ms: 1000,
+        };
+
+        let mut values = std::collections::HashSet::new();
+
+        for _ in 0..10 {
+            let timeout_ms = policy.calculate_delay(1, 0.0);
+            values.insert(timeout_ms);
+        }
+
+        assert_eq!(
+            values.len(),
+            1,
+            "Zero jitter should produce constant timeout"
+        );
+        assert!(values.contains(&1000), "Timeout should be exactly 1000ms");
+    }
 }

data/ext/breaker_machines_native/ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "breaker_machines_native"
-version = "0.5.1"
+version = "0.5.3"
 edition = "2024"
 authors = ["Abdelkader Boudih <terminale@gmail.com>"]
 license = "MIT"
@@ -10,7 +10,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 breaker-machines = { workspace = true }
-magnus = { version = "0.7", features = ["embed"] }
+magnus = { version = "0.8.2", features = ["embed"] }
 
 [build-dependencies]
 rb-sys = "0.9"

data/ext/breaker_machines_native/ffi/src/lib.rs

@@ -54,27 +54,23 @@ impl RubyStorage {
     }
 
     /// Get event log for a circuit (returns array of hashes)
-    fn event_log(&self, circuit_name: String, limit: usize) -> RArray {
-        let events = self.inner.event_log(&circuit_name, limit);
-        let array = RArray::new();
+    fn event_log(ruby: &Ruby, storage: &RubyStorage, circuit_name: String, limit: usize) -> RArray {
+        let events = storage.inner.event_log(&circuit_name, limit);
+        let array = ruby.ary_new();
 
         for event in events {
-            // Create a Ruby hash for each event
-            let hash = RHash::new();
-
-            // Set event type
+            let hash = ruby.hash_new();
             let type_sym = match event.kind {
                 EventKind::Success => "success",
                 EventKind::Failure => "failure",
             };
 
-            let _ = hash.aset(magnus::Symbol::new("type"), type_sym);
-            let _ = hash.aset(magnus::Symbol::new("timestamp"), event.timestamp);
+            let _ = hash.aset(ruby.to_symbol("type"), type_sym);
+            let _ = hash.aset(ruby.to_symbol("timestamp"), event.timestamp);
             let _ = hash.aset(
-                magnus::Symbol::new("duration_ms"),
+                ruby.to_symbol("duration_ms"),
                 (event.duration * 1000.0).round(),
             );
-
             let _ = array.push(hash);
         }
 
@@ -97,41 +93,41 @@ impl RubyCircuit {
     ///   - failure_window_secs: Time window for counting failures (default: 60.0)
     ///   - half_open_timeout_secs: Timeout before attempting reset (default: 30.0)
     ///   - success_threshold: Successes needed to close from half-open (default: 2)
-    fn new(name: String, config_hash: RHash) -> Result<Self, Error> {
+    fn new(ruby: &Ruby, name: String, config_hash: RHash) -> Result<Self, Error> {
         use magnus::TryConvert;
 
         // Extract config values with proper type conversion
         let failure_threshold: usize = config_hash
-            .get(magnus::Symbol::new("failure_threshold"))
+            .get(ruby.to_symbol("failure_threshold"))
             .and_then(|v| usize::try_convert(v).ok())
             .unwrap_or(5);
 
         let failure_window_secs: f64 = config_hash
-            .get(magnus::Symbol::new("failure_window_secs"))
+            .get(ruby.to_symbol("failure_window_secs"))
             .and_then(|v| f64::try_convert(v).ok())
             .unwrap_or(60.0);
 
         let half_open_timeout_secs: f64 = config_hash
-            .get(magnus::Symbol::new("half_open_timeout_secs"))
+            .get(ruby.to_symbol("half_open_timeout_secs"))
             .and_then(|v| f64::try_convert(v).ok())
             .unwrap_or(30.0);
 
         let success_threshold: usize = config_hash
-            .get(magnus::Symbol::new("success_threshold"))
+            .get(ruby.to_symbol("success_threshold"))
             .and_then(|v| usize::try_convert(v).ok())
             .unwrap_or(2);
 
         let jitter_factor: f64 = config_hash
-            .get(magnus::Symbol::new("jitter_factor"))
+            .get(ruby.to_symbol("jitter_factor"))
             .and_then(|v| f64::try_convert(v).ok())
             .unwrap_or(0.0);
 
         let failure_rate_threshold: Option<f64> = config_hash
-            .get(magnus::Symbol::new("failure_rate_threshold"))
+            .get(ruby.to_symbol("failure_rate_threshold"))
             .and_then(|v| f64::try_convert(v).ok());
 
         let minimum_calls: usize = config_hash
-            .get(magnus::Symbol::new("minimum_calls"))
+            .get(ruby.to_symbol("minimum_calls"))
             .and_then(|v| usize::try_convert(v).ok())
             .unwrap_or(20);
 
@@ -152,14 +148,16 @@ impl RubyCircuit {
 
     /// Record a successful operation
     fn record_success(&self, duration: f64) {
-        self.inner.borrow().record_success(duration);
+        self.inner
+            .borrow_mut()
+            .record_success_and_maybe_close(duration);
     }
 
     /// Record a failed operation and attempt to trip the circuit
     fn record_failure(&self, duration: f64) {
-        let mut circuit = self.inner.borrow_mut();
-        circuit.record_failure(duration);
-        circuit.check_and_trip();
+        self.inner
+            .borrow_mut()
+            .record_failure_and_maybe_trip(duration);
     }
 
     /// Check if circuit is open

data/lib/breaker_machines/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BreakerMachines
-  VERSION = '0.9.2'
+  VERSION = '0.10.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: breaker_machines
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.1
 platform: ruby
 authors:
 - Abdelkader Boudih