Creates a new StackClient with parameter psp._1 and Stack Param type psp._2.

Creates a new StackClient with parameter p.

Creates a new StackClient with additional parameters newParams.

Configures the number of concurrent connections a single endpoint has. The connections are load balanced over which allows the pipelined client to avoid head-of-line blocking and reduce its latency.

We've empirically found that two is a good default for this, but it can be increased at the cost of additional connection overhead.

A copy constructor in lieu of defining StackClient as a case class.

Defines the service factory, which establishes connections to a remote peer on apply and returns a service which can write messages onto the wire and read them off of the wire.

Concrete StackClient implementations are expected to specify this.

Prepends filter to the top of the client. That is, after materializing the client (newClient/newService) filter will be the first element which requests flow through. This is a familiar chaining combinator for filters and is particularly useful for StdStackClient implementations that don't expose services but instead wrap the resulting service with a rich API.

Create a new client connected to dest. See the user guide for details on destination names.

Argument label is used to assign a label to this client. The label is used to display stats, etc.

Create a new client connected to dest. See the user guide for details on destination names.

Argument label is used to assign a label to this client. The label is used to display stats, etc.

Create a new client connected to dest. See the user guide for details on destination names.

Construct a new PushTransporter with the appropriately configured pipeline.

Constructs a memcached.Client that dispatches requests over dest. When dest resolves to multiple hosts, the hosts are hashed across a ring with key affinity. The key hashing algorithm can be configured via the withKeyHasher method on Memcached.client. Failing hosts can be ejected from the hash ring if withEjectFailedHost is set to true. Note, the current implementation only supports bound Names.

Constructs a memcached.Client that dispatches requests over dest. When dest resolves to multiple hosts, the hosts are hashed across a ring with key affinity. The key hashing algorithm can be configured via the withKeyHasher method on Memcached.client. Failing hosts can be ejected from the hash ring if withEjectFailedHost is set to true. Note, the current implementation only supports bound Names.

Argument label is used to assign a label to this client. The label is used to scope stats, etc.

Create a new service which dispatches requests to dest. See the user guide for details on destination names.

Argument label is used to assign a label to this client. The label is used to display stats, etc.

Create a new service which dispatches requests to dest. See the user guide for details on destination names.

Create a new service which dispatches requests to dest. See the user guide for details on destination names.

Construct a new push session from the provided PushChannelHandle generated from the PushTransporter

Constructs a memcached.Client that dispatches requests over dest. When dest resolves to multiple hosts, the hosts are hashed across a ring with key affinity. The key hashing algorithm can be configured via the withKeyHasher method on Memcached.client. Failing hosts can be ejected from the hash ring if withEjectFailedHost is set to true. Note, the current implementation only supports bound Names.

Argument label is used to assign a label to this client. The label is used to scope stats, etc.

Constructs a memcached.Client that dispatches requests over dest. When dest resolves to multiple hosts, the hosts are hashed across a ring with key affinity. The key hashing algorithm can be configured via the withKeyHasher method on Memcached.client. Failing hosts can be ejected from the hash ring if withEjectFailedHost is set to true. Note, the current implementation only supports bound Names.

The current parameter map.

Export info about the transporter type so that we can query info about its implementation at runtime.

The current stack.

Build a Service from the provided push session

An entry point for configuring the clients' admission control

Whether to eject cache host from the Ketama ring based on failure accrual. By default, this is off. When turning on, keep the following caveat in mind: ejection is based on local failure accrual, so your cluster may get different views of the same cache host. With cache updates, this can introduce inconsistency in cache data. In many cases, it's better to eject cache host from a separate mechanism that's based on a global view.

Configures this server or client with given exception stats handler.

Configures this server or client with given label (default: empty string).

The label value is used for stats reporting to scope stats reported from different clients/servers to a single stats receiver.

Configures this server or client with given util.Monitor (default: com.twitter.finagle.util.DefaultMonitor).

Monitors are Finagle's out-of-band exception reporters. Whenever an exception is thrown on a request path, it's reported to the monitor. The default monitor implementation, com.twitter.finagle.util.DefaultMonitor, logs these exceptions.

Monitors are wired into the server or client stacks via com.twitter.finagle.filter.MonitorFilter and are appl are applied to the following kinds of exceptions:

• Synchronous exceptions thrown on request path, Service.apply(request)
• Asynchronous exceptions (failed futures) thrown on request path, Service.apply(request)
• Exceptions thrown from respond, onSuccess, onFailure future callbacks
• Fatal exceptions thrown from map, flatMap, transform future continuations

Put it this way, we apply Monitor.handle to an exception if we would otherwise "lose" it, i.e. when it's not connected to the Future, nor is it connected to the call stack.

You can compose multiple monitors if you want to extend or override the standard behavior, defined in DefaultMonitor.

import com.twitter.util.Monitor

val consoleMonitor = new Monitor {
  def handle(exc: Throwable): Boolean = {
    Console.err.println(exc.toString)
    false // continue handling with the next monitor (usually DefaultMonitor)
   }
}

$.withMonitor(consoleMonitor)

Returning true form within a monitor effectively terminates the monitor chain so no exceptions are propagated down to the next monitor.

Duplicate each node across the hash ring according to reps.

Creates a new StackClient with params used to configure this StackClient's stack.

Configures the request timeout of this server or client (default: unbounded).

If the request has not completed within the given timeout, the pending work will be interrupted via com.twitter.util.Future.raise.

Client's Request Timeout

The client request timeout is the maximum amount of time given to a single request (if there are retries, they each get a fresh request timeout). The timeout is applied only after a connection has been acquired. That is: it is applied to the interval between the dispatch of the request and the receipt of the response.

Server's Request Timeout

The server request timeout is the maximum amount of time, a server is allowed to spend handling the incoming request. Using the Finagle terminology, this is an amount of time after which a non-satisfied future returned from the user-defined service times out.

Configures the Tunable request timeout of this server or client (if applying the Tunable produces a value of None, an unbounded timeout is used for the request).

If the request has not completed within the Duration resulting from timeout.apply(), the pending work will be interrupted via com.twitter.util.Future.raise.

Client's Request Timeout

The client request timeout is the maximum amount of time given to a single request (if there are retries, they each get a fresh request timeout). The timeout is applied only after a connection has been acquired. That is: it is applied to the interval between the dispatch of the request and the receipt of the response.

Server's Request Timeout

The server request timeout is the maximum amount of time, a server is allowed to spend handling the incoming request. Using the Finagle terminology, this is an amount of time after which a non-satisfied future returned from the user-defined service times out.

Configure a com.twitter.finagle.service.ResponseClassifier which is used to determine the result of a request/response.

This allows developers to give Finagle the additional application-specific knowledge necessary in order to properly classify responses. Without this, Finagle cannot make judgements about application-level failures as it only has a narrow understanding of failures (for example: transport level, timeouts, and nacks).

As an example take an HTTP server that returns a response with a 500 status code. To Finagle this is a successful request/response. However, the application developer may want to treat all 500 status codes as failures and can do so via setting a com.twitter.finagle.service.ResponseClassifier.

ResponseClassifier is a PartialFunction and as such multiple classifiers can be composed together via PartialFunction.orElse.

Response classification is independently configured on the client and server. For client-side response classification using com.twitter.finagle.builder.ClientBuilder, see com.twitter.finagle.builder.ClientBuilder.responseClassifier

Configures the requeue backoff policy of this client (default: no delay).

The backoff policy is represented by a stream of delays (i.e., Stream[Duration]) used to delay each retry.

Configures the retry budget of this client (default: allows for about 20% of the total requests to be retried on top of 10 retries per second).

This budget is shared across requests and governs the number of retries that can be made by this client.

An entry point for configuring the client's session.

An entry point for configuring the client's session qualifiers (e.g. circuit breakers).

A new StackClient using the function to create a new Stack.

The input to fn is the client's current stack. This API allows for easier usage when writing code that uses method chaining.

This method is similar to transformed while providing easier API ergonomics for one-off Stack changes.

A new StackClient with the provided stack.

Configures this server or client with given stats.StatsReceiver (default: stats.DefaultStatsReceiver).

Configures this server or client with given tracing.Tracer (default: com.twitter.finagle.tracing.DefaultTracer).

An entry point for configuring the client's com.twitter.finagle.transport.Transport.

Transport is a Finagle abstraction over the network connection (i.e., a TCP connection).

Creates a new StackClient with f applied to stack.

This is the same as withStack.