wreq-rb 0.5.1 → 0.6.1

data/README.md

@@ -114,6 +114,34 @@ All methods are available on both `Wreq` (module-level) and `Wreq::Client` (inst
 | `head(url, **opts)` | HEAD request |
 | `options(url, **opts)` | OPTIONS request |
 
+### Batch Requests
+
+`Wreq::Client#request_batch` runs many requests concurrently inside a **single**
+GVL release, multiplexed over the client's connection pool. This avoids one Ruby
+thread per request.
+
+```ruby
+client = Wreq::Client.new(redirect: false, pool_max_idle_per_host: 32)
+
+responses = client.request_batch(urls, concurrency: 128)
+```
+
+Each element of the array is either a URL string or a hash:
+
+```ruby
+client.request_batch([
+  "https://example.com/a", # GET
+  { method: :put, url: "https://example.com/b", body: "hi" }
+], concurrency: 32)
+```
+
+- Results are returned **in input order**.
+- Each element is a `Wreq::Response` **or** a `Wreq::Error` — a single failed
+  request never discards the rest of the batch. Errors are returned, not raised.
+- `concurrency` caps the number of in-flight requests and defaults to `16`.
+- `cancel` and Ruby thread interrupts abort the whole batch, raising
+  `Wreq::Error` with `"request interrupted"`.
+
 ### Cancelling Requests
 
 Call `cancel` on a client to interrupt all in-flight requests immediately:

data/ext/wreq_rb/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wreq_rb"
-version = "0.5.1"
+version = "0.6.1"
 edition = "2021"
 publish = false
 
@@ -10,7 +10,7 @@ crate-type = ["cdylib"]
 [dependencies]
 magnus = { version = "0.8", features = ["rb-sys"] }
 rb-sys = "0.9"
-wreq = { path = "../../vendor/wreq", version = "=6.0.0-rc.29", features = [
+wreq = { path = "../../vendor/wreq", version = "=0.16.1", features = [
   "cookies",
   "json",
   "gzip",
@@ -24,7 +24,7 @@ wreq = { path = "../../vendor/wreq", version = "=6.0.0-rc.29", features = [
   "query",
   "form",
 ] }
-wreq-util = { version = "=3.0.0-rc.12", features = ["emulation", "emulation-serde", "emulation-compression"] }
+wreq-util = { version = "=0.2.0", features = ["emulation", "emulation-serde", "emulation-compression"] }
 tokio = { version = "1", features = ["full"] }
 tokio-util = "0.7"
 serde_json = "1.0"
@@ -32,6 +32,6 @@ bytes = "1"
 http = "1"
 
 [target.'cfg(target_os = "linux")'.dependencies]
-wreq = { path = "../../vendor/wreq", version = "=6.0.0-rc.29", features = [
+wreq = { path = "../../vendor/wreq", version = "=0.16.1", features = [
   "prefix-symbols",
 ] }

data/ext/wreq_rb/src/client.rs

@@ -2,6 +2,7 @@ use std::ffi::c_void;
 use std::panic::{self, AssertUnwindSafe};
 use std::ptr;
 use std::any::Any;
+use std::sync::Arc;
 use std::time::Duration;
 
 use magnus::{
@@ -9,13 +10,15 @@ use magnus::{
     try_convert::TryConvert, Value,
 };
 use tokio::runtime::Runtime;
+use tokio::sync::Semaphore;
+use tokio::task::JoinSet;
 use tokio_util::sync::CancellationToken;
 use std::net::IpAddr;
 use wreq::header::{HeaderMap, HeaderName, HeaderValue, OrigHeaderMap};
 use wreq::tls::TlsVersion;
 use wreq_util::{Emulation as BrowserEmulation, Platform as EmulationPlatform, Profile as BrowserProfile};
 
-use crate::error::{generic_error, to_magnus_error};
+use crate::error::{generic_error, to_magnus_error, wreq_error};
 use crate::response::Response;
 
 // --------------------------------------------------------------------------
@@ -137,12 +140,68 @@ async fn execute_request(req: wreq::RequestBuilder) -> Result<ResponseData, wreq
     Ok(ResponseData { status, headers, body, url, version, content_length, transfer_size })
 }
 
+// --------------------------------------------------------------------------
+// Batch execution
+// --------------------------------------------------------------------------
+
+const DEFAULT_BATCH_CONCURRENCY: usize = 16;
+
+/// Per-item batch result as pure Rust types (no Ruby objects). Errors are kept
+/// as messages so one failure never discards the rest of the batch.
+enum BatchItem {
+    Ok(ResponseData),
+    Err(String),
+}
+
+/// Outcome of a whole batch performed outside the GVL.
+enum BatchOutcome {
+    Done(Vec<BatchItem>),
+    Interrupted,
+}
+
+/// Run every request concurrently with at most `concurrency` in flight,
+/// returning results in input order.
+async fn execute_batch(reqs: Vec<wreq::RequestBuilder>, concurrency: usize) -> Vec<BatchItem> {
+    let permits = Arc::new(Semaphore::new(concurrency));
+    let mut set: JoinSet<(usize, BatchItem)> = JoinSet::new();
+
+    for (idx, req) in reqs.into_iter().enumerate() {
+        let permits = Arc::clone(&permits);
+        set.spawn(async move {
+            let _permit = match permits.acquire_owned().await {
+                Ok(p) => p,
+                Err(_) => return (idx, BatchItem::Err("batch semaphore closed".to_owned())),
+            };
+            let item = match execute_request(req).await {
+                Ok(data) => BatchItem::Ok(data),
+                Err(e) => BatchItem::Err(e.to_string()),
+            };
+            (idx, item)
+        });
+    }
+
+    let mut slots: Vec<Option<BatchItem>> = Vec::new();
+    slots.resize_with(set.len(), || None);
+    while let Some(joined) = set.join_next().await {
+        // A JoinError means the task panicked or was aborted; its slot is left
+        // empty and filled with a generic error below.
+        if let Ok((idx, item)) = joined {
+            slots[idx] = Some(item);
+        }
+    }
+
+    slots
+        .into_iter()
+        .map(|slot| slot.unwrap_or_else(|| BatchItem::Err("request task failed".to_owned())))
+        .collect()
+}
+
 // --------------------------------------------------------------------------
 // Emulation helpers
 // --------------------------------------------------------------------------
 
 /// The default browser profile to apply when none is specified.
-const DEFAULT_EMULATION: BrowserProfile = BrowserProfile::Chrome148;
+const DEFAULT_EMULATION: BrowserProfile = BrowserProfile::Chrome149;
 
 /// Parse a Ruby string like "chrome_143" into a BrowserProfile variant.
 fn parse_emulation(name: &str) -> Result<BrowserProfile, magnus::Error> {
@@ -439,6 +498,120 @@ impl Client {
         };
         Ok(Response::new(data.status, data.headers, data.body, data.url, data.version, data.content_length, data.transfer_size))
     }
+
+    /// Wreq::Client#request_batch(specs) or #request_batch(specs, options)
+    fn request_batch(&self, args: &[Value]) -> Result<RArray, magnus::Error> {
+        if args.is_empty() {
+            return Err(generic_error("an array of requests is required"));
+        }
+        let specs = RArray::try_convert(args[0])?;
+
+        let opts: Option<RHash> = if args.len() > 1 {
+            Some(RHash::try_convert(args[1])?)
+        } else {
+            None
+        };
+
+        let concurrency = match opts.as_ref() {
+            Some(o) => hash_get_usize(o, "concurrency")?.unwrap_or(DEFAULT_BATCH_CONCURRENCY),
+            None => DEFAULT_BATCH_CONCURRENCY,
+        };
+        if concurrency == 0 {
+            return Err(generic_error("concurrency must be >= 1"));
+        }
+
+        // All Ruby -> Rust conversion happens here, while we still hold the GVL.
+        let mut reqs: Vec<wreq::RequestBuilder> = Vec::with_capacity(specs.len());
+        for spec in specs.into_iter() {
+            reqs.push(self.build_request(spec, opts.as_ref())?);
+        }
+
+        let ruby = unsafe { Ruby::get_unchecked() };
+        if reqs.is_empty() {
+            return Ok(ruby.ary_new());
+        }
+
+        let client_token = self.cancel_token.lock().unwrap_or_else(|e| e.into_inner()).clone();
+
+        // One GVL release covering the whole batch.
+        let outcome: BatchOutcome = unsafe {
+            without_gvl(|thread_token| {
+                runtime().block_on(async {
+                    tokio::select! {
+                        biased;
+                        _ = thread_token.cancelled() => BatchOutcome::Interrupted,
+                        _ = client_token.cancelled() => BatchOutcome::Interrupted,
+                        items = execute_batch(reqs, concurrency) => BatchOutcome::Done(items),
+                    }
+                })
+            })
+        };
+
+        let items = match outcome {
+            BatchOutcome::Done(items) => items,
+            BatchOutcome::Interrupted => return Err(generic_error("request interrupted")),
+        };
+
+        // Back under the GVL: Ruby objects may be created again.
+        let results = ruby.ary_new_capa(items.len());
+        for item in items {
+            match item {
+                BatchItem::Ok(d) => {
+                    let resp = Response::new(
+                        d.status, d.headers, d.body, d.url, d.version, d.content_length,
+                        d.transfer_size,
+                    );
+                    results.push(ruby.obj_wrap(resp))?;
+                }
+                BatchItem::Err(msg) => {
+                    let err: Value = wreq_error().funcall("new", (msg,))?;
+                    results.push(err)?;
+                }
+            }
+        }
+        Ok(results)
+    }
+
+    /// Convert a single batch spec into a RequestBuilder. Accepted forms:
+    ///   "https://example.com"      -> GET
+    ///   { method:, url:, **opts }
+    fn build_request(
+        &self,
+        spec: Value,
+        shared: Option<&RHash>,
+    ) -> Result<wreq::RequestBuilder, magnus::Error> {
+        let mut method = wreq::Method::GET;
+        let url: String;
+        let mut item_opts: Option<RHash> = None;
+
+        if let Some(hash) = RHash::from_value(spec) {
+            url = hash_get_string(&hash, "url")?
+                .ok_or_else(|| generic_error("each request hash requires a :url"))?;
+            if let Some(val) = hash_get_value(&hash, "method")? {
+                method = value_to_method(val)?;
+            }
+            item_opts = Some(hash);
+        } else {
+            url = TryConvert::try_convert(spec)?;
+        }
+
+        let mut req = self.inner.request(method, &url);
+        if let Some(shared) = shared {
+            req = apply_request_options(req, shared)?;
+        }
+        if let Some(item_opts) = item_opts {
+            req = apply_request_options(req, &item_opts)?;
+        }
+        Ok(req)
+    }
+}
+
+/// Parse a String or Symbol like "post" / :post into an HTTP method.
+fn value_to_method(val: Value) -> Result<wreq::Method, magnus::Error> {
+    let name: String = val.funcall("to_s", ())?;
+    name.to_uppercase()
+        .parse()
+        .map_err(|_| generic_error(format!("invalid HTTP method: {}", name)))
 }
 
 fn apply_request_options(
@@ -692,6 +865,7 @@ pub fn init(_ruby: &magnus::Ruby, module: &magnus::RModule) -> Result<(), magnus
     client_class.define_method("delete", method!(Client::delete, -1))?;
     client_class.define_method("head", method!(Client::head, -1))?;
     client_class.define_method("options", method!(Client::options, -1))?;
+    client_class.define_method("request_batch", method!(Client::request_batch, -1))?;
     client_class.define_method("cancel", method!(Client::cancel, 0))?;
 
     module.define_module_function("get", function!(wreq_get, -1))?;

data/lib/wreq-rb/version.rb

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

data/patches/0001-add-transfer-size-tracking.patch

@@ -1,5 +1,5 @@
 diff --git a/src/client.rs b/src/client.rs
-index 4abe25d8..76e709a8 100644
+index 214fe423..ccbdb0e9 100644
 --- a/src/client.rs
 +++ b/src/client.rs
 @@ -49,6 +49,7 @@ use self::{
@@ -10,18 +10,14 @@ index 4abe25d8..76e709a8 100644
      },
      request::{Request, RequestBuilder},
      response::Response,
-@@ -115,25 +116,30 @@ type MaybeDecompressionBody<T> = tower_http::decompression::DecompressionBody<T>
+@@ -116,24 +117,26 @@ type MaybeDecompressionBody<T> = tower_http::decompression::DecompressionBody<T>
+ 
  type ClientService = Timeout<
      ConfigService<
-         MaybeDecompression<
--            Retry<RetryPolicy, FollowRedirect<HttpClient<Connector, Body>, FollowRedirectPolicy>>,
-+            TransferSizeService<
-+                Retry<
-+                    RetryPolicy,
-+                    FollowRedirect<HttpClient<Connector, Body>, FollowRedirectPolicy>,
-+                >,
-+            >,
-         >,
+-        MaybeDecompression<Retry<RetryPolicy, FollowRedirect<HttpClient<Connector, Body>>>>,
++        MaybeDecompression<
++            TransferSizeService<Retry<RetryPolicy, FollowRedirect<HttpClient<Connector, Body>>>>,
++        >,
      >,
  >;
  
@@ -45,7 +41,7 @@ index 4abe25d8..76e709a8 100644
      BoxError,
  >;
  
-@@ -593,6 +599,10 @@ impl ClientBuilder {
+@@ -597,6 +600,10 @@ impl ClientBuilder {
                  })
                  .service(service);
  
@@ -56,7 +52,7 @@ index 4abe25d8..76e709a8 100644
              #[cfg(any(
                  feature = "gzip",
                  feature = "zstd",
-@@ -1585,7 +1595,7 @@ impl ClientBuilder {
+@@ -1607,7 +1614,7 @@ impl ClientBuilder {
          L: Layer<
                  BoxCloneSyncService<
                      http::Request<Body>,
@@ -65,7 +61,7 @@ index 4abe25d8..76e709a8 100644
                      BoxError,
                  >,
              > + Clone
-@@ -1594,7 +1604,7 @@ impl ClientBuilder {
+@@ -1616,7 +1623,7 @@ impl ClientBuilder {
              + 'static,
          L::Service: Service<
                  http::Request<Body>,
@@ -266,7 +262,7 @@ index 00000000..f155ec8d
 +    }
 +}
 diff --git a/src/client/response.rs b/src/client/response.rs
-index 3d3532af..ed478804 100644
+index 3d3532af..7d29ec45 100644
 --- a/src/client/response.rs
 +++ b/src/client/response.rs
 @@ -18,6 +18,7 @@ use mime::Mime;

data/vendor/wreq/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "wreq"
-version = "6.0.0-rc.29"
-description = "An ergonomic Rust HTTP Client with TLS fingerprint"
+version = "0.16.1"
+description = "An ergonomic, privacy-aware Rust HTTP Client"
 keywords = ["http", "client", "websocket", "ja3", "ja4"]
 categories = ["web-programming::http-client"]
 repository = "https://github.com/0x676e67/wreq"
@@ -10,8 +10,8 @@ authors = ["0x676e67 <gngppz@gmail.com>"]
 readme = "README.md"
 license = "Apache-2.0"
 edition = "2024"
-rust-version = "1.85"
-include = ["README.md", "LICENSE", "src/**/*.rs"]
+rust-version = "1.98"
+include = ["/README.md", "/LICENSE", "/src/**/*.rs"]
 
 [package.metadata.docs.rs]
 all-features = true
@@ -92,10 +92,10 @@ http = "1.4.0"
 http2 = "0.5.17"
 httparse = "1.10.1"
 http-body = "1.0.1"
-http-body-util = "0.1.3"
+http-body-util = "0.1.4"
 percent-encoding = "2.3.2"
 pin-project-lite = "0.2.17"
-futures-util = { version = "0.3.32", default-features = false }
+futures-util = { version = "0.3.33", default-features = false }
 socket2 = { version = "0.6.3", features = ["all"] }
 ipnet = "2.12.0"
 lru = "0.18.0"
@@ -103,7 +103,7 @@ btls = "0.5.6"
 btls-sys = "0.5.6"
 tokio-btls = "0.5.6"
 tokio = { version = "1.52.3", default-features = false }
-compio = { version = "0.19.0-rc.1", features = ["io", "io-compat"], optional = true }
+compio = { version = "0.19.2", features = ["io", "io-compat"], optional = true }
 wreq-rt = { version = "0.2.2-rc.2", default-features = false }
 wreq-proto = { version = "0.2.3", default-features = false }
 tower = { version = "0.5.3", default-features = false, features = [
@@ -174,7 +174,7 @@ tokio = { version = "1.0", default-features = false, features = [
     "macros",
     "rt-multi-thread",
 ] }
-compio = { version = "0.19.0-rc.1", features = ["macros", "net", "runtime", "time", "io", "io-compat"] }
+compio = { version = "0.19.2", features = ["macros", "net", "runtime", "time", "io", "io-compat"] }
 hyper = { version = "1.7.0", default-features = false, features = [
     "http1",
     "http2",
@@ -202,6 +202,7 @@ zstd = "0.13.3"
 sysinfo = { version = "0.39.1", default-features = false, features = ["system"] }
 criterion = { version = "0.8.2", features = ["async_tokio"] }
 reqwest = { version = "0.13.3", default-features = false, features = ["rustls", "stream", "http2"] }
+cyper = { version = "0.9.0",  default-features = false, features = ["rustls", "stream"] }
 
 [profile.release]
 codegen-units = 1

data/vendor/wreq/README.md

@@ -2,8 +2,8 @@
 
 [![CI](https://github.com/0x676e67/wreq/actions/workflows/ci.yml/badge.svg)](https://github.com/0x676e67/wreq/actions/workflows/ci.yml)
 [![Crates.io License](https://img.shields.io/crates/l/wreq)](https://github.com/0x676e67/wreq/blob/main/LICENSE)
-[![Crates.io MSRV](https://img.shields.io/crates/msrv/wreq?logo=rust)](https://crates.io/crates/wreq)
-[![crates.io](https://img.shields.io/crates/v/wreq.svg?logo=rust)](https://crates.io/crates/wreq)
+[![Crates.io MSRV](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fcrates.io%2Fapi%2Fv1%2Fcrates%2Fwreq%2Fversions%3Fsort%3Ddate%26per_page%3D1&query=%24.versions%5B0%5D.rust_version&suffix=.0&label=MSRV&color=blue&logo=rust)](https://crates.io/crates/wreq)
+[![crates.io](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fcrates.io%2Fapi%2Fv1%2Fcrates%2Fwreq&query=%24.crate.max_stable_version&prefix=v&label=crates.io&color=orange&logo=rust)](https://crates.io/crates/wreq)
 [![Discord chat][discord-badge]][discord-url]
 
 [discord-badge]: https://img.shields.io/discord/1486741856397164788.svg?logo=discord
@@ -35,8 +35,8 @@ The following example uses the [Tokio](https://tokio.rs) runtime with optional f
 ```toml
 [dependencies]
 tokio = { version = "1", features = ["full"] }
-wreq = "6.0.0-rc"
-wreq-util = "3.0.0-rc"
+wreq = "0.16"
+wreq-util = "0.2"
 ```
 
 And then the code:
@@ -53,7 +53,7 @@ async fn main() -> wreq::Result<()> {
         .build()?;
 
     // Use the API you're already familiar with
-    let resp = client.get("https://tls.peet.ws/api/all").send().await?;
+    let resp = client.get("https://pingly.us.kg/api/all").send().await?;
     println!("{}", resp.text().await?);
     Ok(())
 }

data/vendor/wreq/bench/support/bench.rs

@@ -1,8 +1,10 @@
 use criterion::Criterion;
 
 use crate::support::{
-    BoxError, HttpVersion, Tls, client::bench_clients, current_thread_runtime,
-    multi_thread_runtime, server::with_server,
+    BoxError, HttpVersion, Tls,
+    client::bench_clients,
+    rt::{current_thread_runtime, multi_thread_runtime},
+    server::with_server,
 };
 
 pub const CURRENT_THREAD_LABEL: &str = "current_thread";
@@ -54,6 +56,7 @@ pub fn bench(
                 bench_clients(
                     &mut group,
                     current_thread_runtime,
+                    true,
                     addr,
                     tls,
                     http_version,
@@ -74,6 +77,7 @@ pub fn bench(
                 bench_clients(
                     &mut group,
                     multi_thread_runtime,
+                    false,
                     addr,
                     tls,
                     http_version,

data/vendor/wreq/bench/support/client.rs

@@ -2,10 +2,11 @@ use std::{convert::Infallible, net::SocketAddr, sync::Arc};
 
 use bytes::Bytes;
 use criterion::{BenchmarkGroup, measurement::WallTime};
+use futures::{StreamExt, TryStreamExt};
 use http_body_util::BodyExt;
 use tokio::{runtime::Runtime, sync::Semaphore};
 
-use super::{BoxError, HttpVersion, Tls};
+use super::{BoxError, HttpVersion, Tls, rt::CompioBenchExecutor};
 
 fn create_wreq_client(tls: Tls, http_version: HttpVersion) -> Result<wreq::Client, BoxError> {
     let builder = wreq::Client::builder()
@@ -35,6 +36,20 @@ fn create_reqwest_client(tls: Tls, http_version: HttpVersion) -> Result<reqwest:
     Ok(builder.build()?)
 }
 
+fn create_cyper_client(tls: Tls, http_version: HttpVersion) -> Result<cyper::Client, BoxError> {
+    let builder = cyper::Client::builder()
+        .no_proxy()
+        .redirect(cyper::redirect::Policy::none())
+        .danger_accept_invalid_certs(matches!(tls, Tls::Enabled));
+
+    let builder = match http_version {
+        HttpVersion::Http1 => builder,
+        HttpVersion::Http2 => builder.http2_prior_knowledge(),
+    };
+
+    Ok(builder.build()?)
+}
+
 async fn wreq_body_assert(mut response: wreq::Response, expected_body_size: usize) {
     let mut body_size = 0;
     while let Some(Ok(chunk)) = response.frame().await {
@@ -59,6 +74,17 @@ async fn reqwest_body_assert(mut response: reqwest::Response, expected_body_size
     );
 }
 
+async fn cyper_body_assert(mut response: cyper::Response, expected_body_size: usize) {
+    let mut body_size = 0;
+    while let Some(Ok(chunk)) = response.next().await {
+        body_size += chunk.len();
+    }
+    assert!(
+        body_size == expected_body_size,
+        "Unexpected response body: got {body_size} bytes, expected {expected_body_size} bytes"
+    );
+}
+
 fn stream_from_bytes(
     body: &'static [u8],
     chunk_size: usize,
@@ -94,6 +120,16 @@ fn reqwest_body(stream: bool, (body, chunk_size): (&'static [u8], usize)) -> req
     }
 }
 
+#[inline]
+fn cyper_body(stream: bool, (body, chunk_size): (&'static [u8], usize)) -> cyper::Body {
+    if stream {
+        let stream = stream_from_bytes(body, chunk_size).map_err(|never| match never {});
+        cyper::Body::stream(stream)
+    } else {
+        cyper::Body::from(body)
+    }
+}
+
 async fn wreq_requests_concurrent(
     client: &wreq::Client,
     url: &str,
@@ -158,10 +194,44 @@ async fn reqwest_requests_concurrent(
     futures_util::future::join_all(handles).await;
 }
 
+async fn cyper_requests_concurrent(
+    client: &cyper::Client,
+    url: &str,
+    num_requests: usize,
+    concurrent_limit: usize,
+    body: (&'static [u8], usize),
+    stream: bool,
+) {
+    let semaphore = Arc::new(Semaphore::new(concurrent_limit));
+    let mut handles = Vec::with_capacity(num_requests);
+    for _ in 0..num_requests {
+        let client = client.clone();
+        let url = url.to_string();
+        let semaphore = semaphore.clone();
+        let fut = async move {
+            let _permit = semaphore
+                .acquire()
+                .await
+                .expect("Semaphore should be acquirable");
+            let response = client
+                .post(url)
+                .expect("Unexpected request failure")
+                .body(cyper_body(stream, body))
+                .send()
+                .await
+                .expect("Unexpected request failure");
+            cyper_body_assert(response, body.0.len()).await;
+        };
+        handles.push(compio::runtime::spawn(fut));
+    }
+    futures_util::future::join_all(handles).await;
+}
+
 #[allow(clippy::too_many_arguments)]
 pub fn bench_clients(
     group: &mut BenchmarkGroup<'_, WallTime>,
     rt: fn() -> Runtime,
+    include_cyper: bool,
     addr: SocketAddr,
     tls: Tls,
     http_version: HttpVersion,
@@ -211,6 +281,23 @@ pub fn bench_clients(
             })
         });
         ::std::mem::drop(client);
+
+        if include_cyper {
+            let compio_executor = CompioBenchExecutor::new()?;
+            let client = create_cyper_client(tls, http_version)?;
+            group.bench_function(make_benchmark_label::<cyper::Client>(stream), |b| {
+                b.to_async(&compio_executor).iter(|| {
+                    cyper_requests_concurrent(
+                        &client,
+                        &url,
+                        num_requests,
+                        concurrent_limit,
+                        body,
+                        stream,
+                    )
+                })
+            });
+        }
     }
 
     Ok(())

data/vendor/wreq/bench/support/rt.rs

@@ -0,0 +1,34 @@
+use criterion::async_executor::AsyncExecutor;
+
+pub struct CompioBenchExecutor {
+    runtime: compio::runtime::Runtime,
+}
+
+impl CompioBenchExecutor {
+    pub fn new() -> std::io::Result<Self> {
+        Ok(Self {
+            runtime: compio::runtime::Runtime::new()?,
+        })
+    }
+}
+
+impl AsyncExecutor for &CompioBenchExecutor {
+    fn block_on<T>(&self, future: impl std::future::Future<Output = T>) -> T {
+        self.runtime.block_on(future)
+    }
+}
+
+pub fn current_thread_runtime() -> tokio::runtime::Runtime {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .expect("Failed to build current-thread runtime")
+}
+
+pub fn multi_thread_runtime() -> tokio::runtime::Runtime {
+    tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(4)
+        .enable_all()
+        .build()
+        .expect("Failed to build multi-thread runtime")
+}

data/vendor/wreq/bench/support/server.rs

@@ -20,7 +20,7 @@ use tokio::{
 };
 use tokio_btls::SslStream;
 
-use super::{BoxError, Tls, multi_thread_runtime};
+use super::{BoxError, Tls, rt::multi_thread_runtime};
 
 pub struct Server {
     listener: std::net::TcpListener,