Packages

  • package root
    Definition Classes
    root
  • package com
    Definition Classes
    root
  • package twitter

    Start with com.twitter.finagle.

    Definition Classes
    com
  • package finagle

    Finagle is an extensible RPC system.

    Finagle is an extensible RPC system.

    Services are represented by class com.twitter.finagle.Service. Clients make use of com.twitter.finagle.Service objects while servers implement them.

    Finagle contains a number of protocol implementations; each of these implement Client and/or com.twitter.finagle.Server. For example, Finagle's HTTP implementation, com.twitter.finagle.Http (in package finagle-http), exposes both.

    Thus a simple HTTP server is built like this:

    import com.twitter.finagle.{Http, Service}
    import com.twitter.finagle.http.{Request, Response}
    import com.twitter.util.{Await, Future}
    
    val service = new Service[Request, Response] {
      def apply(req: Request): Future[Response] =
        Future.value(Response())
    }
    val server = Http.server.serve(":8080", service)
    Await.ready(server)

    We first define a service to which requests are dispatched. In this case, the service returns immediately with a HTTP 200 OK response, and with no content.

    This service is then served via the Http protocol on TCP port 8080. Finally we wait for the server to stop serving.

    We can now query our web server:

    % curl -D - localhost:8080
    HTTP/1.1 200 OK

    Building an HTTP client is also simple. (Note that type annotations are added for illustration.)

    import com.twitter.finagle.{Http, Service}
    import com.twitter.finagle.http.{Request, Response}
    import com.twitter.util.{Future, Return, Throw}
    
    val client: Service[Request, Response] = Http.client.newService("localhost:8080")
    val f: Future[Response] = client(Request()).respond {
      case Return(rep) =>
        printf("Got HTTP response %s\n", rep)
      case Throw(exc) =>
        printf("Got error %s\n", exc)
    }

    Http.client.newService("localhost:8080") constructs a new com.twitter.finagle.Service instance connected to localhost TCP port 8080. We then issue a HTTP/1.1 GET request to URI "/". The service returns a com.twitter.util.Future representing the result of the operation. We listen to this future, printing an appropriate message when the response arrives.

    The Finagle homepage contains useful documentation and resources for using Finagle.

    Definition Classes
    twitter
  • package tracing
    Definition Classes
    finagle
  • package opencensus
    Definition Classes
    tracing
  • ClientTraceContextFilter
  • LazySpan
  • ServerTraceContextFilter
  • StackClientOps
  • StackServerOps
  • TracingOps

package opencensus

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

Type Members

  1. final class ClientTraceContextFilter[Req, Resp] extends SimpleFilter[Req, Resp]

    Adds an OpenCensus trace context that will be sent to the backend server using Finagle's broadcast contexts.

    Adds an OpenCensus trace context that will be sent to the backend server using Finagle's broadcast contexts. The backend service should install a ServerTraceContextFilter to attach on to this.

    A Span is created per request and is ended when the request's Future is satisfied.

    See also

    StackClientOps for client installation instructions.

  2. sealed trait LazySpan extends AnyRef

    An OpenCensus Span that is only started when get() is called.

    An OpenCensus Span that is only started when get() is called.

    Child spans can be created by calling child(String). The first child span to be started will start the entire parent chain.

  3. final class ServerTraceContextFilter[Req, Resp] extends SimpleFilter[Req, Resp]

    Restoring an OpenCensus trace context sent by a ClientTraceContextFilter into the server's OpenCensus trace context.

    Restoring an OpenCensus trace context sent by a ClientTraceContextFilter into the server's OpenCensus trace context.

    A Span is created per request and is ended when the request's Future is satisfied.

    See also

    StackServerOps for server installation instructions.

Value Members

  1. object ClientTraceContextFilter
  2. object LazySpan
  3. object ServerTraceContextFilter
  4. object StackClientOps

    Syntax enhancements to Finagle clients to add OpenCensus tracing headers to requests.

    Syntax enhancements to Finagle clients to add OpenCensus tracing headers to requests.

    HTTP and ThriftMux protocols are supported.

    Servers should also participate by using StackServerOps.

    Example:
    1. Scala:

      import com.twitter.finagle.Http
      import com.twitter.finagle.tracing.opencensus.StackClientOps._
      
      val clientWithOpenCensusTracing = Http.client.withOpenCensusTracing

      Java users can explicitly use a StackClientOps class:

      import com.twitter.finagle.Http;
      import com.twitter.finagle.tracing.opencensus.StackClientOps.HttpOpenCensusTracing;
      
      Http.Client clientWithOpenCensusTracing =
        new HttpOpenCensusTracing(Http.client()).withOpenCensusTracing();
    See also

    StackServerOps

  5. object StackServerOps

    Syntax enhancements to Finagle servers to attach OpenCensus tracing headers from requests.

    Syntax enhancements to Finagle servers to attach OpenCensus tracing headers from requests.

    HTTP and ThriftMux protocols are supported.

    Clients should also participate by using StackClientOps.

    Example:
    1. Scala:

      import com.twitter.finagle.Http
      import com.twitter.finagle.tracing.opencensus.StackServerOps._
      
      val serverWithOpenCensusTracing = Http.server.withOpenCensusTracing

      Java users can explicitly use a StackServerOps class:

      import com.twitter.finagle.Http;
      import com.twitter.finagle.tracing.opencensus.StackServerOps.HttpOpenCensusTracing;
      
      Http.Server serverWithOpenCensusTracing =
        new HttpOpenCensusTracing(Http.server()).withOpenCensusTracing();
    See also

    StackClientOps

  6. object TracingOps

    Scala syntax extensions for OpenCensus tracing.

    Scala syntax extensions for OpenCensus tracing.

    Example:
    1. import com.twitter.finagle.tracing.opencensus.TracingOps._
      import io.opencensus.trace._
      
      // run with this Span in the current context and ends
      // it when the returned Future is satisfied
      val span: Span = ???
      span.scopedToFuture {
        // code that returns a com.twitter.util.Future
      }
      
      // run with this Span in the current context and ends
      // it when the block of code completes
      val span: Span = ???
      span.scopedAndEnd {
        // code
      }
      
      // run the given code in a newly scoped Span
      val spanBuilder: SpanBuilder = ???
      spanBuilder.runInScope {
        // code
      }

Ungrouped