Struct Diff 

pub struct Diff<Inner = PipeHandle> {
    pub left: Inner,
    pub right: Inner,
    pub replay_cap_bytes: usize,
}

fan-out → fan-in diff. send the same Request through left and right, collect both responses, emit a single JSON diff describing where they disagree. used to A/B two implementations against the same input — record once, run both, see which bytes diverged.

the request body is teed (via the existing backpressure-aware tee) so both branches see identical input bytes. each branch consumes the body to completion before its response body is collected. fan-out diff between two inners. Generic over the inner handle: Diff<PipeHandle> impls Handler; Diff<ThreadLocalPipeHandle> impls ThreadLocalHandler. Both branches must share handle type because the resulting future is one Send-ness.

Fields

left: Inner

right: Inner

replay_cap_bytes: usize

Implementations

impl<Inner> Diff<Inner>

pub fn new(left: Inner, right: Inner) -> Self

pub fn with_replay_cap_bytes(self, cap: usize) -> Self

Trait Implementations

impl Pipe for Diff<ThreadLocalPipeHandle>

type In = Request<Bytes>

Input the pipe consumes.

type Out = Response<Bytes>

Output the pipe produces.

type Err = ProximaError

Error the pipe can fail with. Debug + 'static; Send is added only on the cross-core SendPipe form.

fn call( &self, request: Request<Bytes>, ) -> impl Future<Output = Result<Response<Bytes>, ProximaError>>

Apply the pipe. The returned future is NOT required to be Send.

impl<Inner> SendPipe for Diff<Inner>

where Inner: Handler + Clone,

type In = Request<Bytes>

Input the pipe consumes.

type Out = Response<Bytes>

Output the pipe produces.

type Err = ProximaError

Error the pipe can fail with — Send here so it can cross cores.

fn call( &self, request: Request<Bytes>, ) -> impl Future<Output = Result<Response<Bytes>, ProximaError>> + Send

Apply the pipe. The returned future IS Send.