Tracing#

This is a tracing library based on the Dapper work by Google. It is also similar to Twitter’s Zipkin and HTrace from Cloudera which were also inspired by the Dapper work.

Tracing is different from simply recording metrics about a service or logging text strings to a log file. Tracing is intended to capture information about the units of work that are being performed, how they relate to one another, and how long the pieces of the units of work take to execute.

Each unit of work at the top level is captured by a trace which consists of a tree of spans (<span>). Each unit of work is tracked by a span in the tree.

Each span can have key/value data associated with it via either trace-add-data or span-add-data. This data typically represents data associated with the computation or action. Examples might include the user name making a request, the SQL being executed, the table being queried, or the IP address associated with a request.

Each span can also have timestamped annotations provided via either trace-annotate or span-annotate. This associates a text description of an event with a timestamp and the span. This might be used to indicate progress through a task, unusual events, or anything interesting.

Other important details are discussed below, such as Writers and Sampling.

Instrumenting Your Code#

Instrumenting your code with tracing should be pretty easy.

At application startup, call trace-set-host with a string identifier that is unique among the machines running the software.

To start tracing, either call trace-push and trace-pop or use with-tracing:

with-tracing ("http-request")
  trace-add-data("client-ip-address", ...);
  trace-add-data("requested-path", ...);

  ... do work ...
end;

Setting up Sampling#

Sampling of traces is left up to the application. A few basic primitives are supplied in always-sample, never-sample, if-tracing-sample, and related functions. See Sampling for more information.

The TRACING-CORE module#

Tracing#

The tracing functions in this section represent the high level interface to the tracing library and are what would typically be used, rather than the span-specific functions.

There may be times though when using the lower level, span-specific functions is appropriate, such as when you have multiple units of work executing asynchronously. The asynchronous tasks may find it easier to track their own spans separately.

trace-push Function#
Signature:

trace-push (description #key sampler) => (span?)

Parameters:
Values:

  • span? – An instance of false-or(<span>).

Discussion:

Create a new <span> and make it the current tracing span. If there is already a span, the new span will use the existing span as the parent.

sampler defaults to if-tracing-sample.

See also:

trace-add-data Function#
Signature:

trace-add-data (key data) => ()

Parameters:
Discussion:

Adds key / value data to the current trace span (if any), using span-add-data.

See also:

trace-annotate Function#
Signature:

trace-annotate (description) => ()

Parameters:

  • description – An instance of <string>.

Discussion:

Adds an annotation to the current trace span (if any), using span-annotate.

See also:

trace-pop Function#
Signature:

trace-pop (span?) => ()

Parameters:

  • span? – An instance of false-or(<span>).

Discussion:

Stops the current span and pops it from the stack, returning the previous span to the current slot.

See also:

trace-set-host Function#

Sets the global host identifier that will be set on all spans created by this process.

Signature:

trace-set-host (host) => ()

Parameters:
Discussion:

Sets the global host identifier that will be set on all spans created by this process.

This may just be a hostname, but if multiple processes are running on the same host, then it should include additional identifying data. Ideally, this identifier will be unique per process within a cluster in a distributed system.

Note

This function should be called early in the application startup, before any tracing is performed.

See also:

with-tracing Macro#
Macro Call:

with-tracing ("Span description")
  trace-add-data("Table", "users");
  ...
end with-tracing;

with-tracing ("Span description", sampler: never-sample)
  ...
end with-tracing;

Discussion:

The with-tracing macro simplifies the process of calling trace-push and trace-pop. It can also take any keywords that trace-push takes and will pass them along.

Spans#

<span> Class#
Superclasses:

<object>

Init-Keywords:

  • description –

  • parent-id –

  • trace-id –

Discussion:

A span tracks a period of time associated with a computation or action, along with annotations and key / value data. Spans exist within a tree of spans all of which share the same trace-id.

span-add-data Generic function#
Signature:

span-add-data (span key data) => ()

Parameters:
Discussion:

Key / value pairs may be stored on a span to provide better context. This might include the query being executed, address or host information or whatever is relevant to the application being traced.

See also:

span-annotate Generic function#
Signature:

span-annotate (span description) => ()

Parameters:

  • span – An instance of <span>.

  • description – An instance of <string>.

Discussion:

Annotations are to record an occurrence of an event during a span. They have a specific timestamp associated with them that is automatically set to the time when the annotation is created.

See also:

span-annotations Generic function#

Returns the collection of <span-annotation> associated with this span.

Signature:

span-annotations (span) => (annotations)

Parameters:

  • span – An instance of <span>.

Values:

  • annotations – An instance of <vector>.

See also:

span-data Generic function#

Returns the property list of data associated with this span.

Signature:

span-data (span) => (data)

Parameters:

  • span – An instance of <span>.

Values:
See also:

span-description Generic function#

Returns the description of the span.

Signature:

span-description (span) => (description)

Parameters:

  • span – An instance of <span>.

Values:

  • description – An instance of <string>.

span-duration Generic function#
Signature:

span-duration (span) => (time?)

Parameters:

  • span – An instance of <span>.

Values:

  • time? – An instance of false-or(<duration>).

Discussion:

If the span has not yet been stopped, this returns #f. Once the span has been stopped, the duration that the span was running will be returned.

See also:

span-host Generic function#

Returns the host identifier for the process which created this span.

Signature:

span-host (span) => (host)

Parameters:

  • span – An instance of <span>.

Values:
span-id Generic function#

Returns the unique ID associated with this span.

Signature:

span-id (span) => (id)

Parameters:

  • span – An instance of <span>.

Values:

  • id – An instance of <object>.

span-parent-id Generic function#
Signature:

span-parent-id (span) => (id)

Parameters:

  • span – An instance of <span>.

Values:

  • id – An instance of <object>.

span-process-id Generic function#
Signature:

span-process-id (span) => (process-id)

Parameters:

  • span – An instance of <span>.

Values:
span-start-time Generic function#

Returns the time that the span was created.

Signature:

span-start-time (span) => (timestamp)

Parameters:

  • span – An instance of <span>.

Values:

Like other time values in Dylan, this is the time since January 1, 1900.

See also:

span-stop Generic function#

Stops a span and sends it to the current registered <span-writer> instances.

Signature:

span-stop (span) => ()

Parameters:

  • span – An instance of <span>.

See also:

span-stopped? Generic function#

Has the span been stopped yet?

Signature:

span-stopped? (span) => (stopped?)

Parameters:

  • span – An instance of <span>.

Values:
See also:

span-thread-id Generic function#
Signature:

span-thread-id (span) => (thread-id)

Parameters:

  • span – An instance of <span>.

Values:
span-trace-id Generic function#

Return the trace-id for a span.

Signature:

span-trace-id (span) => (id)

Parameters:

  • span – An instance of <span>.

Values:

  • id – An instance of <object>.

Discussion:

Returns the trace-id for a span. This ID is the same for all spans within a single trace.

Annotations#

Annotations let you attach events that happened at a point in time (noted by a timestamp) to a span.

<span-annotation> Class#
Superclasses:

<object>

Init-Keywords:

  • description –

  • timestamp –

annotation-description Generic function#

Return the description of an annotation.

Signature:

annotation-description (annotation) => (description)

Parameters:
Values:

  • description – An instance of <string>.

annotation-timestamp Generic function#

Return the timestamp at which the annotation was created and attached.

Signature:

annotation-timestamp (annotation) => (timestamp)

Parameters:
Values:

Sampling#

Samplers allow for collecting a subset of the data, making the usage of this tracing framework in a heavily loaded production scenario more realistic.

Samplers are simply functions that return a boolean value indicating whether or not an actual trace should be generated and recorded. They should be called at the appropriate point within the application being traced. Some applications may wish to limit which traces or parts of traces are collected in ways that are not readily representable within this framework.

always-sample Function#

Always returns true, so that the trace is sampled.

Signature:

always-sample () => #t

Values:

  • record-sample? – Always #t.

if-tracing-sample Function#

Returns true if tracing is enabled, otherwise #f.

Signature:

if-tracing-sample () => (record-sample?)

Values:

  • record-sample? – An instance of <boolean>.

See also:

never-sample Function#

Always returns false, so that the trace isn’t sampled.

Signature:

never-sample () => #f

Values:

  • record-sample? – Always #f.

disable-tracing Function#
Signature:

disable-tracing () => ()

Discussion:

This function only modifies the return value of if-tracing-sample and does not globally disable tracing.

See also:

enable-tracing Function#
Signature:

enable-tracing () => ()

Discussion:

This function only modifies the return value of if-tracing-sample and does not globally enable tracing.

See also:

Writers#

Spans are stored by using instances of <span-writer> which have been registered using register-span-writer. Spans are stored when they are stopped (trace-pop, span-stop). Spans are also stored when they are finalized without having been stopped previously. This finalization is only present to prevent data from being lost and should not be a default mode of operation.

<span-writer> Class#
Superclasses:

<object>

See also:

register-span-writer Function#
Signature:

register-span-writer (span-writer) => ()

Parameters:
See also:

registered-span-writers Function#
Signature:

registered-span-writers () => (span-writers)

Values:

  • span-writers – An instance of <span-writer-vector>.

See also:

store-span Function#
Signature:

store-span (span) => ()

Parameters:

  • span – An instance of <span>.

See also:

unregister-span-writer Function#
Signature:

unregister-span-writer (span-writer) => ()

Parameters:
See also:

Writer Implementation#

To add a new storage class, subclass <span-writer> and implement the span-writer-add-span method. Then, call register-span-writer with an instance of your span writer and all subsequent spans completed will be written to it.

span-writer-add-span Generic function#
Signature:

span-writer-add-span (span span-writer) => ()

Parameters:
Discussion:

This method is specialized for each subclass of <span-writer>. It is called whenever a span needs to be processed by a span writer.

Time Utilities#

<duration> Class#

Measure of time elapsed.

Superclasses:

<object>

Init-Keywords:

  • microseconds –

  • seconds –

See also:

duration-microseconds Generic function#
Signature:

duration-microseconds (duration) => (microseconds)

Parameters:
Values:
See also:

duration-seconds Generic function#
Signature:

duration-seconds (duration) => (seconds)

Parameters:
Values:
See also:

<timestamp> Class#

A point in time.

Superclasses:

<object>

Init-Keywords:

  • microseconds –

  • seconds –

See also:

timestamp-days Generic function#
Signature:

timestamp-days (timestamp) => (days)

Parameters:
Values:
See also:

timestamp-microseconds Generic function#
Signature:

timestamp-microseconds (timestamp) => (microseconds)

Parameters:
Values:
See also:

timestamp-seconds Generic function#
Signature:

timestamp-seconds (timestamp) => (seconds)

Parameters:
Values:
See also:

Tags#

These constants are available to help standardize tracing across applications.

$tag/peer/host-name Constant#
$tag/peer/ip Constant#
$tag/peer/port Constant#
$tag/http/uri Constant#
$tag/http/response/size Constant#
$tag/http/status Constant#

Miscellaneous#

get-unique-id Function#
Signature:

get-unique-id () => (id)

Values:

  • id – An instance of <unique-id>.