Struct Intercept 

pub struct Intercept<In, Out, S> { /* private fields */ }

Available on crate features intercept only.

Middleware for observing and modifying service inputs and outputs.

Useful for logging, debugging, metrics, validation, and other cross-cutting concerns.

Examples

Simple usage that observes inputs and outputs without modification:

let stack = (
    Intercept::layer()
        .on_input(|input| println!("request: {input}"))
        .on_output(|output| println!("response: {output}")),
    Execute::new(|input: String| async move { input }),
);

let service = stack.into_service();
let response = service.execute("input".to_string()).await;

Advanced usage of Intercept allows you to modify and observe inputs and outputs:

let stack = (
    Intercept::<String, String, _>::layer()
        .on_input(|input| println!("request: {input}")) // input observers are called first
        .on_input(|input| println!("another: {input}")) // multiple observers supported
        .modify_input(|input| input.to_uppercase()) // then inputs are modified
        .modify_input(|input| input.to_lowercase()) // multiple modifications supported
        .on_output(|output| println!("response: {output}")) // output observers called first
        .on_output(|output| println!("another response: {output}")) // multiple observers supported
        .modify_output(|output| output.trim().to_string()) // then outputs are modified
        .modify_output(|output| format!("result: {output}")), // multiple modifications supported
    Execute::new(|input: String| async move { input }),
);

let service = stack.into_service();
let response = service.execute("input".to_string()).await;

Implementations

impl<In, Out> Intercept<In, Out, ()>

pub fn layer() -> InterceptLayer<In, Out>

Creates a new InterceptLayer for building interception middleware.

Examples

let stack = (
    Intercept::layer(), // Create a new interception layer, no observers yet
    Execute::new(|input: String| async move { input }),
);

let service = stack.into_service();
let response = service.execute("input".to_string()).await;

Trait Implementations

impl<In, Out, S: Clone> Clone for Intercept<In, Out, S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<In, Out, S: Debug> Debug for Intercept<In, Out, S>

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

Formats the value using the given formatter.

impl<In: Send, Out, S> Service<In> for Intercept<In, Out, S>

where S: Service<In, Out = Out>,

async fn execute(&self, input: In) -> Self::Out

Executes the wrapped service with interception and modification.

Execution order: input observers → input modifications → service execution → output observers → output modifications. Input modifications can short-circuit execution by returning ControlFlow::Break.

type Out = Out

The output type returned by this service.

impl<Req, Res, Err, S> Service<Req> for Intercept<Req, Result<Res, Err>, S>

where Err: Send + 'static, Req: Send + 'static, Res: Send + 'static, S: Service<Req, Response = Res, Error = Err> + Send + Sync + 'static, S::Future: Send + 'static,

Available on crate features tower-service only.

type Response = Res

Responses given by the service.

type Error = Err

Errors produced by the service.

type Future = InterceptFuture<Result<Res, Err>>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Req) -> Self::Future

Process the request and return the response asynchronously.