Zipkin JS

To instrument a gRPC client for Zipkin tracing, use the zipkin-instrumentation-grpc-client library to create a gRPC interceptor. This interceptor requires a Zipkin Tracer instance and the name of the remote service you are calling (remoteServiceName).

When making a gRPC call, pass the interceptor in the interceptors array within the call options object.

const grpc = require('grpc');
const {Tracer, ExplicitContext, ConsoleRecorder} = require('zipkin');
const grpcInstrumentation = require('zipkin-instrumentation-grpc-client');

// 1. Setup Zipkin tracer
const ctxImpl = new ExplicitContext();
const recorder = new ConsoleRecorder();
const localServiceName = 'service-a';
const tracer = new Tracer({ctxImpl, recorder, localServiceName});

// 2. Setup gRPC client (example setup)
// ... (load proto and create client) ...
const client = new weather.WeatherService('localhost:50051', grpc.credentials.createInsecure());

// 3. Create the interceptor
const remoteServiceName = 'weather-service';
const interceptor = grpcInstrumentation(grpc, {tracer, remoteServiceName});

// 4. Use the interceptor in a call
client.getTemperature({ location: 'Tahoe'}, { interceptors: [interceptor] }, (error, response) => {
    console.info(`temprature in Tahoe is: ${response.temperature} `);
});

To add Zipkin tracing to the request library, use wrapRequest from zipkin-instrumentation-request. This function wraps the standard request module and requires a Zipkin Tracer instance and a remoteServiceName string. The wrapped function behaves identically to the original request function but automatically handles trace propagation and span creation for outgoing requests.

const express = require('express');
const {Tracer, ExplicitContext, ConsoleRecorder} = require('zipkin');
const wrapRequest = require('zipkin-instrumentation-request');
const request = require('request');

const ctxImpl = new ExplicitContext();
const recorder = new ConsoleRecorder();
const localServiceName = 'service-a'; // name of this application
const tracer = new Tracer({ctxImpl, recorder, localServiceName});

const remoteServiceName = 'weather-api';
const zipkinRequest = wrapRequest(request, {tracer, remoteServiceName});

zipkinRequest({
    url: 'http://api.weather.com',
    method: 'GET',
  }, function(error, response, body) {
    console.log('error:', error);
    console.log('statusCode:', response && response.statusCode);
    console.log('body:', body);
  });

Use the wrapAxios function to wrap either the global axios module or a specific axios instance. The resulting zipkinAxios object retains all original axios types, functions, and attributes, allowing it to be used interchangeably with the standard axios API.

To instrument, provide an options object containing:

• tracer: An instance of a Zipkin Tracer.
• remoteServiceName (optional): The name of the remote application being called.

const axios = require('axios');
const wrapAxios = require('zipkin-instrumentation-axiosjs');
const { Tracer, ExplicitContext, ConsoleRecorder } = require('zipkin');

const ctxImpl = new ExplicitContext();
const recorder = new ConsoleRecorder();
const localServiceName = 'service-a';
const tracer = new Tracer({ ctxImpl, recorder, localServiceName });

const remoteServiceName = 'weather-api';
const zipkinAxios = wrapAxios(axios, { tracer, remoteServiceName });

// Use it just like axios
zipkinAxios.get('/user?ID=12345')
  .then(function (response) {
    console.log(response);
  })
  .catch(function (error) {
    console.log(error);
  });

To start tracing, instantiate a zipkin.Tracer. The tracer requires a context implementation (ctxImpl), a recorder to send spans, a sampler to determine the sampling rate, and a localServiceName to identify your service in the trace graph.

Common configuration options:

• ctxImpl: The in-process context implementation (e.g., zipkin-context-cls for Node.js or zipkin.ExplicitContext for manual passing).
• recorder: An implementation that handles sending spans (e.g., zipkin.ConsoleRecorder for debugging).
• sampler: A strategy to decide which requests to trace (e.g., zipkin.sampler.CountingSampler).
• traceId128Bit: Boolean; set to true to use 128-bit trace IDs instead of the default 64-bit.

const zipkin = require('zipkin');
const CLSContext = require('zipkin-context-cls');
const ctxImpl = new CLSContext();

const tracer = new zipkin.Tracer({
  ctxImpl,
  recorder: new zipkin.ConsoleRecorder(),
  sampler: new zipkin.sampler.CountingSampler(0.01),
  traceId128Bit: true,
  localServiceName: 'my-service'
});

To add Zipkin tracing to your memcached client, use zipkin-instrumentation-memcached. This library wraps the standard memcached client and requires a Zipkin Tracer instance.

To use it, pass your tracer and the Memcached constructor to the zipkin-instrumentation-memcached function. This returns a wrapped constructor that you can use to instantiate your client as usual.

const {Tracer} = require('zipkin');
const Memcached = require('memcached');
const zipkinClient = require('zipkin-instrumentation-memcached');

const localServiceName = 'service-a'; // name of this application
const tracer = new Tracer({ctxImpl, recorder, localServiceName});

const connectionString = 'localhost:11211';
const options = {timeout: 1000};

// Wrap the Memcached constructor with the tracer
const memcached = new (zipkinClient(tracer, Memcached))(connectionString, options);

// Your application code here
memcached.get('foo', (err, data) => {
  console.log('got', data.foo);
});