impl Builder

fn scoped<impl scope::Scope: scope::Scope>(scope: impl scope::Scope) -> Self

Create a scoped retry policy.

For a more convenient constructor, see [for_host()].

fn no_budget(self: Self) -> Self

Set no retry budget.

Sets that no budget will be enforced. This could also be considered to be an infinite budget.

This is NOT recommended. Disabling the budget can make your system more susceptible to retry storms.

fn max_extra_load(self: Self, extra_percent: f32) -> Self

Sets the max extra load the budget will allow.

Think of the amount of requests your client generates, and how much load that puts on the server. This option configures as a percentage how much extra load is allowed via retries.

For example, if you send 1,000 requests per second, setting a maximum extra load value of 0.3 would allow 300 more requests per second in retries. A value of 2.5 would allow 2,500 more requests.

Panics

The extra_percent value must be within reasonable values for a percentage. This method will panic if it is less than 0.0, or greater than 1000.0.

fn max_retries_per_request(self: Self, max: u32) -> Self

Set the max retries allowed per request.

For each logical (initial) request, only retry up to max times.

This value is used in combination with a token budget that is applied to all requests. Even if the budget would allow more requests, this limit will prevent. Likewise, the budget may prevent retrying up to max times. This setting prevents a single request from consuming the entire budget.

Default is currently 2 retries.

fn classify_fn<F>(self: Self, func: F) -> Self
where
    F: Fn(classify::ReqRep<'_>) -> classify::Action + Send + Sync + 'static

Provide a classifier to determine if a request should be retried.

Example

# fn with_builder(builder: reqwest::retry::Builder) -> reqwest::retry::Builder {
builder.classify_fn(|req_rep| {
    match (req_rep.method(), req_rep.status()) {
        (&http::Method::GET, Some(http::StatusCode::SERVICE_UNAVAILABLE)) => {
            req_rep.retryable()
        },
        _ => req_rep.success()
    }
})
# }

fn classify<impl classify::Classify: classify::Classify>(self: Self, classifier: impl classify::Classify) -> Self

Provide a classifier to determine if a request should be retried.

impl Debug for Builder

fn fmt(self: &Self, f: &mut $crate::fmt::Formatter<'_>) -> $crate::fmt::Result

impl Freeze for Builder

impl RefUnwindSafe for Builder

impl Send for Builder

impl Sync for Builder

impl Unpin for Builder

impl UnwindSafe for Builder

impl<T> Any for Builder

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Builder

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Builder

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> ErasedDestructor for Builder

impl<T> From for Builder

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for Builder

impl<T> PolicyExt for Builder

fn and<P, B, E>(self: Self, other: P) -> And<T, P>
where
    T: Policy<B, E>,
    P: Policy<B, E>

fn or<P, B, E>(self: Self, other: P) -> Or<T, P>
where
    T: Policy<B, E>,
    P: Policy<B, E>

impl<T> WithSubscriber for Builder

impl<T, U> Into for Builder

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Builder

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Builder

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>