wreq 1.2.12 → 1.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfff227b1aca526697d055128ca828a911403c337796d840e45667554ece669a
-  data.tar.gz: ce36c588548df0a31e769fa54b226561d2e5b84cf0dd681c0102575503803e86
+  metadata.gz: 45253084ba060aa37efcdd71fdea4302d55a8ca658b9945385dd632a241452f9
+  data.tar.gz: 817dd6fd547b6f1f5dcf074f707487cf1efb6b7f42324c24a27a8afa444f2868
 SHA512:
-  metadata.gz: 77c99a185649091bc2c537efbdf4490404ef113c250a733ab47c3f49ac574659b455e78a3a77efe2f95ca9739b88b0f8ed6452b51d8583b01de7aaf4d88a1d0c
-  data.tar.gz: df326eb44d85324d981fb9a624f52a87d30871836f093dbde2ecd9c8b7b9b76cb786e8f2c2cd15aed1d2237fe8b9fc33a34803bf74972fb15a1bb9e8296071e5
+  metadata.gz: 1af6ea1ce815b1b64ff19ea238831b57176df435b2d307f3050a4b33b977370b56891d1c56c334a173fc5e11e694527fe30a7ebb418720033ccffd484dc5381c
+  data.tar.gz: 88a15b449a5e6fbeb62a57d73fa28d8734d5453c0a5ecfca0d295f2b33f4d23481ad34bdae0acf8d78d622c24a98f5ed2f43c35fb0d24d1d2752aaa88467d0f5

data/Cargo.lock

@@ -1489,7 +1489,7 @@ dependencies = [
 
 [[package]]
 name = "wreq-ruby"
-version = "1.2.12"
+version = "1.2.13"
 dependencies = [
  "arc-swap",
  "bytes",

data/Cargo.toml

@@ -5,7 +5,7 @@ authors = ["SearchApi <support@searchapi.io>"]
 homepage = "https://github.com/SearchApi/wreq-ruby"
 repository = "https://github.com/SearchApi/wreq-ruby"
 edition = "2024"
-version = "1.2.12"
+version = "1.2.13"
 rust-version = "1.95"
 
 [lib]

data/docs/fork-safety.md

@@ -1,34 +1,51 @@
 # Fork safety
 
-## Why inherited clients are rejected
-
-wreq-ruby uses a process-wide Tokio runtime and connection pool. `fork` copies
-the parent's memory, but only the thread that called `fork` continues in the
-child. Tokio's worker threads are gone, and its inherited tasks, locks, and
-connections are not safe to reuse.
-
-If the parent has already loaded wreq-ruby, native HTTP operations in the child
-raise `Wreq::ForkError`. This applies to new and existing clients, module
-request methods, streaming request bodies, and response methods backed by native
-state. Retrying the operation in the same child raises the same error. Read-only
-response metadata such as status, headers, and captured TLS information remains
-available.
-
-The parent can continue using its clients. When inherited Ruby objects are
-collected in the child, their native runtime state is left for the operating
-system to reclaim when the process exits.
-
-## HTTP work in forked children is unsupported
-
-A process created with `fork` must not start or continue HTTP work through
-wreq-ruby, even when it first loads the extension after the fork. If the parent
-loaded wreq-ruby, native HTTP operations in the child raise `Wreq::ForkError`.
-
-When the extension was not present in the parent, no wreq-ruby state or fork
-marker reaches the child. The extension cannot reliably distinguish that child
-from a newly started process, so this unsupported path cannot guarantee a Ruby
-error and may fail inside platform libraries.
-
-Prefork servers should use an `exec`- or spawn-based worker model when workers
-need wreq-ruby. Requiring the extension again does not reset inherited runtime
-state, and there is no `after_fork!` hook.
+## Prefork checklist
+
+- `require "wreq"` may run in the parent before workers fork.
+- Create each `Wreq::Client`, `Wreq::Jar`, and `Wreq::BodySender` in the worker
+  that will use it.
+- Keep each `Wreq::Response` in the process that received it.
+- Do not start requests or push streaming body data in the parent before workers
+  fork.
+- If the parent must use wreq-ruby first, start workers with `spawn` or `exec`
+  instead of `fork`.
+
+wreq-ruby checks process ownership whenever it exposes guarded native state. It
+does not copy, reset, or rebuild inherited objects.
+
+## Loading before fork
+
+wreq-ruby creates its process-wide Tokio runtime on the first operation that
+needs it. Requiring the gem does not initialize the runtime, so a prefork server
+may load wreq-ruby during boot. Each worker can then create its own runtime on
+its first request without an `after_fork!` hook.
+
+Create clients and other native-backed objects inside the worker. Each client,
+response, body sender, and cookie jar belongs to the process that created it.
+Using an inherited object raises `Wreq::ForkError`, even when the parent never
+started the runtime. wreq-ruby does not rebuild these objects.
+
+## Forking after runtime initialization
+
+Once the parent starts an HTTP operation or otherwise uses the Tokio runtime, a
+forked child must not reuse it. Tokio's worker threads do not survive `fork`, and
+the inherited connection pool may refer to those missing threads.
+
+Operations that need the inherited runtime raise `Wreq::ForkError`. This
+includes requests through new or existing clients, module request methods, and
+streaming request writes. Constructing a new client, body sender, or cookie jar
+does not use the runtime, but runtime-backed operations remain unavailable in
+that child. Retrying them raises the same error.
+
+An inherited `Wreq::Response` cannot be used at all. This includes status,
+headers, socket addresses, TLS information, and body methods. Values copied out
+before the fork, such as a `Wreq::StatusCode` or `Wreq::TlsInfo`, are separate
+objects and do not retain access to the response.
+
+The parent remains usable. Native objects collected in the child do not destroy
+state owned by the parent process.
+
+Use a spawn- or exec-based worker when the parent must perform HTTP work before
+workers start. Requiring the extension again cannot replace an inherited
+runtime.

data/docs/interrupt-handling.md

@@ -84,9 +84,10 @@ to the Ruby-owned thread with the GVL may [`src/rt.rs`](../src/rt.rs) map a
 wreq-owned cancellation to the `Wreq::InterruptError` defined in
 [`src/error.rs`](../src/error.rs).
 
-Keep this conversion centralized in `rt::try_block_on`. Request, response, and
-body operations may call `try_block_on`, but they must not construct their own
-Ruby cancellation exception.
+Keep cancellation conversion centralized in `rt::block_on`. Request, response,
+and body operations may call `block_on`, but they must not construct their own
+Ruby cancellation exception. `block_on` returns a future's native error
+unchanged so the caller can convert it after the GVL has been reacquired.
 
 These forms are forbidden for wreq-owned cancellation:
 

data/lib/wreq.rb

@@ -19,6 +19,33 @@ require_relative "wreq_ruby/error"
 require_relative "wreq_ruby/cookie"
 
 unless defined?(Wreq)
+  # An HTTP client backed by a lazily initialized, process-wide Tokio runtime.
+  #
+  # Loading wreq-ruby before `fork` is supported. The parent must not send a
+  # request or perform another operation that starts the runtime before workers
+  # are forked. Create clients and begin HTTP work inside each worker so it gets
+  # its own runtime and connection pool. Clients, responses, body senders, and
+  # cookie jars belong to the process that created them and must be recreated
+  # in the worker. wreq-ruby does not rebuild inherited objects.
+  #
+  # Accessing an inherited native-backed object raises Wreq::ForkError even if
+  # the parent did not start the runtime. If the parent did start it, the child
+  # also cannot perform new runtime-backed operations. Retrying does not replace
+  # either kind of inherited state. Use `spawn` or `exec`, or move the parent's
+  # HTTP work until after the workers have been forked.
+  #
+  # @example Preload the extension, then start HTTP work in the worker
+  #   require "wreq"
+  #
+  #   Process.fork do
+  #     client = Wreq::Client.new
+  #     response = client.get("https://example.com")
+  #     puts response.status
+  #   end
+  #
+  # @note Fork safety Create clients, cookie jars, and body senders inside the
+  #   worker that uses them. Do not carry responses across `fork`.
+  # @see https://github.com/SearchApi/wreq-ruby/blob/main/docs/fork-safety.md
   module Wreq
     # Current wreq gem version.
     # @return [String]
@@ -29,9 +56,6 @@ unless defined?(Wreq)
     # raise ArgumentError. Known values retain the error class from their Ruby
     # or native conversion, such as TypeError or Wreq::BuilderError. Validation
     # finishes before network I/O.
-    #
-    # If a child process inherits wreq-ruby from its parent, requests raise
-    # Wreq::ForkError. Require wreq after the worker has been forked.
 
     # Send an HTTP request.
     #
@@ -64,7 +88,7 @@ unless defined?(Wreq)
     # @return [Wreq::Response] HTTP response
     # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
     #   value cannot be converted, validated, or built
-    # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+    # @raise [Wreq::ForkError] if the child inherited an initialized wreq-ruby runtime
     def self.request(method, url, **options)
     end
 
@@ -98,7 +122,7 @@ unless defined?(Wreq)
     # @return [Wreq::Response] HTTP response
     # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
     #   value cannot be converted, validated, or built
-    # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+    # @raise [Wreq::ForkError] if the child inherited an initialized wreq-ruby runtime
     def self.get(url, **options)
     end
 
@@ -132,7 +156,7 @@ unless defined?(Wreq)
     # @return [Wreq::Response] HTTP response
     # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
     #   value cannot be converted, validated, or built
-    # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+    # @raise [Wreq::ForkError] if the child inherited an initialized wreq-ruby runtime
     def self.head(url, **options)
     end
 
@@ -166,7 +190,7 @@ unless defined?(Wreq)
     # @return [Wreq::Response] HTTP response
     # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
     #   value cannot be converted, validated, or built
-    # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+    # @raise [Wreq::ForkError] if the child inherited an initialized wreq-ruby runtime
     def self.post(url, **options)
     end
 
@@ -200,7 +224,7 @@ unless defined?(Wreq)
     # @return [Wreq::Response] HTTP response
     # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
     #   value cannot be converted, validated, or built
-    # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+    # @raise [Wreq::ForkError] if the child inherited an initialized wreq-ruby runtime
     def self.put(url, **options)
     end
 
@@ -234,7 +258,7 @@ unless defined?(Wreq)
     # @return [Wreq::Response] HTTP response
     # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
     #   value cannot be converted, validated, or built
-    # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+    # @raise [Wreq::ForkError] if the child inherited an initialized wreq-ruby runtime
     def self.delete(url, **options)
     end
 
@@ -268,7 +292,7 @@ unless defined?(Wreq)
     # @return [Wreq::Response] HTTP response
     # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
     #   value cannot be converted, validated, or built
-    # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+    # @raise [Wreq::ForkError] if the child inherited an initialized wreq-ruby runtime
     def self.options(url, **options)
     end
 
@@ -302,7 +326,7 @@ unless defined?(Wreq)
     # @return [Wreq::Response] HTTP response
     # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
     #   value cannot be converted, validated, or built
-    # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+    # @raise [Wreq::ForkError] if the child inherited an initialized wreq-ruby runtime
     def self.trace(url, **options)
     end
 
@@ -336,7 +360,7 @@ unless defined?(Wreq)
     # @return [Wreq::Response] HTTP response
     # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
     #   value cannot be converted, validated, or built
-    # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+    # @raise [Wreq::ForkError] if the child inherited an initialized wreq-ruby runtime
     def self.patch(url, **options)
     end
   end

data/lib/wreq_ruby/body.rb

@@ -17,8 +17,12 @@ unless defined?(Wreq)
     #
     # A sender can be attached to one request. Closing it prevents further writes but
     # retains queued chunks so a request attached afterward can still drain them.
-    # Creating or using a sender raises Wreq::ForkError if the child inherited
-    # wreq-ruby from its parent.
+    # Creating a sender does not initialize Tokio. An inherited sender raises
+    # Wreq::ForkError before its channel is accessed. A new sender can be
+    # created in a child, but pushing data also requires a usable runtime.
+    #
+    # @note Fork safety Create each sender in the worker that writes to it.
+    #   Do not pass a sender through `fork`.
     class BodySender
       # Create a bounded request-body sender.
       #
@@ -27,7 +31,6 @@ unless defined?(Wreq)
       # @return [Wreq::BodySender] A streaming request body sender
       # @raise [ArgumentError] if capacity is zero, negative, or too large
       # @raise [TypeError] if capacity is not an Integer
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
       def self.new(capacity = 8)
       end
 
@@ -36,7 +39,7 @@ unless defined?(Wreq)
       # @param data [String] binary chunk
       # @return [nil]
       # @raise [IOError] if the sender or receiving side is closed
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the sender or runtime belongs to the parent process
       def push(data)
       end
 
@@ -45,7 +48,7 @@ unless defined?(Wreq)
       # This operation is idempotent.
       #
       # @return [nil]
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the sender belongs to the parent process
       def close
       end
 
@@ -55,7 +58,7 @@ unless defined?(Wreq)
       # the receiving side.
       #
       # @return [Boolean]
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the sender belongs to the parent process
       def closed?
       end
     end

data/lib/wreq_ruby/client.rb

@@ -17,9 +17,14 @@ unless defined?(Wreq)
     # native conversion, such as TypeError or Wreq::BuilderError. Request
     # validation finishes before network I/O.
     #
-    # A child process cannot create or use a client if it inherited wreq-ruby
-    # from its parent. These calls raise Wreq::ForkError before accessing the
-    # native runtime. Require wreq after the worker has been forked.
+    # A client belongs to the process that created it. An inherited client
+    # raises Wreq::ForkError before its connection pool is accessed. Loading
+    # the gem before fork is supported, but clients must be created inside the
+    # worker. If the parent already started the runtime, new clients can be
+    # constructed in the child but cannot send requests.
+    #
+    # @note Fork safety Create each client in the worker that uses it. An
+    #   inherited client is never rebuilt automatically.
     #
     # @example Basic usage
     #   client = Wreq::Client.new
@@ -174,8 +179,7 @@ unless defined?(Wreq)
       #   value cannot be converted or validated.
       # @raise [Wreq::BuilderError, Wreq::TlsError] if the native client cannot
       #   be initialized.
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
-      #
+      # @raise [Wreq::ForkError] if :cookie_provider belongs to a parent process.
       # @example Minimal client
       #   client = Wreq::Client.new
       #
@@ -290,7 +294,7 @@ unless defined?(Wreq)
       #   or unavailable on the current platform
       # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
       #   value cannot be converted, validated, or built
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the client or runtime belongs to the parent process
       def request(method, url, **options)
       end
 
@@ -324,7 +328,7 @@ unless defined?(Wreq)
       # @return [Wreq::Response] HTTP response
       # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
       #   value cannot be converted, validated, or built
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the client or runtime belongs to the parent process
       def get(url, **options)
       end
 
@@ -358,7 +362,7 @@ unless defined?(Wreq)
       # @return [Wreq::Response] HTTP response
       # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
       #   value cannot be converted, validated, or built
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the client or runtime belongs to the parent process
       def head(url, **options)
       end
 
@@ -392,7 +396,7 @@ unless defined?(Wreq)
       # @return [Wreq::Response] HTTP response
       # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
       #   value cannot be converted, validated, or built
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the client or runtime belongs to the parent process
       def post(url, **options)
       end
 
@@ -426,7 +430,7 @@ unless defined?(Wreq)
       # @return [Wreq::Response] HTTP response
       # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
       #   value cannot be converted, validated, or built
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the client or runtime belongs to the parent process
       def put(url, **options)
       end
 
@@ -460,7 +464,7 @@ unless defined?(Wreq)
       # @return [Wreq::Response] HTTP response
       # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
       #   value cannot be converted, validated, or built
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the client or runtime belongs to the parent process
       def delete(url, **options)
       end
 
@@ -494,7 +498,7 @@ unless defined?(Wreq)
       # @return [Wreq::Response] HTTP response
       # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
       #   value cannot be converted, validated, or built
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the client or runtime belongs to the parent process
       def options(url, **options)
       end
 
@@ -528,7 +532,7 @@ unless defined?(Wreq)
       # @return [Wreq::Response] HTTP response
       # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
       #   value cannot be converted, validated, or built
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the client or runtime belongs to the parent process
       def trace(url, **options)
       end
 
@@ -562,7 +566,7 @@ unless defined?(Wreq)
       # @return [Wreq::Response] HTTP response
       # @raise [TypeError, ArgumentError, Wreq::BuilderError] if a known option
       #   value cannot be converted, validated, or built
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the client or runtime belongs to the parent process
       def patch(url, **options)
       end
     end

data/lib/wreq_ruby/cookie.rb

@@ -158,6 +158,11 @@ unless defined?(Wreq)
     # Stores cookies for reuse across requests.
     #
     # Pass a Jar to Wreq::Client as `cookie_provider` to share its cookies.
+    # A jar belongs to the process that created it and cannot be inherited
+    # across `fork`.
+    #
+    # @note Fork safety Create a new jar in each worker. wreq-ruby does not
+    #   copy cookies from an inherited jar.
     class Jar
       # Creates an empty cookie jar.
       # @return [Wreq::Jar]
@@ -166,6 +171,7 @@ unless defined?(Wreq)
 
       # Returns all stored cookies.
       # @return [Array<Wreq::Cookie>]
+      # @raise [Wreq::ForkError] if the jar belongs to the parent process
       def get_all
       end
 
@@ -174,6 +180,7 @@ unless defined?(Wreq)
       # @param url [String] URL that scopes the cookie
       # @return [void]
       # @raise [TypeError] if cookie is neither a String nor Wreq::Cookie
+      # @raise [Wreq::ForkError] if the jar belongs to the parent process
       def add(cookie, url)
       end
 
@@ -181,11 +188,13 @@ unless defined?(Wreq)
       # @param name [String]
       # @param url [String]
       # @return [void]
+      # @raise [Wreq::ForkError] if the jar belongs to the parent process
       def remove(name, url)
       end
 
       # Clear all cookies from the jar.
       # @return [void]
+      # @raise [Wreq::ForkError] if the jar belongs to the parent process
       def clear
       end
     end

data/lib/wreq_ruby/error.rb

@@ -11,15 +11,17 @@ unless defined?(Wreq)
     # Memory allocation failed.
     class MemoryError < StandardError; end
 
-    # The child process inherited wreq-ruby from its parent.
+    # The child process tried to use native state created by its parent.
     #
-    # Tokio worker threads do not survive fork, and inherited pooled
-    # connections are not safe to reuse. This error is raised before a child
-    # can access that state.
+    # Tokio worker threads do not survive fork. Inherited connection pools,
+    # locks, channels, and response state are also unsafe to use. wreq-ruby
+    # raises this error before exposing them. Loading the gem before fork is
+    # supported, but native-backed objects must be created in each worker.
     #
     # @example
+    #   client = Wreq::Client.new
     #   Process.fork do
-    #     Wreq::Client.new # Raises if the parent loaded wreq-ruby.
+    #     client.get("https://example.com") # Raises in the child.
     #   end
     # @see https://github.com/SearchApi/wreq-ruby/blob/main/docs/fork-safety.md
     class ForkError < RuntimeError; end

data/lib/wreq_ruby/response.rb

@@ -8,8 +8,12 @@ unless defined?(Wreq)
     # access to HTTP response data including status codes, headers, body
     # content, and streaming capabilities.
     #
-    # Body methods raise Wreq::ForkError if the child inherited wreq-ruby from
-    # its parent.
+    # A response belongs to the process that received it. Accessing its metadata
+    # or body after inheriting it from a parent raises Wreq::ForkError.
+    #
+    # @note Fork safety Keep each response in the process that received it.
+    #   Issue a new request in the worker instead of carrying a response through
+    #   `fork`.
     #
     # @example Basic response handling
     #   response = client.get("https://api.example.com")
@@ -29,6 +33,7 @@ unless defined?(Wreq)
       # Get the HTTP status code as an integer.
       #
       # @return [Integer] Status code (e.g., 200, 404, 500)
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example
       #   response.code  # => 200
       def code
@@ -37,6 +42,7 @@ unless defined?(Wreq)
       # Get the HTTP status code object.
       #
       # @return [Wreq::StatusCode] Status code wrapper with helper methods
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example
       #   status = response.status
       #   status.success?  # => true
@@ -46,6 +52,7 @@ unless defined?(Wreq)
       # Get the HTTP protocol version used.
       #
       # @return [Wreq::Version] HTTP version (HTTP/1.1, HTTP/2, etc.)
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example
       #   response.version  # => Wreq::Version::HTTP_11
       def version
@@ -54,6 +61,7 @@ unless defined?(Wreq)
       # Get the final URL after redirects.
       #
       # @return [String] The final URL
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example
       #   response.url  # => "https://example.com/final-page"
       def url
@@ -62,6 +70,7 @@ unless defined?(Wreq)
       # Get the content length if known.
       #
       # @return [Integer, nil] Content length in bytes, or nil if unknown
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example
       #   response.content_length  # => 1024
       def content_length
@@ -75,6 +84,7 @@ unless defined?(Wreq)
       # response or a later snapshot, and object identity is not guaranteed.
       #
       # @return [Wreq::Headers] Response headers
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example
       #   response.headers.get("content-type")  # => "application/json"
       def headers
@@ -83,6 +93,7 @@ unless defined?(Wreq)
       # Get the local socket address.
       #
       # @return [String, nil] Local address (e.g., "127.0.0.1:54321"), or nil
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example
       #   response.local_addr  # => "192.168.1.100:54321"
       def local_addr
@@ -91,6 +102,7 @@ unless defined?(Wreq)
       # Get the remote socket address.
       #
       # @return [String, nil] Remote address (e.g., "93.184.216.34:443"), or nil
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example
       #   response.remote_addr  # => "93.184.216.34:443"
       def remote_addr
@@ -101,6 +113,7 @@ unless defined?(Wreq)
       # Invalid `Set-Cookie` values are skipped.
       #
       # @return [Array<Wreq::Cookie>] Parsed response cookies
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example
       #   response.cookies.each do |cookie|
       #     puts "#{cookie.name}=#{cookie.value}"
@@ -110,7 +123,7 @@ unless defined?(Wreq)
 
       # Get the response bytes as a binary string.
       # @return [String] Response body as binary data
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example
       #   binary_data = response.bytes
       #   puts binary_data.size  # => 1024
@@ -126,7 +139,7 @@ unless defined?(Wreq)
       #   html = response.text("ISO-8859-1")
       #   puts html
       # @raise [Wreq::DecodingError] if body cannot be decoded with the specified encoding
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       def text(default_encoding = "UTF-8")
       end
 
@@ -137,7 +150,7 @@ unless defined?(Wreq)
       #
       # @return [Object] Parsed JSON (Hash, Array, String, Integer, Float, Boolean, nil)
       # @raise [Wreq::DecodingError] if body is not valid JSON
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example
       #   data = response.json
       #   puts data["key"]
@@ -155,7 +168,7 @@ unless defined?(Wreq)
       # @raise [LocalJumpError] if called without a block
       # @raise [Wreq::TimeoutError, Wreq::BodyError, Wreq::ConnectionResetError, Wreq::RequestError]
       #   if streaming fails while reading the response body
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example Save response to file
       #   File.open("output.bin", "wb") do |f|
       #     response.chunks { |chunk| f.write(chunk) }
@@ -172,7 +185,7 @@ unless defined?(Wreq)
       # Close the response and free associated resources.
       #
       # @return [void]
-      # @raise [Wreq::ForkError] if the child inherited wreq-ruby from its parent
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example
       #   response.close
       def close
@@ -186,6 +199,7 @@ unless defined?(Wreq)
       #
       # @return [Wreq::TlsInfo, nil] TLS information for this response, or +nil+
       #   when unavailable
+      # @raise [Wreq::ForkError] if the response belongs to the parent process
       # @example
       #   client = Wreq::Client.new(tls_info: true)
       #   response = client.get("https://example.com")
@@ -208,6 +222,7 @@ module Wreq
     # Returns the response body as a string.
     #
     # @return [String] Response body text
+    # @raise [Wreq::ForkError] if the response belongs to the parent process
     # @example
     #   puts response.to_s
     #   puts response
@@ -221,6 +236,7 @@ module Wreq
     # Format: #<Wreq::Response STATUS content-type="..." body=SIZE>
     #
     # @return [String] Compact formatted response information
+    # @raise [Wreq::ForkError] if the response belongs to the parent process
     # @example
     #   p response
     #   # => #<Wreq::Response 200 content-type="application/json" body=456B>