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 zipkin
    Definition Classes
    finagle
  • package core
    Definition Classes
    zipkin
  • BinaryAnnotation
  • Endpoint
  • RawZipkinTracer
  • Sampler
  • SamplingTracer
  • Span
  • ZipkinAnnotation
  • package thrift
    Definition Classes
    zipkin
  • package thriftscala
    Definition Classes
    zipkin

package core

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

Type Members

  1. case class BinaryAnnotation(key: String, value: ByteBuffer, annotationType: AnnotationType, endpoint: Endpoint) extends Product with Serializable
  2. case class Endpoint(ipv4: Int, port: Short) extends Product with Serializable

    Endpoints describe a TCP endpoint that terminates RPC communication.

  3. abstract class RawZipkinTracer extends Tracer

    Receives the Finagle generated traces and sends them off to Zipkin

  4. class Sampler extends AnyRef

    Decide if we should sample a particular trace or not.

  5. class SamplingTracer extends Tracer

    Tracer that supports sampling.

    Tracer that supports sampling. Will pass through a subset of the records.

  6. case class Span(traceId: TraceId, _serviceName: Option[String], _name: Option[String], annotations: Seq[ZipkinAnnotation], bAnnotations: Seq[BinaryAnnotation], endpoint: Endpoint) extends Product with Serializable

    The span itself is an immutable datastructure.

    The span itself is an immutable datastructure. Mutations are done through copying & updating span references elsewhere.

    traceId

    Contains the Trace id (same for whole trace), Span id (same for just one rpc call) and parent id (links to the parent span in this trace, if None this is the root span)

    _serviceName

    The name of the service handling the RPC

    _name

    The name of the RPC method

    annotations

    A sequence of annotations made in this span

    bAnnotations

    Key-Value annotations, used to attach non timestamped data

    endpoint

    This is the local endpoint the span was created on.

  7. case class ZipkinAnnotation(timestamp: Time, value: String, endpoint: Endpoint) extends Product with Serializable

    Annotation for a span.

    Annotation for a span. An event that happened at a particular time at a particular node.

Value Members

  1. object Endpoint extends Serializable
  2. object Sampler
  3. object Span extends Serializable

Ungrouped