wreq 1.2.10 → 1.2.12

data/src/arch.rs

@@ -6,6 +6,49 @@
 //! do not leak into the rest of the binding.
 #![allow(unsafe_code)]
 
+use std::mem::ManuallyDrop;
+
+/// Native state that belongs to the process where the extension was loaded.
+///
+/// A forked child must not destroy inherited clients, channels, or response
+/// bodies because their synchronization state may belong to threads that no
+/// longer exist. The child intentionally leaks the value and lets the operating
+/// system reclaim it when the process exits.
+///
+/// This wrapper only controls destruction. Call [`crate::rt::ensure_current`]
+/// before using process-bound state stored inside it.
+#[derive(Clone)]
+pub(crate) struct ProcessLocal<T>(ManuallyDrop<T>);
+
+impl<T> ProcessLocal<T> {
+    /// Wrap native state created by the current process.
+    pub(crate) fn new(value: T) -> Self {
+        Self(ManuallyDrop::new(value))
+    }
+}
+
+impl<T> AsRef<T> for ProcessLocal<T> {
+    fn as_ref(&self) -> &T {
+        &self.0
+    }
+}
+
+impl<T> Drop for ProcessLocal<T> {
+    fn drop(&mut self) {
+        #[cfg(unix)]
+        if forked_process_ids().is_some() {
+            return;
+        }
+
+        // SAFETY: `new` initializes the value exactly once, `ManuallyDrop`
+        // prevents an automatic second drop, and this wrapper's `Drop`
+        // implementation runs at most once.
+        unsafe {
+            ManuallyDrop::drop(&mut self.0);
+        }
+    }
+}
+
 /// Whether the native client exposes TCP user-timeout configuration.
 pub(crate) const SUPPORTS_TCP_USER_TIMEOUT: bool = cfg!(any(
     target_os = "android",
@@ -27,6 +70,64 @@ pub(crate) const SUPPORTS_INTERFACE: bool = cfg!(any(
     target_os = "watchos",
 ));
 
+#[cfg(unix)]
+mod unix {
+    use std::{io, process, sync::OnceLock};
+
+    /// Process state captured when the extension initializes.
+    ///
+    /// The atfork guard uses a POSIX child handler to advance an atomic fork
+    /// generation without running Ruby code.
+    /// https://pubs.opengroup.org/onlinepubs/9799919799/functions/pthread_atfork.html
+    struct ForkGuard {
+        detector: forkguard::Guard,
+        owner_pid: u32,
+    }
+
+    impl ForkGuard {
+        /// Create a guard and register fork detection with the process.
+        fn new() -> io::Result<Self> {
+            forkguard::Guard::try_new()
+                .map(|detector| Self {
+                    detector,
+                    owner_pid: process::id(),
+                })
+                .map_err(|error| io::Error::from_raw_os_error(error.code().get()))
+        }
+
+        /// Return process IDs when this guard was inherited through a fork.
+        fn forked_process_ids(&self) -> Option<(u32, u32)> {
+            // Keep the stored generation unchanged so every runtime access in
+            // the child remains rejected. Cloning the detector copies one usize.
+            let mut detector = self.detector.clone();
+            detector
+                .detected_fork()
+                .then(|| (self.owner_pid, process::id()))
+        }
+    }
+
+    static FORK_GUARD: OnceLock<ForkGuard> = OnceLock::new();
+
+    /// Register process fork tracking before the extension exposes its API.
+    pub(crate) fn initialize_fork_tracking() -> io::Result<()> {
+        if FORK_GUARD.get().is_some() {
+            return Ok(());
+        }
+
+        let guard = ForkGuard::new()?;
+        let _ = FORK_GUARD.set(guard);
+        Ok(())
+    }
+
+    /// Return process IDs only when this process inherited the extension.
+    pub(crate) fn forked_process_ids() -> Option<(u32, u32)> {
+        FORK_GUARD.get().and_then(ForkGuard::forked_process_ids)
+    }
+}
+
+#[cfg(unix)]
+pub(crate) use unix::{forked_process_ids, initialize_fork_tracking};
+
 #[cfg(all(target_os = "windows", target_env = "gnu"))]
 mod windows_gnu {
     //! Windows GNU support.
@@ -53,3 +154,30 @@ mod windows_gnu {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::cell::Cell;
+
+    use super::ProcessLocal;
+
+    struct DropCounter<'a>(&'a Cell<usize>);
+
+    impl Drop for DropCounter<'_> {
+        fn drop(&mut self) {
+            self.0.set(self.0.get() + 1);
+        }
+    }
+
+    #[test]
+    fn process_local_drops_in_its_owner_process() {
+        let drops = Cell::new(0);
+
+        {
+            let value = ProcessLocal::new(DropCounter(&drops));
+            assert_eq!(value.as_ref().0.get(), 0);
+        }
+
+        assert_eq!(drops.get(), 1);
+    }
+}

data/src/client/body/stream.rs

@@ -13,6 +13,7 @@ use magnus::{Error, Integer, RString, Ruby, Value, scan_args::scan_args};
 use tokio::sync::{Mutex, Semaphore, mpsc};
 
 use crate::{
+    arch::ProcessLocal,
     error::{
         argument_error, body_sender_borrow_error, body_sender_borrow_mut_error,
         body_sender_send_error, closed_body_sender_error, memory_error, type_error, wreq_error,
@@ -33,7 +34,7 @@ pub struct BodyReceiver(Mutex<Pin<Box<dyn Stream<Item = wreq::Result<Bytes>> + S
 /// receiver. Ruby's GVL protects state access; no [`RefCell`] borrow is kept
 /// while request backpressure waits without the GVL.
 #[magnus::wrap(class = "Wreq::BodySender", free_immediately, size)]
-pub struct BodySender(RefCell<InnerBodySender>);
+pub struct BodySender(ProcessLocal<RefCell<InnerBodySender>>);
 
 /// Mutable ownership state for both halves of the body channel.
 struct InnerBodySender {
@@ -89,8 +90,10 @@ impl BodySender {
     /// # Errors
     ///
     /// Returns `TypeError` for a non-Integer capacity and `ArgumentError` for
-    /// an invalid range or argument count.
+    /// an invalid range or argument count. Returns `Wreq::ForkError` before
+    /// creating a channel in a child that inherited the extension.
     pub fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
+        rt::ensure_current(ruby)?;
         let capacity = parse_capacity(ruby, args)?;
 
         // Create the Tokio channel without allowing an unwind to cross the Ruby FFI boundary.
@@ -100,10 +103,12 @@ impl BodySender {
         let (tx, rx) =
             catch_unwind(|| mpsc::channel(capacity)).map_err(|_| invalid_capacity_error(ruby))?;
 
-        Ok(BodySender(RefCell::new(InnerBodySender {
-            tx: Some(tx),
-            rx: Some(rx),
-        })))
+        Ok(BodySender(ProcessLocal::new(RefCell::new(
+            InnerBodySender {
+                tx: Some(tx),
+                rx: Some(rx),
+            },
+        ))))
     }
 
     /// Push a binary chunk, waiting for capacity when the channel is full.
@@ -113,8 +118,11 @@ impl BodySender {
     /// # Errors
     ///
     /// Returns `IOError` after either channel side has closed. An interrupted
-    /// wait raises `Wreq::InterruptError`.
+    /// wait raises `Wreq::InterruptError`. Returns `Wreq::ForkError` before
+    /// reading an inherited channel.
     pub fn push(ruby: &Ruby, rb_self: &Self, data: RString) -> Result<(), Error> {
+        rt::ensure_current(ruby)?;
+
         // Clone during the shared borrow, then release it before waiting
         // for capacity. Request attachment needs a mutable borrow.
         let tx = match &rb_self.read_inner(ruby)?.tx {
@@ -131,8 +139,10 @@ impl BodySender {
     ///
     /// # Errors
     ///
-    /// Returns `Wreq::BodyError` if the internal state is already borrowed.
+    /// Returns `Wreq::ForkError` before reading an inherited channel, or
+    /// `Wreq::BodyError` if the internal state is already borrowed.
     pub fn close(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
+        rt::ensure_current(ruby)?;
         let mut inner = rb_self.write_inner(ruby)?;
         inner.tx.take();
         Ok(())
@@ -142,14 +152,17 @@ impl BodySender {
     ///
     /// # Errors
     ///
-    /// Returns `Wreq::BodyError` if the internal state is already borrowed.
+    /// Returns `Wreq::ForkError` before reading an inherited channel, or
+    /// `Wreq::BodyError` if the internal state is already borrowed.
     pub fn is_closed(ruby: &Ruby, rb_self: &Self) -> Result<bool, Error> {
+        rt::ensure_current(ruby)?;
         rb_self.read_inner(ruby).map(|r| r.is_closed())
     }
 
     /// Borrow the channel state without panicking on accidental re-entry.
     fn read_inner(&self, ruby: &Ruby) -> Result<Ref<'_, InnerBodySender>, Error> {
         self.0
+            .as_ref()
             .try_borrow()
             .map_err(|err| body_sender_borrow_error(ruby, err))
     }
@@ -157,6 +170,7 @@ impl BodySender {
     /// Mutably borrow the channel state without panicking on accidental re-entry.
     fn write_inner(&self, ruby: &Ruby) -> Result<RefMut<'_, InnerBodySender>, Error> {
         self.0
+            .as_ref()
             .try_borrow_mut()
             .map_err(|err| body_sender_borrow_mut_error(ruby, err))
     }
@@ -168,6 +182,7 @@ impl BodySender {
     /// Returns `Wreq::MemoryError` if the receiver was already consumed, or
     /// `Wreq::BodyError` if Ruby re-enters while the state is borrowed.
     pub(super) fn take_receiver(&self, ruby: &Ruby) -> Result<ReceiverStream<Bytes>, Error> {
+        rt::ensure_current(ruby)?;
         self.write_inner(ruby)?
             .rx
             .take()

data/src/client/resp.rs

@@ -9,6 +9,7 @@ use magnus::{Error, Module, RArray, RModule, Ruby, Value, scan_args::scan_args};
 use wreq::Uri;
 
 use crate::{
+    arch::ProcessLocal,
     client::body::{json::Json, stream::BodyReceiver},
     cookie::Cookie,
     error::{memory_error, no_block_given_error, wreq_error},
@@ -16,6 +17,7 @@ use crate::{
     header::Headers,
     http::{StatusCode, Version},
     rt,
+    tls::TlsInfo,
 };
 
 /// A response from a request.
@@ -28,8 +30,7 @@ pub struct Response {
     headers: HeaderMap,
     local_addr: Option<SocketAddr>,
     remote_addr: Option<SocketAddr>,
-    body: ArcSwapOption<Body>,
-    extensions: Extensions,
+    state: ProcessLocal<NativeResponseState>,
 }
 
 /// Represents the state of the HTTP response body.
@@ -40,6 +41,12 @@ enum Body {
     Reusable(Bytes),
 }
 
+/// Response state that may contain handles owned by the native runtime.
+struct NativeResponseState {
+    body: ArcSwapOption<Body>,
+    extensions: Extensions,
+}
+
 impl Response {
     /// Create a new [`Response`] instance.
     pub fn new(response: wreq::Response) -> Self {
@@ -55,26 +62,31 @@ impl Response {
             local_addr,
             remote_addr,
             content_length,
-            extensions: parts.extensions,
             version: Version::from_ffi(parts.version),
             status: StatusCode::from(parts.status),
             headers: parts.headers,
-            body: ArcSwapOption::from_pointee(Body::Streamable(body)),
+            state: ProcessLocal::new(NativeResponseState {
+                body: ArcSwapOption::from_pointee(Body::Streamable(body)),
+                extensions: parts.extensions,
+            }),
         }
     }
 
     /// Internal method to get the wreq::Response, optionally streaming the body.
     fn response(&self, ruby: &Ruby, stream: bool) -> Result<wreq::Response, Error> {
+        rt::ensure_current(ruby)?;
+        let state = self.state.as_ref();
+
         let build_response = |body: wreq::Body| -> wreq::Response {
             let mut response = HttpResponse::new(body);
             *response.version_mut() = self.version.into_ffi();
             *response.status_mut() = self.status.0;
             *response.headers_mut() = self.headers.clone();
-            *response.extensions_mut() = self.extensions.clone();
+            *response.extensions_mut() = state.extensions.clone();
             wreq::Response::from(response)
         };
 
-        if let Some(arc) = self.body.swap(None) {
+        if let Some(arc) = state.body.swap(None) {
             match Arc::try_unwrap(arc) {
                 Ok(Body::Streamable(body)) => {
                     return if stream {
@@ -86,14 +98,16 @@ impl Response {
                             wreq_error,
                         )?;
 
-                        self.body
+                        state
+                            .body
                             .store(Some(Arc::new(Body::Reusable(bytes.clone()))));
 
                         Ok(build_response(wreq::Body::from(bytes)))
                     };
                 }
                 Ok(Body::Reusable(bytes)) => {
-                    self.body
+                    state
+                        .body
                         .store(Some(Arc::new(Body::Reusable(bytes.clone()))));
 
                     if !stream {
@@ -167,6 +181,16 @@ impl Response {
         self.remote_addr.map(|addr| addr.to_string())
     }
 
+    /// Return peer certificate data retained for this response.
+    fn tls_info(&self) -> Option<TlsInfo> {
+        self.state
+            .as_ref()
+            .extensions
+            .get::<wreq::tls::TlsInfo>()
+            .cloned()
+            .map(TlsInfo)
+    }
+
     /// Get the response body as bytes.
     pub fn bytes(ruby: &Ruby, rb_self: &Self) -> Result<Bytes, Error> {
         let response = rb_self.response(ruby, false)?;
@@ -175,6 +199,7 @@ impl Response {
 
     ///  Get the full response text given a specific encoding.
     pub fn text(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<String, Error> {
+        rt::ensure_current(ruby)?;
         let args = scan_args::<(), (Option<String>,), (), (), (), ()>(args)?;
         let response = rb_self.response(ruby, false)?;
         match args.optional.0 {
@@ -194,6 +219,8 @@ impl Response {
 
     /// Yield response body chunks to the given Ruby block.
     pub fn chunks(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
+        rt::ensure_current(ruby)?;
+
         if !ruby.block_given() {
             return Err(no_block_given_error(ruby));
         }
@@ -211,16 +238,15 @@ impl Response {
     }
 
     /// Close the response body, dropping any resources.
-    #[inline]
-    pub fn close(&self) {
-        gvl::nogvl(|| self.body.swap(None));
-    }
-}
-
-impl Drop for Response {
-    fn drop(&mut self) {
-        // Ensure body is dropped in GVL
-        self.body.swap(None);
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` before touching a body inherited from the
+    /// parent process.
+    pub fn close(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
+        rt::ensure_current(ruby)?;
+        gvl::nogvl(|| rb_self.state.as_ref().body.swap(None));
+        Ok(())
     }
 }
 
@@ -243,5 +269,6 @@ pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
     response.define_method("json", magnus::method!(Response::json, 0))?;
     response.define_method("chunks", magnus::method!(Response::chunks, 0))?;
     response.define_method("close", magnus::method!(Response::close, 0))?;
+    response.define_method("tls_info", magnus::method!(Response::tls_info, 0))?;
     Ok(())
 }

data/src/client.rs

@@ -11,7 +11,7 @@ use magnus::{Module, Object, RModule, Ruby, TryConvert, Value, function, method,
 use wreq::Proxy;
 
 use crate::{
-    arch::{SUPPORTS_INTERFACE, SUPPORTS_TCP_USER_TIMEOUT},
+    arch::{ProcessLocal, SUPPORTS_INTERFACE, SUPPORTS_TCP_USER_TIMEOUT},
     client::{req::execute_request, resp::Response},
     cookie::Jar,
     emulate::Emulation,
@@ -21,6 +21,7 @@ use crate::{
     header::{Headers, OrigHeaders, UserAgent},
     http::Method,
     options::{NativeOption, Options},
+    rt,
 };
 
 /// A builder for `Client`.
@@ -94,6 +95,8 @@ struct Builder {
     // ========= TLS options =========
     /// Whether to verify TLS certificates.
     verify: Option<bool>,
+    /// Whether to retain peer certificate data on responses.
+    tls_info: Option<bool>,
 
     // ========= Network options =========
     /// Whether to disable the proxy for the client.
@@ -120,7 +123,7 @@ struct Builder {
 
 #[derive(Clone)]
 #[magnus::wrap(class = "Wreq::Client", free_immediately, size)]
-pub struct Client(wreq::Client);
+pub struct Client(ProcessLocal<wreq::Client>);
 
 // ===== impl Builder =====
 
@@ -193,11 +196,15 @@ impl Client {
     /// native fallible client builder. Extra positional arguments return
     /// `ArgumentError`.
     pub fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, magnus::Error> {
+        rt::ensure_current(ruby)?;
+
         Options::from_args(ruby, args, "client")?
             .map(Builder::from_options)
             .transpose()
             .map(Option::unwrap_or_default)
             .and_then(|params| Self::build(ruby, params))
+            .map(ProcessLocal::new)
+            .map(Self)
     }
 
     /// Build the default client through the same fallible path as `new`.
@@ -206,7 +213,7 @@ impl Client {
     ///
     /// Returns `Wreq::BuilderError`, `Wreq::TlsError`, or another mapped native
     /// initialization error without unwinding through Ruby.
-    pub(crate) fn default_client(ruby: &Ruby) -> Result<Self, magnus::Error> {
+    pub(crate) fn default_client(ruby: &Ruby) -> Result<wreq::Client, magnus::Error> {
         Self::build(ruby, Builder::default())
     }
 
@@ -214,8 +221,12 @@ impl Client {
     ///
     /// # Errors
     ///
-    /// Maps native build failures only after the GVL has been reacquired.
-    fn build(ruby: &Ruby, mut params: Builder) -> Result<Self, magnus::Error> {
+    /// Returns `Wreq::ForkError` before touching native client state when the
+    /// extension was inherited from a parent process. Maps native build
+    /// failures only after the GVL has been reacquired.
+    fn build(ruby: &Ruby, mut params: Builder) -> Result<wreq::Client, magnus::Error> {
+        rt::ensure_current(ruby)?;
+
         let result = gvl::nogvl(|| {
             let mut builder = wreq::Client::builder();
 
@@ -349,6 +360,7 @@ impl Client {
 
             // TLS options.
             apply_option!(set_if_some, builder, params.verify, tls_cert_verification);
+            apply_option!(set_if_some, builder, params.tls_info, tls_info);
 
             // Network options.
             apply_option!(set_if_some, builder, params.proxy, proxy);
@@ -374,12 +386,17 @@ impl Client {
             apply_option!(set_if_some, builder, params.deflate, deflate);
             apply_option!(set_if_some, builder, params.zstd, zstd);
 
-            builder.build().map(Client)
+            builder.build()
         });
 
         // Ruby exceptions must be created after the GVL has been reacquired.
         result.map_err(|err| wreq_error(ruby, err))
     }
+
+    /// Clone the native client handle for a request future.
+    fn native_client(&self) -> wreq::Client {
+        self.0.as_ref().clone()
+    }
 }
 
 impl Client {
@@ -391,9 +408,9 @@ impl Client {
         ruby: &Ruby,
         args: &[Value],
     ) -> Result<Response, magnus::Error> {
-        let ((method, url), request) = extract_request!(args, (Obj<Method>, String));
+        let ((method, url), request) = extract_request!(ruby, args, (Obj<Method>, String));
         let client = Self::default_client(ruby)?;
-        execute_request(ruby, client.0, *method, url, request)
+        execute_request(ruby, client, *method, url, request)
     }
 
     /// Send a request with `method` through a newly built default client.
@@ -405,72 +422,72 @@ impl Client {
         method: Method,
         args: &[Value],
     ) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
+        let ((url,), request) = extract_request!(ruby, args, (String,));
         let client = Self::default_client(ruby)?;
-        execute_request(ruby, client.0, method, url, request)
+        execute_request(ruby, client, method, url, request)
     }
 
     /// Send a HTTP request.
     #[inline]
     pub fn request(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((method, url), request) = extract_request!(args, (Obj<Method>, String));
-        execute_request(ruby, rb_self.0.clone(), *method, url, request)
+        let ((method, url), request) = extract_request!(ruby, args, (Obj<Method>, String));
+        execute_request(ruby, rb_self.native_client(), *method, url, request)
     }
 
     /// Send a GET request.
     #[inline]
     pub fn get(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
-        execute_request(ruby, rb_self.0.clone(), Method::GET, url, request)
+        let ((url,), request) = extract_request!(ruby, args, (String,));
+        execute_request(ruby, rb_self.native_client(), Method::GET, url, request)
     }
 
     /// Send a POST request.
     #[inline]
     pub fn post(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
-        execute_request(ruby, rb_self.0.clone(), Method::POST, url, request)
+        let ((url,), request) = extract_request!(ruby, args, (String,));
+        execute_request(ruby, rb_self.native_client(), Method::POST, url, request)
     }
 
     /// Send a PUT request.
     #[inline]
     pub fn put(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
-        execute_request(ruby, rb_self.0.clone(), Method::PUT, url, request)
+        let ((url,), request) = extract_request!(ruby, args, (String,));
+        execute_request(ruby, rb_self.native_client(), Method::PUT, url, request)
     }
 
     /// Send a DELETE request.
     #[inline]
     pub fn delete(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
-        execute_request(ruby, rb_self.0.clone(), Method::DELETE, url, request)
+        let ((url,), request) = extract_request!(ruby, args, (String,));
+        execute_request(ruby, rb_self.native_client(), Method::DELETE, url, request)
     }
 
     /// Send a HEAD request.
     #[inline]
     pub fn head(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
-        execute_request(ruby, rb_self.0.clone(), Method::HEAD, url, request)
+        let ((url,), request) = extract_request!(ruby, args, (String,));
+        execute_request(ruby, rb_self.native_client(), Method::HEAD, url, request)
     }
 
     /// Send an OPTIONS request.
     #[inline]
     pub fn options(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
-        execute_request(ruby, rb_self.0.clone(), Method::OPTIONS, url, request)
+        let ((url,), request) = extract_request!(ruby, args, (String,));
+        execute_request(ruby, rb_self.native_client(), Method::OPTIONS, url, request)
     }
 
     /// Send a TRACE request.
     #[inline]
     pub fn trace(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
-        execute_request(ruby, rb_self.0.clone(), Method::TRACE, url, request)
+        let ((url,), request) = extract_request!(ruby, args, (String,));
+        execute_request(ruby, rb_self.native_client(), Method::TRACE, url, request)
     }
 
     /// Send a PATCH request.
     #[inline]
     pub fn patch(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
-        let ((url,), request) = extract_request!(args, (String,));
-        execute_request(ruby, rb_self.0.clone(), Method::PATCH, url, request)
+        let ((url,), request) = extract_request!(ruby, args, (String,));
+        execute_request(ruby, rb_self.native_client(), Method::PATCH, url, request)
     }
 }
 

data/src/error.rs

@@ -56,6 +56,7 @@ macro_rules! map_wreq_error {
 
 // System-level and runtime errors
 define_exception!(MEMORY, "MemoryError", exception_runtime_error);
+define_exception!(FORK_ERROR, "ForkError", exception_runtime_error);
 
 // Network connection errors
 define_exception!(CONNECTION_ERROR, "ConnectionError", exception_runtime_error);
@@ -98,6 +99,26 @@ pub fn interrupt_error(ruby: &Ruby) -> MagnusError {
     MagnusError::new(ruby.get_inner(&INTERRUPT_ERROR), "request interrupted")
 }
 
+/// Build `Wreq::ForkError` without touching inherited native state.
+#[cfg(unix)]
+pub fn fork_error(ruby: &Ruby, owner_pid: u32, current_pid: u32) -> MagnusError {
+    MagnusError::new(
+        ruby.get_inner(&FORK_ERROR),
+        format!(
+            "wreq-ruby was loaded in process {owner_pid} and cannot be used after fork in process {current_pid}"
+        ),
+    )
+}
+
+/// Map a failed process-fork handler registration to `Wreq::ForkError`.
+#[cfg(unix)]
+pub fn fork_handler_error(ruby: &Ruby, err: &std::io::Error) -> MagnusError {
+    MagnusError::new(
+        ruby.get_inner(&FORK_ERROR),
+        format!("failed to initialize process fork tracking: {err}"),
+    )
+}
+
 /// Map a Tokio runtime initialization failure to `Wreq::BuilderError`.
 pub fn runtime_initialization_error(ruby: &Ruby, err: &std::io::Error) -> MagnusError {
     MagnusError::new(
@@ -239,6 +260,13 @@ pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), MagnusError> {
         "MemoryError",
         exception_runtime_error
     );
+    initialize_exception!(
+        ruby,
+        gem_module,
+        FORK_ERROR,
+        "ForkError",
+        exception_runtime_error
+    );
     initialize_exception!(
         ruby,
         gem_module,