Struct AdaptiveEndpoint 

pub struct AdaptiveEndpoint<S> { /* private fields */ }

A Tower service with per-endpoint adaptive pacing and bounded admission.

poll_ready reports whether another request can enter the endpoint’s bounded scheduling horizon. call reserves a virtual GCRA slot; the returned future waits until that slot is due, waits for the inner service to be ready, and only then records the actual dispatch. Queue delay therefore never contaminates the RTT sample.

The endpoint is intentionally single-owner: Tower’s P2C balancer owns one service per discovered backend and does not require endpoint services to be cloneable. This lets readiness use the controller’s queue state directly, without a second shared allocation for coordinating cloned handles.

Implementations

impl<S> AdaptiveEndpoint<S>

pub fn new(inner: S, config: EndpointConfig) -> Self

Wraps a Tower endpoint using the current Tokio runtime time.

The returned service starts with an immediately available pacing slot.

Panics

Panics when config contains invalid controller settings.

pub fn new_at(inner: S, config: EndpointConfig, now: Instant) -> Self

Wraps a Tower endpoint using an explicit controller start time.

This constructor is useful in deterministic tests. Production code should normally use Self::new so Tokio and controller deadlines share the runtime’s clock domain.

Panics

Panics when config contains invalid controller settings.

pub fn snapshot(&self) -> ControllerSnapshot

Returns a current snapshot of this endpoint’s controller.

Reading a snapshot refreshes time-driven probe state and may update the effective pacing rate.

pub fn load_metric(&self) -> LoadMetric

Returns the endpoint’s predicted completion cost for load balancing.

Lower values are preferred. Reading the metric refreshes time-driven controller state, including probes.

Trait Implementations

impl<S> Load for AdaptiveEndpoint<S>

type Metric = LoadMetric

A comparable load metric.

fn load(&self) -> Self::Metric

Estimate the service’s current load.

impl<S, Request> Service<Request> for AdaptiveEndpoint<S>

where S: Service<Request> + Send + 'static, S::Future: Send + 'static, Request: Send + 'static,

type Response = <S as Service<Request>>::Response

Responses given by the service.

type Error = <S as Service<Request>>::Error

Errors produced by the service.

type Future = ResponseFuture<<S as Service<Request>>::Response, <S as Service<Request>>::Error>

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, request: Request) -> Self::Future

Process the request and return the response asynchronously.