wreq 1.2.4 → 1.2.5

data/crates/wreq-util/src/tower/delay/future.rs

@@ -0,0 +1,43 @@
+use std::{
+    pin::Pin,
+    task::{Context, Poll, ready},
+};
+
+use pin_project_lite::pin_project;
+use tokio::time::Sleep;
+use tower::BoxError;
+
+pin_project! {
+    /// Response future for [`Delay`].
+    ///
+    /// [`Delay`]: super::Delay
+    #[derive(Debug)]
+    pub struct ResponseFuture<S> {
+        #[pin]
+        response: S,
+        #[pin]
+        sleep: Sleep,
+    }
+}
+
+impl<S> ResponseFuture<S> {
+    // Create a new [`ResponseFuture`]
+    #[inline]
+    pub(crate) fn new(response: S, sleep: Sleep) -> Self {
+        ResponseFuture { response, sleep }
+    }
+}
+
+impl<F, S, E> Future for ResponseFuture<F>
+where
+    F: Future<Output = Result<S, E>>,
+    E: Into<BoxError>,
+{
+    type Output = Result<S, BoxError>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        ready!(this.sleep.poll(cx));
+        this.response.poll(cx).map_err(Into::into)
+    }
+}

data/crates/wreq-util/src/tower/delay/layer.rs

@@ -0,0 +1,201 @@
+use std::time::Duration;
+
+use tower::Layer;
+
+use super::service::{Delay, DelayWith, JitterDelay, JitterDelayWith};
+
+/// A Tower [`Layer`] that introduces a fixed delay before each request.
+#[derive(Clone, Debug)]
+pub struct DelayLayer {
+    delay: Duration,
+}
+
+/// Conditional delay [`Layer`], applies delay based on a predicate.
+///
+/// Created via [`DelayLayer::when`].
+#[derive(Clone, Debug)]
+pub struct DelayLayerWith<P> {
+    delay: Duration,
+    predicate: P,
+}
+
+/// A Tower [`Layer`] that introduces a jittered delay before each request.
+///
+/// The actual delay for each request will be randomly chosen within the range
+/// `[base - base*pct, base + base*pct]`.
+///
+/// # Example
+///
+/// ```no_run
+/// use std::time::Duration;
+/// use wreq::Client;
+/// use wreq_util::middleware::delay::JitterDelayLayer;
+///
+/// // Creates delays in range [0.8s, 1.2s] (1s ± 20%)
+/// let client = Client::builder()
+///     .layer(JitterDelayLayer::new(Duration::from_secs(1), 0.2))
+///     .build()?;
+/// # Ok::<(), wreq::Error>(())
+/// ```
+#[derive(Clone, Debug)]
+pub struct JitterDelayLayer {
+    base: Duration,
+    pct: f64,
+}
+
+/// Conditional jitter delay [`Layer`], applies delay based on a predicate.
+///
+/// Created via [`JitterDelayLayer::when`].
+#[derive(Clone, Debug)]
+pub struct JitterDelayLayerWith<P> {
+    base: Duration,
+    pct: f64,
+    predicate: P,
+}
+
+// ===== impl DelayLayer =====
+
+impl DelayLayer {
+    /// Create a new [`DelayLayer`] with the given delay duration.
+    #[inline]
+    pub const fn new(delay: Duration) -> Self {
+        DelayLayer { delay }
+    }
+
+    /// Apply delay only to requests that satisfy a predicate.
+    ///
+    /// Requests that don't match the predicate will pass through without delay.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use std::time::Duration;
+    /// use http::Request;
+    /// use wreq_util::middleware::delay::DelayLayer;
+    ///
+    /// // Only delay POST requests
+    /// let layer = DelayLayer::new(Duration::from_secs(1))
+    ///     .when(|req: &Request<_>| req.method() == http::Method::POST);
+    /// ```
+    pub fn when<P, Req>(self, predicate: P) -> DelayLayerWith<P>
+    where
+        P: Fn(&Req) -> bool + Clone,
+    {
+        DelayLayerWith::new(self.delay, predicate)
+    }
+}
+
+impl<S> Layer<S> for DelayLayer {
+    type Service = Delay<S>;
+
+    #[inline]
+    fn layer(&self, service: S) -> Self::Service {
+        Delay::new(service, self.delay)
+    }
+}
+
+// ===== impl DelayLayerWith =====
+
+impl<P> DelayLayerWith<P> {
+    /// Creates a new [`DelayLayerWith`].
+    #[inline]
+    pub fn new(delay: Duration, predicate: P) -> Self {
+        Self { delay, predicate }
+    }
+}
+
+impl<P, S> Layer<S> for DelayLayerWith<P>
+where
+    P: Clone,
+{
+    type Service = DelayWith<S, P>;
+
+    #[inline]
+    fn layer(&self, inner: S) -> Self::Service {
+        DelayWith::new(inner, self.delay, self.predicate.clone())
+    }
+}
+
+// ===== impl JitterDelayLayer =====
+
+impl JitterDelayLayer {
+    /// Create a new [`JitterDelayLayer`] with the given base delay and jitter percentage.
+    ///
+    /// # Arguments
+    /// * `base` - The base delay duration
+    /// * `pct` - The jitter percentage (0.0 to 1.0), representing ±pct deviation
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use std::time::Duration;
+    /// use wreq_util::middleware::delay::JitterDelayLayer;
+    ///
+    /// // Creates delays in range [800ms, 1200ms]
+    /// let layer = JitterDelayLayer::new(Duration::from_secs(1), 0.2);
+    /// ```
+    #[inline]
+    pub fn new(base: Duration, pct: f64) -> Self {
+        Self {
+            base,
+            pct: pct.clamp(0.0, 1.0),
+        }
+    }
+
+    /// Apply jitter delay only to requests that satisfy a predicate.
+    ///
+    /// Requests that don't match the predicate will pass through without delay.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use std::time::Duration;
+    /// use http::Request;
+    /// use wreq_util::middleware::delay::JitterDelayLayer;
+    ///
+    /// // Only delay requests to paths starting with "/slow"
+    /// let layer = JitterDelayLayer::new(Duration::from_secs(1), 0.2)
+    ///     .when(|req: &Request<_>| req.uri().path().starts_with("/slow"));
+    /// ```
+    pub fn when<P, Req>(self, predicate: P) -> JitterDelayLayerWith<P>
+    where
+        P: Fn(&Req) -> bool + Clone,
+    {
+        JitterDelayLayerWith::new(self.base, self.pct, predicate)
+    }
+}
+
+impl<S> Layer<S> for JitterDelayLayer {
+    type Service = JitterDelay<S>;
+
+    #[inline]
+    fn layer(&self, inner: S) -> Self::Service {
+        JitterDelay::new(inner, self.base, self.pct)
+    }
+}
+
+// ===== impl JitterDelayLayerWith =====
+
+impl<P> JitterDelayLayerWith<P> {
+    /// Creates a new [`JitterDelayLayerWith`].
+    #[inline]
+    pub fn new(base: Duration, pct: f64, predicate: P) -> Self {
+        Self {
+            base,
+            pct: pct.clamp(0.0, 1.0),
+            predicate,
+        }
+    }
+}
+
+impl<P, S> Layer<S> for JitterDelayLayerWith<P>
+where
+    P: Clone,
+{
+    type Service = JitterDelayWith<S, P>;
+
+    #[inline]
+    fn layer(&self, inner: S) -> Self::Service {
+        JitterDelayWith::new(inner, self.base, self.pct, self.predicate.clone())
+    }
+}

data/crates/wreq-util/src/tower/delay/service.rs

@@ -0,0 +1,190 @@
+use std::{
+    task::{Context, Poll},
+    time::Duration,
+};
+
+use tower::{BoxError, Service};
+
+use super::{future::ResponseFuture, jittered_duration};
+
+/// A Tower [`Service`] that introduces a fixed delay before each request.
+#[derive(Debug, Clone)]
+pub struct Delay<S> {
+    inner: S,
+    delay: Duration,
+}
+
+/// A Tower [`Service`] that conditionally applies fixed delay based on a predicate.
+///
+/// Requests that match the predicate will have the delay applied;
+/// other requests pass through immediately.
+#[derive(Clone, Debug)]
+pub struct DelayWith<S, P> {
+    inner: Delay<S>,
+    predicate: P,
+}
+
+/// A Tower [`Service`] that applies jittered delay to requests.
+///
+/// This service wraps an inner service and introduces a random delay
+/// (within a configured range) before each request.
+#[derive(Clone, Debug)]
+pub struct JitterDelay<S> {
+    inner: S,
+    base: Duration,
+    pct: f64,
+}
+
+/// A Tower [`Service`] that conditionally applies jittered delay based on a predicate.
+///
+/// Requests that match the predicate will have a jittered delay applied;
+/// other requests pass through immediately.
+#[derive(Clone, Debug)]
+pub struct JitterDelayWith<S, P> {
+    inner: JitterDelay<S>,
+    predicate: P,
+}
+
+// ===== impl Delay =====
+
+impl<S> Delay<S> {
+    /// Create a new [`Delay`] service wrapping the given inner service
+    #[inline]
+    pub fn new(inner: S, delay: Duration) -> Self {
+        Delay { inner, delay }
+    }
+}
+
+impl<S, Request> Service<Request> for Delay<S>
+where
+    S: Service<Request>,
+    S::Error: Into<BoxError>,
+{
+    type Response = S::Response;
+    type Error = BoxError;
+    type Future = ResponseFuture<S::Future>;
+
+    #[inline]
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx).map_err(Into::into)
+    }
+
+    fn call(&mut self, req: Request) -> Self::Future {
+        let response = self.inner.call(req);
+        let sleep = tokio::time::sleep(self.delay);
+        ResponseFuture::new(response, sleep)
+    }
+}
+
+// ===== impl DelayWith =====
+
+impl<S, P> DelayWith<S, P> {
+    /// Creates a new [`DelayWith`].
+    #[inline]
+    pub fn new(inner: S, delay: Duration, predicate: P) -> Self {
+        Self {
+            inner: Delay::new(inner, delay),
+            predicate,
+        }
+    }
+}
+
+impl<S, Req, P> Service<Req> for DelayWith<S, P>
+where
+    S: Service<Req>,
+    S::Error: Into<BoxError>,
+    P: Fn(&Req) -> bool,
+{
+    type Response = S::Response;
+    type Error = BoxError;
+    type Future = ResponseFuture<S::Future>;
+
+    #[inline]
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx).map_err(Into::into)
+    }
+
+    fn call(&mut self, req: Req) -> Self::Future {
+        if !(self.predicate)(&req) {
+            self.inner.delay = Duration::ZERO;
+        }
+        self.inner.call(req)
+    }
+}
+
+// ===== impl JitterDelay =====
+
+impl<S> JitterDelay<S> {
+    /// Creates a new [`JitterDelay`].
+    #[inline]
+    pub fn new(inner: S, base: Duration, pct: f64) -> Self {
+        Self {
+            inner,
+            base,
+            pct: pct.clamp(0.0, 1.0),
+        }
+    }
+}
+
+impl<S, Req> Service<Req> for JitterDelay<S>
+where
+    S: Service<Req>,
+    S::Error: Into<BoxError>,
+{
+    type Response = S::Response;
+    type Error = BoxError;
+    type Future = ResponseFuture<S::Future>;
+
+    #[inline]
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx).map_err(Into::into)
+    }
+
+    fn call(&mut self, req: Req) -> Self::Future {
+        let delay = jittered_duration(self.base, self.pct);
+        let sleep = tokio::time::sleep(delay);
+        let fut = self.inner.call(req);
+        ResponseFuture::new(fut, sleep)
+    }
+}
+
+// ===== impl JitterDelayWith =====
+
+impl<S, P> JitterDelayWith<S, P> {
+    /// Creates a new [`JitterDelayWith`].
+    #[inline]
+    pub fn new(inner: S, base: Duration, pct: f64, predicate: P) -> Self {
+        Self {
+            inner: JitterDelay::new(inner, base, pct),
+            predicate,
+        }
+    }
+}
+
+impl<S, Req, P> Service<Req> for JitterDelayWith<S, P>
+where
+    S: Service<Req>,
+    S::Error: Into<BoxError>,
+    P: Fn(&Req) -> bool,
+{
+    type Response = S::Response;
+    type Error = BoxError;
+    type Future = ResponseFuture<S::Future>;
+
+    #[inline]
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx).map_err(Into::into)
+    }
+
+    fn call(&mut self, req: Req) -> Self::Future {
+        let delay = if (self.predicate)(&req) {
+            jittered_duration(self.inner.base, self.inner.pct)
+        } else {
+            Duration::ZERO
+        };
+
+        let sleep = tokio::time::sleep(delay);
+        let fut = self.inner.inner.call(req);
+        ResponseFuture::new(fut, sleep)
+    }
+}

data/crates/wreq-util/src/tower/delay.rs

@@ -0,0 +1,98 @@
+//! Request delay middleware.
+//!
+//! Adds configurable delays before HTTP requests — useful for rate limiting,
+//! testing under slow network conditions, or just being polite to APIs.
+//!
+//! # Quick Start
+//!
+//! Fixed 1-second delay:
+//!
+//! ```no_run
+//! use std::time::Duration;
+//! use wreq::Client;
+//! use wreq_util::middleware::delay::DelayLayer;
+//!
+//! let client = Client::builder()
+//!     .layer(DelayLayer::new(Duration::from_secs(1)))
+//!     .build()?;
+//! # Ok::<(), wreq::Error>(())
+//! ```
+//!
+//! Random jitter (0.8s ~ 1.2s):
+//!
+//! ```no_run
+//! use std::time::Duration;
+//! use wreq::Client;
+//! use wreq_util::middleware::delay::JitterDelayLayer;
+//!
+//! let client = Client::builder()
+//!     .layer(JitterDelayLayer::new(Duration::from_secs(1), 0.2))
+//!     .build()?;
+//! # Ok::<(), wreq::Error>(())
+//! ```
+//!
+//! # Conditional Delays
+//!
+//! Use `.when()` to apply delays only to matching requests:
+//!
+//! ```ignore
+//! // Only delay POST requests
+//! DelayLayer::new(Duration::from_secs(1))
+//!     .when(|req: &http::Request<_>| req.method() == http::Method::POST)
+//!
+//! // Jitter on specific paths
+//! JitterDelayLayer::new(Duration::from_millis(500), 0.3)
+//!     .when(|req: &http::Request<_>| req.uri().path().starts_with("/api"))
+//! ```
+//!
+//! # Notes
+//!
+//! - Delays are async and won't block the runtime
+//! - Not a substitute for proper rate limiters — servers can still see timing patterns
+//! - Keep delays short in hot paths
+
+mod future;
+mod layer;
+mod service;
+
+use std::time::Duration;
+
+pub use self::{
+    future::ResponseFuture,
+    layer::{DelayLayer, DelayLayerWith, JitterDelayLayer, JitterDelayLayerWith},
+    service::{Delay, DelayWith, JitterDelay, JitterDelayWith},
+};
+
+/// Compute a randomized duration in `[base * (1 - pct), base * (1 + pct)]`.
+fn jittered_duration(base: Duration, pct: f64) -> Duration {
+    let jitter = base.mul_f64(pct);
+    let low = base.saturating_sub(jitter);
+    let high = base.saturating_add(jitter);
+
+    if low >= high {
+        return base;
+    }
+
+    // Generate pseudo-random value using multiple entropy sources
+    let time_entropy = {
+        use std::time::SystemTime;
+        SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .map(|d| d.as_nanos() as u64)
+            .unwrap_or(0)
+    };
+
+    // Use stack address as additional entropy source
+    let addr_entropy = (&time_entropy as *const u64 as u64).wrapping_mul(0x517cc1b727220a95);
+
+    // Mix entropy sources with a simple but effective hash
+    let mixed = time_entropy
+        .wrapping_add(addr_entropy)
+        .wrapping_mul(0x9e3779b97f4a7c15);
+
+    // Convert to fraction in [0, 1)
+    let frac = (mixed as f64) / (u64::MAX as f64);
+
+    let span = (high - low).as_secs_f64();
+    low + Duration::from_secs_f64(span * frac)
+}

data/crates/wreq-util/src/tower.rs

@@ -0,0 +1,7 @@
+//! Tower middleware helpers for `wreq`.
+//!
+//! Modules here are feature-gated. Enable the feature to make the tower middleware
+//! available and to include its docs.
+
+#[cfg(feature = "tower-delay")]
+pub mod delay;

data/crates/wreq-util/tests/client.rs

@@ -0,0 +1,51 @@
+#![cfg(not(target_arch = "wasm32"))]
+mod support;
+
+use support::server;
+use wreq::Client;
+use wreq_util::{Emulation, Platform};
+
+#[tokio::test]
+async fn test_client_emulation_device() {
+    let server = server::http(move |req| async move {
+        for (name, value) in req.headers() {
+            if name == "user-agent" {
+                assert_eq!(
+                    value,
+                    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36"
+                );
+            }
+            if name == "sec-ch-ua" {
+                assert_eq!(
+                    value,
+                    r#""Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133""#
+                );
+            }
+            if name == "sec-ch-ua-mobile" {
+                assert_eq!(value, "?0");
+            }
+            if name == "sec-ch-ua-platform" {
+                assert_eq!(value, "\"Linux\"");
+            }
+        }
+        http::Response::default()
+    });
+
+    let url = format!("http://{}/ua", server.addr());
+    let res = Client::builder()
+        .emulation(
+            Emulation::builder()
+                .profile(Emulation::Chrome133)
+                .platform(Platform::Linux)
+                .http2(true)
+                .build(),
+        )
+        .build()
+        .expect("Unable to build client")
+        .get(&url)
+        .send()
+        .await
+        .expect("request");
+
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+}