wreq-rb 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd3f8d369b26129c00889f9e357c368ad8db091e5feabb5273d5b92cb4e92c56
-  data.tar.gz: 84e3bdf4fedc4340b8d88495acbb2a8b1020bb77837d15b4bdec6070d3d3bc72
+  metadata.gz: ce3d1d61f00a9a6585dcf3dedf9c32efe8bb25d99ab3ce332deee5de6c84ee4f
+  data.tar.gz: 97e22c094b0d0f28db1c0e65f94eb82eeca2f55bb1a96fa8e7f706d17a008df3
 SHA512:
-  metadata.gz: 7f7e75b4ec8e64998c979157d640529244a0e102a4ebdfb67d3c6a3a2543b468e6688b05bce68f7ad2480f12cdfadcc727b5a041e3bd40f429149e63294fa397
-  data.tar.gz: ddf1859a8f3cab61028fd74416e4f5c4633ffab12f9c9dda9e8828eaf9ac4c605c8da2547d10b8256fbbbb6ee3d30c40a1d2affd145eb17e478bbecd76c03c27
+  metadata.gz: 7ce21633e4394d4f4d6a3a71ad38708d98e9809f3d0910bf5e0f947adb2bdabbb59481bcd5a4c9096114fc74ffa035c2519e4460733a61c9a810220be3c6b7a3
+  data.tar.gz: 643d9f5411aaa343c165665a9a1de939102d2abe7396b5c07ff16e18456a0c5fce885ffe0118c57491ce850227117a5d5248ebda5d083c0b5c903020b0458978

data/Cargo.lock

@@ -4211,7 +4211,7 @@ dependencies = [
 
 [[package]]
 name = "wreq_rb"
-version = "0.6.1"
+version = "0.6.2"
 dependencies = [
  "bytes",
  "http",

data/ext/wreq_rb/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wreq_rb"
-version = "0.6.1"
+version = "0.6.2"
 edition = "2021"
 publish = false
 
@@ -31,6 +31,9 @@ serde_json = "1.0"
 bytes = "1"
 http = "1"
 
+[dev-dependencies]
+magnus = { version = "0.8", features = ["embed"] }
+
 [target.'cfg(target_os = "linux")'.dependencies]
 wreq = { path = "../../vendor/wreq", version = "=0.16.1", features = [
   "prefix-symbols",

data/ext/wreq_rb/src/client.rs

@@ -47,7 +47,7 @@ fn runtime() -> &'static Runtime {
 /// # Safety
 /// The closure must NOT access any Ruby objects or call any Ruby C API.
 /// Extract all data from Ruby before calling this, convert results after.
-unsafe fn without_gvl<F, R>(f: F) -> R
+unsafe fn without_gvl<F, R>(f: F) -> Result<R, magnus::Error>
 where
     F: FnOnce(CancellationToken) -> R,
 {
@@ -89,19 +89,22 @@ where
     let data_ptr = &mut data as *mut CallData<F, R> as *mut c_void;
 
     unsafe {
-        rb_sys::rb_thread_call_without_gvl(
-            Some(call::<F, R>),
-            data_ptr,
-            Some(ubf::<F, R>),
-            data_ptr,
-        );
+        magnus::rb_sys::protect(|| {
+            rb_sys::rb_thread_call_without_gvl(
+                Some(call::<F, R>),
+                data_ptr,
+                Some(ubf::<F, R>),
+                data_ptr,
+            );
+            0
+        })?;
     }
 
     if let Some(payload) = data.panic_payload {
         panic::resume_unwind(payload);
     }
 
-    data.result.unwrap()
+    Ok(data.result.unwrap())
 }
 
 /// Collected response data as pure Rust types (no Ruby objects).
@@ -288,12 +291,13 @@ impl Client {
                 builder = builder.default_headers(hmap);
             }
 
-            if let Some(t) = hash_get_float(&opts, "timeout")? {
-                builder = builder.timeout(Duration::from_secs_f64(t));
+            let timeout = hash_get_float(&opts, "timeout")?;
+            if let Some(timeout) = timeout {
+                builder = builder.timeout(Duration::from_secs_f64(timeout));
             }
 
-            if let Some(t) = hash_get_float(&opts, "connect_timeout")? {
-                builder = builder.connect_timeout(Duration::from_secs_f64(t));
+            if let Some(connect_timeout) = hash_get_float(&opts, "connect_timeout")?.or(timeout) {
+                builder = builder.connect_timeout(Duration::from_secs_f64(connect_timeout));
             }
 
             if let Some(t) = hash_get_float(&opts, "read_timeout")? {
@@ -489,7 +493,7 @@ impl Client {
                     }
                 })
             })
-        };
+        }?;
 
         let data = match outcome {
             RequestOutcome::Ok(d) => d,
@@ -545,7 +549,7 @@ impl Client {
                     }
                 })
             })
-        };
+        }?;
 
         let items = match outcome {
             BatchOutcome::Done(items) => items,
@@ -877,3 +881,89 @@ pub fn init(_ruby: &magnus::Ruby, module: &magnus::RModule) -> Result<(), magnus
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+
+    static READY: AtomicBool = AtomicBool::new(false);
+    static LIVE: AtomicUsize = AtomicUsize::new(0);
+
+    struct DropProbe;
+
+    impl DropProbe {
+        fn new() -> Self {
+            LIVE.fetch_add(1, Ordering::SeqCst);
+            Self
+        }
+    }
+
+    impl Drop for DropProbe {
+        fn drop(&mut self) {
+            LIVE.fetch_sub(1, Ordering::SeqCst);
+        }
+    }
+
+    fn probe_ready() -> bool {
+        READY.load(Ordering::SeqCst)
+    }
+
+    fn drop_probe() -> Result<(), magnus::Error> {
+        let _caller_resource = DropProbe::new();
+        let result = unsafe {
+            without_gvl(|token| {
+                let _callback_resource = DropProbe::new();
+                READY.store(true, Ordering::SeqCst);
+                runtime().block_on(token.cancelled());
+                DropProbe::new()
+            })
+        }?;
+        drop(result);
+        Ok(())
+    }
+
+    #[test]
+    fn ruby_interrupts_drop_native_resources() {
+        let ruby = unsafe { magnus::embed::init() };
+        let result = unsafe { without_gvl(|_| DropProbe::new()) }.unwrap();
+        assert_eq!(LIVE.load(Ordering::SeqCst), 1);
+        drop(result);
+        assert_eq!(LIVE.load(Ordering::SeqCst), 0);
+
+        let panicked = panic::catch_unwind(|| unsafe {
+            without_gvl::<_, ()>(|_| {
+                let _resource = DropProbe::new();
+                panic!("probe panic");
+            })
+        });
+        assert!(panicked.is_err());
+        assert_eq!(LIVE.load(Ordering::SeqCst), 0);
+
+        ruby.define_global_function("wreq_drop_probe", function!(drop_probe, 0));
+        ruby.define_global_function("wreq_probe_ready", function!(probe_ready, 0));
+
+        for (interrupt, expected) in [
+            ("worker.kill", None),
+            ("worker.raise(RuntimeError, 'stop request')", Some("stop request")),
+        ] {
+            READY.store(false, Ordering::SeqCst);
+            let result: Option<String> = ruby.eval(&format!(
+                "worker = Thread.new do
+                   begin
+                     wreq_drop_probe
+                     'returned normally'
+                   rescue RuntimeError => error
+                     error.message
+                   end
+                 end
+                 Thread.pass until wreq_probe_ready
+                 {interrupt}
+                 worker.value"
+            )).unwrap();
+
+            assert_eq!(result.as_deref(), expected);
+            assert_eq!(LIVE.load(Ordering::SeqCst), 0, "resources leaked after {interrupt}");
+        }
+    }
+}

data/ext/wreq_rb/src/response.rs

@@ -5,7 +5,8 @@ use magnus::{
 use crate::error::generic_error;
 
 /// Wraps a wreq::Response in a Ruby-accessible type.
-#[magnus::wrap(class = "Wreq::Response", free_immediately)]
+#[derive(magnus::TypedData)]
+#[magnus(class = "Wreq::Response", free_immediately, size)]
 pub struct Response {
     status: u16,
     headers: Vec<(String, String)>,
@@ -26,7 +27,7 @@ impl Response {
         content_length: Option<u64>,
         transfer_size: Option<u64>,
     ) -> Self {
-        Self {
+        let response = Self {
             status,
             headers,
             body,
@@ -34,7 +35,18 @@ impl Response {
             version,
             content_length,
             transfer_size,
-        }
+        };
+        unsafe { Ruby::get_unchecked() }
+            .gc_adjust_memory_usage(response.heap_size() as isize);
+        response
+    }
+
+    fn heap_size(&self) -> usize {
+        self.body.capacity()
+            + self.url.capacity()
+            + self.version.capacity()
+            + self.headers.capacity() * std::mem::size_of::<(String, String)>()
+            + self.headers.iter().map(|(name, value)| name.capacity() + value.capacity()).sum::<usize>()
     }
 
     fn status(&self) -> u16 {
@@ -119,6 +131,19 @@ impl Response {
     }
 }
 
+impl magnus::DataTypeFunctions for Response {
+    fn size(&self) -> usize {
+        std::mem::size_of::<Self>() + self.heap_size()
+    }
+}
+
+impl Drop for Response {
+    fn drop(&mut self) {
+        unsafe { Ruby::get_unchecked() }
+            .gc_adjust_memory_usage(-(self.heap_size() as isize));
+    }
+}
+
 pub fn init(ruby: &magnus::Ruby, module: &magnus::RModule) -> Result<(), magnus::Error> {
     let class = module.define_class("Response", ruby.class_object())?;
     class.define_method("status", method!(Response::status, 0))?;

data/lib/wreq-rb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wreq
-  VERSION = "0.6.1"
+  VERSION = "0.6.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wreq-rb
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Yicheng Zhou
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-28 00:00:00.000000000 Z
+date: 2026-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys