Trace

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply(): Tracing

Returns a Tracing instance with captured Contexts so it's cheap to reuse.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def disable(): Unit

Turn trace recording off.

def enable(): Unit

Turn trace recording on.

def enabled: Boolean

Whether or not trace recording is enabled on this process: false indicates it was shutdown either via -com.twitter.finagle.tracing.enabled flag or Trac.disable() API.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hasId: Boolean

True if there is an identifier for the current trace.

def hashCode(): Int

final def id: TraceId

Get the current trace identifier.

def idOption: Option[TraceId]

Get the current identifier, if it exists.

final def isActivelyTracing: Boolean

Return true if tracing is enabled with a good tracer pushed and at least one tracer decides to actively trace the current id.

final def isInstanceOf[T0]: Boolean

final def isTerminal: Boolean

Return true if the current trace id is terminal.

def letClear[R](f: ⇒ R): R

Run computation f with all tracing state (tracers, trace id) cleared.

def letId[R](traceId: TraceId, terminal: Boolean = false)(f: ⇒ R): R

Run computation f with the given traceId.

def letIdOption[R](traceIdOpt: Option[TraceId])(f: ⇒ R): R

A version of [com.twitter.finagle.tracing.Trace.letId] providing an optional ID.

def letTracer[R](tracer: Tracer)(f: ⇒ R): R

Run computation f with tracer added onto the tracer stack.

def letTracerAndId[R](tracer: Tracer, traceId: TraceId, terminal: Boolean = false)(f: ⇒ R): R

Run computation f with the given tracer and trace id.

def letTracerAndNextId[R](tracer: Tracer, terminal: Boolean = false)(f: ⇒ R): R

Run computation f with the given tracer, and a derivative TraceId.

final def ne(arg0: AnyRef): Boolean

final def nextId: TraceId

Create a derived id from the current TraceId.

final def notify(): Unit

final def notifyAll(): Unit

final def record(message: String): Unit

final def record(ann: Annotation, duration: Duration): Unit

final def record(ann: Annotation): Unit

final def record(rec: Record): Unit

Record a raw Record.

final def recordBinaries(annotations: Map[String, Any]): Unit

final def recordBinary(key: String, value: Any): Unit

final def recordClientAddr(ia: InetSocketAddress): Unit

final def recordClientRecv(): Unit

final def recordClientRecvError(error: String): Unit

final def recordClientRecvFragment(): Unit

final def recordClientSend(): Unit

final def recordClientSendFrargmet(): Unit

final def recordLocalAddr(ia: InetSocketAddress): Unit

final def recordRpc(name: String): Unit

final def recordServerAddr(ia: InetSocketAddress): Unit

final def recordServerRecv(): Unit

final def recordServerRecvFragment(): Unit

final def recordServerSend(): Unit

final def recordServerSendError(error: String): Unit

final def recordServerSendFragment(): Unit

final def recordServiceName(serviceName: String): Unit

final def recordWireRecv(): Unit

final def recordWireRecvError(error: String): Unit

final def recordWireSend(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def time[T](message: String)(f: ⇒ T): T

Time an operation and add a binary annotation to the current span with the duration.

def timeFuture[T](message: String)(f: Future[T]): Future[T]

Time an async operation and add a binary annotation to the current span with the duration.

def toString(): String

def traceLocal[T](name: String)(f: ⇒ T): T

Create a span that begins right before the function is called and ends immediately after the function completes.

def traceLocalFuture[T](name: String)(f: ⇒ Future[T]): Future[T]

Create a span that begins right before the function is called and ends immediately after the async operation completes.

def traceService[T](service: String, rpc: String, hostOpt: Option[InetSocketAddress] = None)(f: ⇒ T): T

Convenience method for event loops in services.

def tracers: List[Tracer]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def record(message: String, duration: Duration): Unit