Struct StatusInRangeAsFailures

pub struct StatusInRangeAsFailures { /* private fields */ }

Response classifier that considers responses with a status code within some range to be failures.

Example

A client with tracing where server errors and client errors are considered failures.

use tower_http::{trace::TraceLayer, classify::StatusInRangeAsFailures};
use tower::{ServiceBuilder, Service, ServiceExt};
use http::{Request, Method};
use http_body_util::Full;
use bytes::Bytes;
use hyper_util::{rt::TokioExecutor, client::legacy::Client};

let classifier = StatusInRangeAsFailures::new(400..=599);

let client = Client::builder(TokioExecutor::new()).build_http();
let mut client = ServiceBuilder::new()
    .layer(TraceLayer::new(classifier.into_make_classifier()))
    .service(client);

let request = Request::builder()
    .method(Method::GET)
    .uri("https://example.com")
    .body(Full::<Bytes>::default())
    .unwrap();

let response = client.ready().await?.call(request).await?;

Implementations

impl StatusInRangeAsFailures

pub fn new(range: RangeInclusive<u16>) -> Self

Creates a new StatusInRangeAsFailures.

Panics

Panics if the start or end of range aren’t valid status codes as determined by StatusCode::from_u16.

pub fn new_for_client_and_server_errors() -> Self

Creates a new StatusInRangeAsFailures that classifies client and server responses as failures.

This is a convenience for StatusInRangeAsFailures::new(400..=599).

pub fn into_make_classifier(self) -> SharedClassifier<Self>

Convert this StatusInRangeAsFailures into a MakeClassifier.

Trait Implementations

impl ClassifyResponse for StatusInRangeAsFailures

type FailureClass = StatusInRangeFailureClass

The type returned when a response is classified as a failure.

type ClassifyEos = NeverClassifyEos<<StatusInRangeAsFailures as ClassifyResponse>::FailureClass>

The type used to classify the response end of stream (EOS).

fn classify_response<B>( self, res: &Response<B>, ) -> ClassifiedResponse<Self::FailureClass, Self::ClassifyEos>

Attempt to classify the beginning of a response.

fn classify_error<E>(self, error: &E) -> Self::FailureClass

where E: Display + 'static,

Classify an error.

fn map_failure_class<F, NewClass>(self, f: F) -> MapFailureClass<Self, F>

where Self: Sized, F: FnOnce(Self::FailureClass) -> NewClass,

Transform the failure classification using a function.

impl Clone for StatusInRangeAsFailures

fn clone(&self) -> StatusInRangeAsFailures

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StatusInRangeAsFailures

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

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 6 bytes