feat: Add Envoy Propagator

package.json

@@ -23,7 +23,9 @@
     "eventemitter3": "1.1.1",
     "google-protobuf": "3.6.1",
     "hex2dec": "1.0.1",
+    "long": "^4.0.0",
     "opentracing": "^0.14.4",
+    "protobufjs": "^6.10.2",
     "source-map-support": "0.3.3",
     "thrift": "0.13.0"
   },

src/_leftpad.js

@@ -0,0 +1,11 @@
+// Underscore.js-like wrapper to left pad a string to a certain length with a character
+export default function _leftpad(str, len, ch) {
+    str = String(str);
+    let i = -1;
+    if (!ch && ch !== 0) ch = ' ';
+    len -= str.length;
+    while (++i < len) {
+        str = ch + str;
+    }
+    return str;
+}

src/imp/propagator_envoy.js

@@ -0,0 +1,187 @@
+import pb from 'protobufjs';
+import long from 'long';
+import _each from '../_each';
+import _leftpad from '../_leftpad';
+import SpanContextImp from './span_context_imp';
+import LightStepPropagator from './propagator_ls';
+
+const CARRIER_ENVOY_HEADER_KEY = 'x-ot-span-context';
+
+const BINARY_PROTO = {
+    nested : {
+        lightstep : {
+            options : { go_package : 'lightsteppb' },
+            nested  : {
+                BinaryCarrier : {
+                    fields : {
+                        deprecated_text_ctx : {
+                            rule : 'repeated',
+                            type : 'bytes',
+                            id   : 1,
+                        },
+                        basic_ctx : { type : 'BasicTracerCarrier', id : 2 },
+                    },
+                },
+                BasicTracerCarrier : {
+                    fields : {
+                        trace_id      : { type : 'fixed64', id : 1 },
+                        span_id       : { type : 'fixed64', id : 2 },
+                        sampled       : { type : 'bool', id : 3 },
+                        baggage_items : { keyType : 'string', type : 'string', id : 4 },
+                    },
+                },
+            },
+        },
+    },
+};
+
+
+export default class EnvoyPropagator extends LightStepPropagator {
+    constructor(tracer) {
+        super(tracer);
+        this._tracer = tracer;
+        this._envoyHeaderKey = CARRIER_ENVOY_HEADER_KEY;
+        this._carrierPb = pb.Root.fromJSON(BINARY_PROTO);
+    }
+
+    inject(spanContext, carrier) {
+        if (!carrier) {
+            this._tracer._error('Unexpected null carrier in call to inject');
+            return;
+        }
+        if (typeof carrier !== 'object') {
+            this._tracer._error(
+                `Unexpected '${typeof carrier}' FORMAT_BINARY carrier in call to inject`,
+            );
+            return;
+        }
+
+        let basicContext = {
+            span_id       : long.fromString(spanContext._guid, 16),
+            trace_id      : long.fromString(spanContext._traceGUID, 16),
+            sampled       : true,
+            baggage_items : {},
+        };
+        spanContext.forEachBaggageItem((key, value) => {
+            basicContext.baggage_items[key] = value;
+        });
+
+        let binaryCarrier = this._carrierPb.lookupType('BinaryCarrier');
+
+        let payload = {
+            basic_ctx : basicContext,
+        };
+
+        let err = binaryCarrier.verify(payload);
+        if (err) {
+            this._tracer._error(`Invalid Span Context: ${err}`);
+            return null;
+        }
+        let msg = binaryCarrier.create(payload);
+        let buffer = binaryCarrier.encode(msg).finish();
+        let bufferString = pb.util.base64.encode(buffer, 0, buffer.length);
+        carrier[this._envoyHeaderKey] = bufferString;
+
+        return carrier;
+    }
+
+    extract(carrier) {
+        // Iterate over the contents of the carrier and set the properties
+        // accordingly.
+        let foundFields = 0;
+        let spanGUID = null;
+        let traceGUID = null;
+        let sampled = true;
+
+        if (carrier[this._envoyHeaderKey] === undefined) {
+            // This is not an error per se, there was simply no SpanContext
+            // in the carrier.
+            return null;
+        }
+
+        // Decode context
+        const binaryData = Buffer.from(carrier[this._envoyHeaderKey], 'base64');
+        let binaryCarrier = this._carrierPb.lookupType('BinaryCarrier');
+        let msg = binaryCarrier.decode(binaryData);
+        let basicContext = msg.basic_ctx.toJSON();
+
+        if (basicContext === undefined) {
+            // This is not an error per se, there was simply no SpanContext
+            // in the carrier.
+            return null;
+        }
+
+        // Validate span context
+        _each(basicContext, (value, key) => {
+            key = key.toLowerCase();
+            if (key === 'baggage_items') {
+                // We will address baggage after span context is verified
+                return;
+            }
+
+            switch (key) {
+            case 'trace_id':
+                foundFields++;
+                // left pad to length of 16
+                // long is used because JS only supports up to 53 bit integers
+                traceGUID = _leftpad(
+                    long.fromValue(value).toString(16),
+                    16,
+                    '0',
+                );
+                break;
+            case 'span_id':
+                foundFields++;
+                // left pad to length of 16
+                // long is used because JS only supports up to 53 bit integers
+                spanGUID = _leftpad(
+                    long.fromValue(value).toString(16),
+                    16,
+                    '0',
+                );
+                // left pad
+
+                break;
+            case 'sampled':
+                switch (value) {
+                case 0:
+                case '0':
+                case false:
+                case 'false':
+                    sampled = false;
+                    break;
+                default:
+                    sampled = true;
+                    break;
+                }
+                break;
+            default:
+                this._tracer._error(
+                    `Unrecognized carrier key '${key}'. Ignoring.`,
+                );
+                break;
+            }
+        });
+
+        if (foundFields === 0) {
+        // This is not an error per se, there was simply no SpanContext
+        // in the carrier.
+            return null;
+        }
+        if (foundFields < 2) {
+        // A partial SpanContext suggests some sort of data corruption.
+            this._tracer._error(`Only found a partial SpanContext: ${carrier}`);
+            return null;
+        }
+
+        let spanContext = new SpanContextImp(spanGUID, traceGUID, sampled);
+
+        if (basicContext.baggage_items !== undefined) {
+            _each(basicContext.baggage_items, (value, key) => {
+                spanContext.setBaggageItem(key.toLowerCase(), value);
+            });
+        }
+
+        return spanContext;
+    }
+}

src/imp/tracer_imp.js

@@ -12,7 +12,6 @@ import { Platform, ProtoTransport, ThriftTransport } from '../platform_abstracti
 import AuthImp from './auth_imp';
 import RuntimeImp from './runtime_imp';
 import ReportImp from './report_imp';
-import UnsupportedPropagator from './propagator';
 import LightStepPropagator from './propagator_ls';
 
 const ClockState    = require('./util/clock_state');
@@ -81,7 +80,7 @@ export default class Tracer extends opentracing.Tracer {
         this._propagators = {};
         this._propagators[this._opentracing.FORMAT_HTTP_HEADERS] = new LightStepPropagator(this);
         this._propagators[this._opentracing.FORMAT_TEXT_MAP] = new LightStepPropagator(this);
-        this._propagators[this._opentracing.FORMAT_BINARY] = new UnsupportedPropagator(this,
+        this._propagators[this._opentracing.FORMAT_BINARY] = new LightStepPropagator(this,
             this._opentracing.FORMAT_BINARY);
 
         if (opts && opts.propagators) {

src/lib.js

@@ -2,14 +2,17 @@ import Tracer from './imp/tracer_imp';
 import LightStepPropagator from './imp/propagator_ls';
 import B3Propagator from './imp/propagator_b3';
 import DDPropagator from './imp/propagator_dd';
+import EnvoyPropagator from './imp/propagator_envoy';
 import SpanContext from './imp/span_context_imp';
 import { Platform } from './platform_abstraction_layer';
 
+
 const library = {
     Tracer              : Tracer,
     LightStepPropagator : LightStepPropagator,
     B3Propagator        : B3Propagator,
     DDPropagator        : DDPropagator,
+    EnvoyPropagator     : EnvoyPropagator,
     SpanContext         : SpanContext,
 };