Struct GrpcErrorsAsFailures

struct GrpcErrorsAsFailures { ... }

Response classifier for gRPC responses.

gRPC doesn't use normal HTTP statuses for indicating success or failure but instead a special header that might appear in a trailer.

Responses are considered successful if

All others are considered failures.

Implementations

impl GrpcErrorsAsFailures

fn new() -> Self

Create a new GrpcErrorsAsFailures.

fn with_success(self: Self, code: GrpcCode) -> Self

Change which gRPC codes are considered success.

Defaults to only considering Ok as success.

Ok will always be considered a success.

Example

Servers might not want to consider Invalid Argument or Not Found as failures since thats likely the clients fault:

use tower_http::classify::{GrpcErrorsAsFailures, GrpcCode};

let classifier = GrpcErrorsAsFailures::new()
    .with_success(GrpcCode::InvalidArgument)
    .with_success(GrpcCode::NotFound);

fn make_classifier() -> SharedClassifier<Self>

Returns a MakeClassifier that produces GrpcErrorsAsFailures.

This is a convenience function that simply calls SharedClassifier::new.

impl ClassifyResponse for GrpcErrorsAsFailures

fn classify_response<B>(self: Self, res: &Response<B>) -> ClassifiedResponse<<Self as >::FailureClass, <Self as >::ClassifyEos>
fn classify_error<E>(self: Self, error: &E) -> <Self as >::FailureClass
where
    E: Display + 'static

impl Clone for GrpcErrorsAsFailures

fn clone(self: &Self) -> GrpcErrorsAsFailures

impl Debug for GrpcErrorsAsFailures

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

impl Default for GrpcErrorsAsFailures

fn default() -> Self

impl Freeze for GrpcErrorsAsFailures

impl RefUnwindSafe for GrpcErrorsAsFailures

impl Send for GrpcErrorsAsFailures

impl Sync for GrpcErrorsAsFailures

impl Unpin for GrpcErrorsAsFailures

impl UnsafeUnpin for GrpcErrorsAsFailures

impl UnwindSafe for GrpcErrorsAsFailures

impl<T> Any for GrpcErrorsAsFailures

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for GrpcErrorsAsFailures

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

impl<T> BorrowMut for GrpcErrorsAsFailures

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

impl<T> CloneToUninit for GrpcErrorsAsFailures

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for GrpcErrorsAsFailures

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for GrpcErrorsAsFailures

impl<T> PolicyExt for GrpcErrorsAsFailures

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> ToOwned for GrpcErrorsAsFailures

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

impl<T> WithSubscriber for GrpcErrorsAsFailures

impl<T, U> Into for GrpcErrorsAsFailures

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 GrpcErrorsAsFailures

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

impl<T, U> TryInto for GrpcErrorsAsFailures

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