Adding 128 bit traceId support

.gitignore

@@ -4,6 +4,7 @@ npm-debug.log
 dist/
 
 .idea/
+.vscode/
 *.iml
 
 crossdock/jaeger-docker-compose.yml

.travis.yml

@@ -21,6 +21,9 @@ matrix:
       - docker
   - env: TEST_NODE_VERSION=6 LINT=1 COVER=1
   - env: TEST_NODE_VERSION=4
+  - env: TEST_NODE_VERSION=--lts
+  - env: TEST_NODE_VERSION=node
+  allow_failures:
   - env: TEST_NODE_VERSION=node
 
 env:

src/_flow/tracer.js

@@ -20,4 +20,5 @@ declare type startSpanOptions = {
   references?: Array<Reference>,
   tags?: any,
   startTime?: number,
+  traceId128bit?: boolean,
 };

src/span_context.js

@@ -15,7 +15,8 @@ import * as constants from './constants.js';
 import Utils from './util.js';
 
 export default class SpanContext {
-  _traceId: any;
+  _traceIdLow: any;
+  _traceIdHigh: any;
   _spanId: any;
   _parentId: any;
   _traceIdStr: ?string;
@@ -43,7 +44,8 @@ export default class SpanContext {
   _samplingFinalized: boolean;
 
   constructor(
-    traceId: any,
+    traceIdLow: any,
+    traceIdHigh: any,
     spanId: any,
     parentId: any,
     traceIdStr: ?string,
@@ -54,7 +56,8 @@ export default class SpanContext {
     debugId: ?string = '',
     samplingFinalized: boolean = false
   ) {
-    this._traceId = traceId;
+    this._traceIdLow = traceIdLow;
+    this._traceIdHigh = traceIdHigh;
     this._spanId = spanId;
     this._parentId = parentId;
     this._traceIdStr = traceIdStr;
@@ -66,11 +69,33 @@ export default class SpanContext {
     this._samplingFinalized = samplingFinalized;
   }
 
-  get traceId(): any {
-    if (this._traceId == null && this._traceIdStr != null) {
-      this._traceId = Utils.encodeInt64(this._traceIdStr);
+  get traceIdLow(): any {
+    this._tryParseTraceIdStr();
+    return this._traceIdLow;
+  }
+
+  get traceIdHigh(): any {
+    this._tryParseTraceIdStr();
+    return this._traceIdHigh;
+  }
+
+  _tryParseTraceIdStr() {
+    if (this._traceIdLow == null && this._traceIdHigh == null && this._traceIdStr != null) {
+      if (this._traceIdStr.length > 16) {
+        const safeTraceIdStr = this._traceIdStr.length % 2 == 0 ? this._traceIdStr : '0' + this._traceIdStr;
+        const traceId = new Buffer(safeTraceIdStr, 'hex');
+        this._traceIdHigh = traceId.slice(-16, -8);
+        if (this._traceIdHigh.length != 8) {
+          const tmpBuffer = new Buffer(8);
+          tmpBuffer.fill(0);
+          this._traceIdHigh.copy(tmpBuffer, 8 - this._traceIdHigh.length);
+          this._traceIdHigh = tmpBuffer;
+        }
+        this._traceIdLow = traceId.slice(-8);
+      } else {
+        this._traceIdLow = Utils.encodeInt64(this._traceIdStr);
+      }
     }
-    return this._traceId;
   }
 
   get spanId(): any {
@@ -88,8 +113,14 @@ export default class SpanContext {
   }
 
   get traceIdStr(): ?string {
-    if (this._traceIdStr == null && this._traceId != null) {
-      this._traceIdStr = Utils.removeLeadingZeros(this._traceId.toString('hex'));
+    if (this._traceIdStr == null && this._traceIdLow != null) {
+      if (this._traceIdHigh != null) {
+        this._traceIdStr = Utils.removeLeadingZeros(
+          this._traceIdHigh.toString('hex') + this._traceIdLow.toString('hex')
+        );
+      } else {
+        this._traceIdStr = Utils.removeLeadingZeros(this._traceIdLow.toString('hex'));
+      }
     }
     return this._traceIdStr;
   }
@@ -124,8 +155,13 @@ export default class SpanContext {
     return this._samplingFinalized;
   }
 
-  set traceId(traceId: Buffer): void {
-    this._traceId = traceId;
+  set traceIdLow(traceIdLow: Buffer): void {
+    this._traceIdLow = traceIdLow;
+    this._traceIdStr = null;
+  }
+
+  set traceIdHigh(traceIdHigh: Buffer): void {
+    this._traceIdHigh = traceIdHigh;
     this._traceIdStr = null;
   }
 
@@ -152,7 +188,7 @@ export default class SpanContext {
   }
 
   get isValid(): boolean {
-    return !!((this._traceId || this._traceIdStr) && (this._spanId || this._spanIdStr));
+    return !!((this._traceIdLow || this._traceIdStr) && (this._spanId || this._spanIdStr));
   }
 
   finalizeSampling(): void {
@@ -181,7 +217,8 @@ export default class SpanContext {
     let newBaggage = Utils.clone(this._baggage);
     newBaggage[key] = value;
     return new SpanContext(
-      this._traceId,
+      this._traceIdLow,
+      this._traceIdHigh,
       this._spanId,
       this._parentId,
       this._traceIdStr,
@@ -238,15 +275,17 @@ export default class SpanContext {
   }
 
   static withBinaryIds(
-    traceId: any,
+    traceIdLow: any,
+    traceIdHigh: any,
     spanId: any,
     parentId: any,
     flags: number,
     baggage: any = {},
     debugId: ?string = ''
   ): SpanContext {
     return new SpanContext(
-      traceId,
+      traceIdLow,
+      traceIdHigh,
       spanId,
       parentId,
       null, // traceIdStr: string,
@@ -267,7 +306,8 @@ export default class SpanContext {
     debugId: ?string = ''
   ): SpanContext {
     return new SpanContext(
-      null, // traceId,
+      null, // traceIdLow,
+      null, // traceIdHigh,
       null, // spanId,
       null, // parentId,
       traceIdStr,

src/thrift.js

@@ -104,8 +104,8 @@ export default class ThriftUtils {
 
       thriftRefs.push({
         refType: refEnum,
-        traceIdLow: context.traceId,
-        traceIdHigh: ThriftUtils.emptyBuffer,
+        traceIdLow: context.traceIdLow,
+        traceIdHigh: context.traceIdHigh == null ? ThriftUtils.emptyBuffer : context.traceIdHigh,
         spanId: context.spanId,
       });
     }
@@ -119,8 +119,9 @@ export default class ThriftUtils {
     let unsigned = true;
 
     return {
-      traceIdLow: span._spanContext.traceId,
-      traceIdHigh: ThriftUtils.emptyBuffer, // TODO(oibe) implement 128 bit ids
+      traceIdLow: span._spanContext.traceIdLow,
+      traceIdHigh:
+        span._spanContext.traceIdHigh == null ? ThriftUtils.emptyBuffer : span._spanContext.traceIdHigh,
       spanId: span._spanContext.spanId,
       parentSpanId: span._spanContext.parentId || ThriftUtils.emptyBuffer,
       operationName: span._operationName,

src/tracer.js

@@ -188,6 +188,8 @@ export default class Tracer {
    *        the created Span object. The time should be specified in
    *        milliseconds as Unix timestamp. Decimal value are supported
    *        to represent time values with sub-millisecond accuracy.
+   * @param {number} [options.traceId128bit] - generate root span with a
+   *        128bit traceId.
    * @return {Span} - a new Span object.
    **/
   startSpan(operationName: string, options: ?startSpanOptions): Span {
@@ -239,12 +241,18 @@ export default class Tracer {
         ctx.baggage = parent.baggage;
       }
 
-      ctx.traceId = randomId;
+      if (options.traceId128bit) {
+        ctx.traceIdLow = randomId;
+        ctx.traceIdHigh = Utils.getRandom64();
+      } else {
+        ctx.traceIdLow = randomId;
+      }
       ctx.spanId = randomId;
       ctx.parentId = null;
       ctx.flags = flags;
     } else {
-      ctx.traceId = parent.traceId;
+      ctx.traceIdLow = parent.traceIdLow;
+      ctx.traceIdHigh = parent.traceIdHigh;
       ctx.spanId = Utils.getRandom64();
       ctx.parentId = parent.spanId;
       ctx.flags = parent.flags;

test/span.js

@@ -35,6 +35,7 @@ describe('span should', () => {
 
     spanContext = SpanContext.withBinaryIds(
       Utils.encodeInt64(1),
+      null,
       Utils.encodeInt64(2),
       Utils.encodeInt64(3),
       constants.SAMPLED_MASK

test/span_context.js

@@ -24,14 +24,31 @@ describe('SpanContext should', () => {
   });
 
   it('return given values as they were set', () => {
-    let traceId = Utils.encodeInt64(1);
+    let traceIdLow = Utils.encodeInt64(1);
     let spanId = Utils.encodeInt64(2);
     let parentId = Utils.encodeInt64(3);
     let flags = 1;
 
-    let context = SpanContext.withBinaryIds(traceId, spanId, parentId, flags);
+    let context = SpanContext.withBinaryIds(traceIdLow, null, spanId, parentId, flags);
 
-    assert.deepEqual(traceId, context.traceId);
+    assert.deepEqual(traceIdLow, context.traceIdLow);
+    assert.deepEqual(spanId, context.spanId);
+    assert.deepEqual(parentId, context.parentId);
+    assert.equal(flags, context.flags);
+  });
+
+  it('return given values as they were set 128 bit', () => {
+    let traceIdLow = Utils.encodeInt64(1);
+    let traceIdHigh = Utils.encodeInt64(2);
+    let spanId = Utils.encodeInt64(3);
+    let parentId = Utils.encodeInt64(4);
+    let flags = 1;
+
+    let context = SpanContext.withBinaryIds(traceIdLow, traceIdHigh, spanId, parentId, flags);
+
+    assert.deepEqual(traceIdLow, context.traceIdLow);
+    assert.deepEqual(traceIdHigh, context.traceIdHigh);
+    assert.deepEqual('20000000000000001', context.traceIdStr);
     assert.deepEqual(spanId, context.spanId);
     assert.deepEqual(parentId, context.parentId);
     assert.equal(flags, context.flags);
@@ -40,6 +57,7 @@ describe('SpanContext should', () => {
   it('return IsSampled properly', () => {
     let context = SpanContext.withBinaryIds(
       Utils.encodeInt64(1),
+      null,
       Utils.encodeInt64(2),
       Utils.encodeInt64(3),
       3
@@ -53,19 +71,20 @@ describe('SpanContext should', () => {
   });
 
   it('format strings properly with toString', () => {
-    let ctx1 = SpanContext.withBinaryIds(Utils.encodeInt64(0x100), Utils.encodeInt64(0x7f), null, 1);
+    let ctx1 = SpanContext.withBinaryIds(Utils.encodeInt64(0x100), null, Utils.encodeInt64(0x7f), null, 1);
     assert.equal(ctx1.toString(), '100:7f:0:1');
 
     let ctx2 = SpanContext.withBinaryIds(
       Utils.encodeInt64(255 << 4),
+      null,
       Utils.encodeInt64(127),
       Utils.encodeInt64(256),
       0
     );
     assert.equal(ctx2.toString(), 'ff0:7f:100:0');
 
     // test large numbers
-    let ctx3 = SpanContext.withBinaryIds(LARGEST_64_BUFFER, LARGEST_64_BUFFER, LARGEST_64_BUFFER, 0);
+    let ctx3 = SpanContext.withBinaryIds(LARGEST_64_BUFFER, null, LARGEST_64_BUFFER, LARGEST_64_BUFFER, 0);
     assert.equal(ctx3.toString(), 'ffffffffffffffff:ffffffffffffffff:ffffffffffffffff:0');
     assert.equal('ffffffffffffffff', ctx3.traceIdStr);
     assert.equal('ffffffffffffffff', ctx3.spanIdStr);
@@ -90,6 +109,28 @@ describe('SpanContext should', () => {
     assert.equal(context.flags, 0x1);
   });
 
+  it('turn properly formatted strings into correct span contexts 128 bit', () => {
+    let context = SpanContext.fromString('20000000000000100:7f:0:1');
+
+    assert.deepEqual('20000000000000100', context.traceIdStr);
+    assert.deepEqual(Utils.encodeInt64(0x100), context.traceIdLow);
+    assert.deepEqual(Utils.encodeInt64(0x2), context.traceIdHigh);
+    assert.deepEqual(Utils.encodeInt64(0x7f), context.spanId);
+    assert.equal(null, context.parentId);
+    assert.equal(1, context.flags);
+
+    // test large numbers
+    context = SpanContext.fromString('ffffffffffffffffffffffffffffffff:ffffffffffffffff:5:1');
+    assert.equal('ffffffffffffffffffffffffffffffff', context.traceIdStr);
+    assert.equal('ffffffffffffffff', context.spanIdStr);
+    assert.deepEqual(LARGEST_64_BUFFER, context.traceIdLow);
+    assert.deepEqual(LARGEST_64_BUFFER, context.traceIdHigh);
+    assert.deepEqual(LARGEST_64_BUFFER, context.spanId);
+    assert.deepEqual(LARGEST_64_BUFFER, context.spanId);
+    assert.deepEqual(Utils.encodeInt64(0x5), context.parentId);
+    assert.equal(context.flags, 0x1);
+  });
+
   it('return null on malformed traces', () => {
     assert.equal(SpanContext.fromString('bad value'), null);
     assert.equal(SpanContext.fromString('1:1:1:1:1'), null, 'Too many colons');

test/thrift.js

@@ -11,6 +11,7 @@
 // the License.
 
 import { assert } from 'chai';
+import opentracing from 'opentracing';
 import ConstSampler from '../src/samplers/const_sampler.js';
 import InMemoryReporter from '../src/reporters/in_memory_reporter.js';
 import Tracer from '../src/tracer.js';
@@ -64,4 +65,22 @@ describe('ThriftUtils', () => {
     assert.deepEqual(tSpan.duration, Utils.encodeInt64((123.678 - 123.456) * 1000));
     assert.deepEqual(tSpan.logs[0].timestamp, Utils.encodeInt64(123567));
   });
+
+  it('should convert span with 128 bit traceId', () => {
+    let reporter = new InMemoryReporter();
+    let tracer = new Tracer('test-service-name', reporter, new ConstSampler(true));
+    let span = tracer.startSpan('some operation', { traceId128bit: true });
+    let childOfRef = new opentracing.Reference(opentracing.REFERENCE_CHILD_OF, span.context());
+    let childSpan = tracer.startSpan('some child operation', { references: [childOfRef] });
+    childSpan.finish();
+    span.finish();
+    tracer.close();
+    let tSpan = ThriftUtils.spanToThrift(childSpan);
+    assert.deepEqual(tSpan.traceIdLow, childSpan.context().traceIdLow);
+    assert.deepEqual(tSpan.traceIdHigh, childSpan.context().traceIdHigh);
+    assert.deepEqual(tSpan.spanId, childSpan.context().spanId);
+    assert.deepEqual(tSpan.references[0].traceIdLow, span.context().traceIdLow);
+    assert.deepEqual(tSpan.references[0].traceIdHigh, span.context().traceIdHigh);
+    assert.deepEqual(tSpan.references[0].spanId, span.context().spanId);
+  });
 });