opentracing

What is opentracing?

The opentracing npm package provides a standard, vendor-neutral API for distributed tracing. It allows developers to add instrumentation to their applications, which is essential for understanding the performance and behavior of complex distributed systems. The package enables the tracking of request flows across various services and systems, making it easier to diagnose and optimize performance issues.

What are opentracing's main functionalities?

Starting a new trace

This code demonstrates how to start a new trace with a span named 'my_span' and then finish the span. This is the basic building block of distributed tracing.

const opentracing = require('opentracing');
const tracer = opentracing.globalTracer();
const span = tracer.startSpan('my_span');
span.finish();

Injecting and extracting span context

This code snippet shows how to inject a span context into a carrier (e.g., HTTP headers) and then extract it. This is crucial for propagating trace context across process boundaries.

const opentracing = require('opentracing');
const tracer = opentracing.globalTracer();
const spanContext = span.context();
const carrier = {};
tracer.inject(spanContext, opentracing.FORMAT_HTTP_HEADERS, carrier);
const extractedContext = tracer.extract(opentracing.FORMAT_HTTP_HEADERS, carrier);

Setting tags and logs

This example illustrates how to set tags and logs on a span. Tags are key-value pairs that provide additional context, such as HTTP method, while logs record timed events within a span.

const opentracing = require('opentracing');
const span = opentracing.globalTracer().startSpan('my_span');
span.setTag(opentracing.Tags.HTTP_METHOD, 'GET');
span.log({ event: 'request_sent' });
span.finish();

Other packages similar to opentracing

jaeger-client

Jaeger Client is an open-source, end-to-end distributed tracing system that works with the OpenTracing API. It is similar to opentracing but is specifically designed to work with the Jaeger backend. It provides more specific implementations for trace collection and reporting.

zipkin

Zipkin is another distributed tracing system that captures timing data needed to troubleshoot latency problems in service architectures. It has a different API compared to opentracing but serves a similar purpose in tracing requests through distributed systems.

lightstep-tracer

LightStep Tracer is a distributed tracing library that implements the OpenTracing API, similar to opentracing. It is designed to integrate with LightStep's real-time analysis platform, providing more advanced features and integrations for monitoring and diagnosing distributed systems.

README

OpenTracing API for JavaScript

This library is a JavaScript implementation of Open Tracing API. It is intended for use both on the server and in the browser.

Required Reading

To fully understand this platform API, it's helpful to be familiar with the OpenTracing project and terminology more specifically.

Quick Start

Install the package using npm:

npm install --save opentracing

Example

The package contains a example using a naive MockTracer implementation. To run the example:

npm run example

The output should look something like:

Spans:
    parent_span - 1521ms
        tag 'custom':'tag value'
        tag 'alpha':'1000'
    child_span - 503ms
        tag 'alpha':'200'
        tag 'beta':'50'

Code snippet

In your JavaScript code, add instrumentation to the operations to be tracked. This is composed primarily of using "spans" around operations of interest and adding log statements to capture useful data relevant to those operations.

const http = require('http');
const opentracing = require('opentracing');

// NOTE: the default OpenTracing tracer does not record any tracing information.
// Replace this line with the tracer implementation of your choice.
const tracer = new opentracing.Tracer();

const span = tracer.startSpan('http_request');
const opts = {
    host : 'example.com',
    method: 'GET',
    port : '80',
    path: '/',
};
http.request(opts, res => {
    res.setEncoding('utf8');
    res.on('error', err => {
        // assuming no retries, mark the span as failed
        span.setTag(opentracing.Tags.ERROR, true);
        span.log({'event': 'error', 'error.object': err, 'message': err.message, 'stack': err.stack});
        span.finish();
    });
    res.on('data', chunk => {
        span.log({'event': 'data_received', 'chunk_length': chunk.length});
    });
    res.on('end', () {
        span.log({'event': 'request_end'});
        span.finish();
    });
}).end();

As noted in the source snippet, the default behavior of the opentracing package is to act as a "no op" implementation. To capture and make the tracing data actionable, the tracer object should be initialized with the OpenTracing implementation of your choice as in the pseudo-code below:

const CustomTracer = require('tracing-implementation-of-your-choice');
const tracer = new CustomTracer();

Usage in the browser

The package contains two bundles built with webpack that can be included using a standard <script> tag. The library will be exposed under the global opentracing namespace:

• dist/opentracing-browser.min.js - minified, no runtime checks
• dist/opentracing-browser.js - debug version with runtime checks

Usage with TypeScript

Since the source is written in TypeScript, if you are using TypeScript, you can just npm install the package and it will work out of the box. This is especially useful for implementators who want to typecheck their implementation with the base interface.

Global tracer

The library also provides a global singleton tracer for convenience. This can be set and accessed via the following:

opentracing.initGlobalTracer(new CustomTracer());

const tracer = opentracing.globalTracer();

Note: globalTracer() returns a wrapper on the actual tracer object. This is done for convenience of use as it ensures that the function will always return a non-null object. This can be helpful in cases where it is difficult or impossible to know precisely when initGlobalTracer is called (for example, when writing a utility library that does not control the initialization process). For more precise control, individual Tracer objects can be used instead of the global tracer.

API Documentation

There is a hosted copy of the current generated ESDoc API Documentation here.

Contributing & developer information

See the OpenTracing website for general information on contributing to OpenTracing.

The project is written in TypeScript and built using a npm scripts. Run:

• npm run build creates the compiled, distributable JavaScript code in ./lib
• npm run watch incrementally compiles on file changes
• npm run webpack creates the bundles for the browser in ./dist
• npm test runs the tests
• npm run typedoc generates the documentation in ./typedoc

OpenTracing tracer implementations

This section is intended for developers wishing to implement their own tracers. Developers who simply wish to use OpenTracing can safely ignore this information.

Custom tracer implementation

Implementations can subclass opentracing.Trace, opentracing.Span, and the other API classes to build a OpenTracing tracer and implement the underscore prefixed methods such as _addTag to pick up a bit of common code implemented in the base classes.

API compatibility testing

If mocha is being used for unit testing, test/api_compatibility can be used to test the custom tracer. The file exports a single function that expects as an argument a function that will return a new instance of the tracer.

const { apiCompatibilityChecks } = require('opentracing/lib/test/api_compatibility.js');
apiCompatibilityChecks(() => new CustomTracer());

MockTracer

An minimal example tracer is provided in the src/mock_tracer directory of the source code.