Merge pull request #8 from ExpediaDotCom/opentracing-propagators

keshavpeswani · web-flow · commit 3faff7ddb58a · 2018-07-01T20:47:30.000-07:00
Adding propagators for textmap and http formats
diff --git a/Makefile b/Makefile
@@ -12,7 +12,14 @@ check-node-version:
 	@$(MIN_NODE_VER_FOUND) || echo Build requires minimum Node $(MIN_NODE_VER).x
 
 .PHONY: build
-build: check-node-version npm_install idl_codegen tslint
+build: check-node-version npm_install idl_codegen tslint compile test
+
+.PHONY: test
+test:
+	./node_modules/mocha/bin/mocha -r ./node_modules/ts-node/register tests/**/*.ts
+
+.PHONY: compile
+compile:
 	rm -rf ./dist/
 	tsc -p tsconfig.json
 	cp package.json dist/
diff --git a/package.json b/package.json
@@ -22,13 +22,18 @@
   "dependencies": {
     "google-protobuf": "^3.0.0",
     "grpc": "^1.9.0",
-    "uuid": "^3.2.1",
-    "opentracing": "^0.13.0"
+    "opentracing": "^0.13.0",
+    "uuid": "^3.2.1"
   },
   "devDependencies": {
-    "@types/node": "^10.3.4",
-    "typescript": "2.9.2",
+    "@types/node": "7.0.12",
+    "@types/chai": "3.4.35",
+    "@types/mocha": "2.2.40",
+    "chai": "^3.5.0",
     "grpc-tools": "1.6.6",
-    "tslint": "^5.0.0"
+    "mocha": "^2.5.3",
+    "ts-node": "^7.0.0",
+    "tslint": "^5.0.0",
+    "typescript": "2.9.2"
   }
 }
diff --git a/src/dispatchers/in_memory.ts b/src/dispatchers/in_memory.ts
@@ -40,4 +40,8 @@ export default class InMemoryDispatcher implements Dispatcher {
             callback();
         }
     }
+
+    spans(): Span[] {
+        return this._spans;
+    }
 }
diff --git a/src/dispatchers/remote.ts b/src/dispatchers/remote.ts
@@ -108,9 +108,12 @@ export default class RemoteDispatcher implements Dispatcher {
         } else if (typeof tagValue === 'boolean') {
             protoTag.setVbool(tagValue);
             protoTag.setType(messages.Tag.TagType.BOOL);
-        } else {
+        } else if (typeof tagValue === 'string') {
             protoTag.setVstr(tagValue);
             protoTag.setType(messages.Tag.TagType.STRING);
+        } else {
+            protoTag.setVbytes(tagValue);
+            protoTag.setType(messages.Tag.TagType.BINARY);
         }
 
         return protoTag;
diff --git a/src/propagators/default_codex.ts b/src/propagators/default_codex.ts
@@ -0,0 +1,29 @@
+/*
+ *  Copyright 2018 Expedia, Inc.
+ *
+ *       Licensed under the Apache License, Version 2.0 (the "License");
+ *       you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *           http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *       Unless required by applicable law or agreed to in writing, software
+ *       distributed under the License is distributed on an "AS IS" BASIS,
+ *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *       See the License for the specific language governing permissions and
+ *       limitations under the License.
+ */
+
+import {Codex} from './propagator';
+
+export default class DefaultCodex implements Codex {
+    constructor() { }
+
+    encode(value: string): string {
+        return value;
+    }
+
+    decode(value: string): string {
+        return value;
+    }
+}
diff --git a/src/propagators/propagation_registry.ts b/src/propagators/propagation_registry.ts
@@ -0,0 +1,33 @@
+/*
+ *  Copyright 2018 Expedia, Inc.
+ *
+ *       Licensed under the Apache License, Version 2.0 (the "License");
+ *       you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *           http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *       Unless required by applicable law or agreed to in writing, software
+ *       distributed under the License is distributed on an "AS IS" BASIS,
+ *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *       See the License for the specific language governing permissions and
+ *       limitations under the License.
+ */
+
+import {Propagator} from './propagator';
+
+export default class PropagationRegistry {
+    _propagators: any;
+
+    constructor() {
+        this._propagators = {};
+    }
+
+    register(format: string, propagator: Propagator): void {
+        this._propagators[format] = propagator;
+    }
+
+    propagator(format): Propagator {
+        return this._propagators[format];
+    }
+}
diff --git a/src/propagators/propagator.ts b/src/propagators/propagator.ts
@@ -0,0 +1,50 @@
+/*
+ *  Copyright 2018 Expedia, Inc.
+ *
+ *       Licensed under the Apache License, Version 2.0 (the "License");
+ *       you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *           http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *       Unless required by applicable law or agreed to in writing, software
+ *       distributed under the License is distributed on an "AS IS" BASIS,
+ *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *       See the License for the specific language governing permissions and
+ *       limitations under the License.
+ */
+
+import SpanContext from '../span_context';
+
+export class PropagatorOpts {
+    _traceIdKey: string;
+    _spanIdKey: string;
+    _parentSpanIdKey: string;
+    _baggageKeyPrefix: string;
+
+    traceIdKey(): string {
+        return this._traceIdKey || 'Trace-ID';
+    }
+
+    spanIdKey(): string {
+        return this._spanIdKey || 'Span-ID';
+    }
+
+    parentSpanIdKey(): string {
+        return this._parentSpanIdKey || 'Parent-ID';
+    }
+
+    baggageKeyPrefix(): string {
+        return this._baggageKeyPrefix || 'Baggage-';
+    }
+}
+
+export interface Propagator {
+    inject(spanContext: SpanContext, carrier: any): void;
+    extract(carrier: any): SpanContext;
+}
+
+export interface Codex {
+    encode(value: string): string;
+    decode(value: string): string;
+}
diff --git a/src/propagators/textmap_propagator.ts b/src/propagators/textmap_propagator.ts
@@ -0,0 +1,53 @@
+/*
+ *  Copyright 2018 Expedia, Inc.
+ *
+ *       Licensed under the Apache License, Version 2.0 (the "License");
+ *       you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *           http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *       Unless required by applicable law or agreed to in writing, software
+ *       distributed under the License is distributed on an "AS IS" BASIS,
+ *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *       See the License for the specific language governing permissions and
+ *       limitations under the License.
+ */
+
+import {Codex, Propagator, PropagatorOpts} from './propagator';
+import SpanContext from '../span_context';
+import DefaultCodex from './default_codex';
+
+export default class TextMapPropagator implements Propagator {
+    _opts: PropagatorOpts;
+    _codex: Codex;
+
+    constructor(codex: Codex = new DefaultCodex(), opts: PropagatorOpts = new PropagatorOpts()) {
+        this._opts = opts;
+        this._codex = codex;
+    }
+
+    inject(spanContext: SpanContext, carrier: any): void {
+        carrier[this._opts.traceIdKey()] = spanContext.traceId();
+        carrier[this._opts.spanIdKey()] = spanContext.spanId();
+        carrier[this._opts.parentSpanIdKey()] = spanContext.parentSpanId();
+
+        const baggage = spanContext.baggage();
+        for (const key in baggage) {
+            if (baggage.hasOwnProperty(key)) {
+                carrier[`${this._opts.baggageKeyPrefix()}${key}`] = this._codex.encode(spanContext.baggage()[key]);
+            }
+        }
+    }
+
+    extract(carrier: any): SpanContext {
+        const baggage = {};
+        for (const key in carrier) {
+            if (carrier.hasOwnProperty(key) && key.indexOf(this._opts.baggageKeyPrefix()) === 0) {
+                const keySansPrefix = key.substring(this._opts.baggageKeyPrefix().length);
+                baggage[keySansPrefix] = this._codex.decode(carrier[key]);
+            }
+        }
+        return new SpanContext(carrier[this._opts.traceIdKey()], carrier[this._opts.spanIdKey()], carrier[this._opts.parentSpanIdKey()], baggage);
+    }
+}
diff --git a/src/propagators/url_codex.ts b/src/propagators/url_codex.ts
@@ -0,0 +1,27 @@
+/*
+ *  Copyright 2018 Expedia, Inc.
+ *
+ *       Licensed under the Apache License, Version 2.0 (the "License");
+ *       you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *           http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *       Unless required by applicable law or agreed to in writing, software
+ *       distributed under the License is distributed on an "AS IS" BASIS,
+ *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *       See the License for the specific language governing permissions and
+ *       limitations under the License.
+ */
+
+import {Codex} from './propagator';
+
+export default class URLCodex implements Codex {
+    encode(value: string): string {
+        return encodeURI(value);
+    }
+
+    decode(value: string): string {
+        return decodeURI(value);
+    }
+}
diff --git a/src/start_span_fields.ts b/src/start_span_fields.ts
@@ -0,0 +1,27 @@
+/*
+ *  Copyright 2018 Expedia, Inc.
+ *
+ *       Licensed under the Apache License, Version 2.0 (the "License");
+ *       you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *           http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *       Unless required by applicable law or agreed to in writing, software
+ *       distributed under the License is distributed on an "AS IS" BASIS,
+ *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *       See the License for the specific language governing permissions and
+ *       limitations under the License.
+ */
+
+// startSpanFields is used for type-checking the Trace.startSpan().
+import SpanContext from './span_context';
+import * as opentracing from 'opentracing';
+
+export default class StartSpanFields {
+    childOf?: SpanContext;
+    references?: opentracing.Reference[];
+    tags?: any;
+    startTime?: number;
+    callerSpanContext?: SpanContext;
+}
diff --git a/src/tracer.ts b/src/tracer.ts
@@ -23,21 +23,17 @@ import SpanContext from './span_context';
 import NoopDispatcher from './dispatchers/noop';
 import NullLogger from './logger';
 import Utils from './utils';
-
-// startSpanFields is used for type-checking the Trace.startSpan().
-declare interface StartSpanFields {
-    childOf?: SpanContext;
-    references?: opentracing.Reference[];
-    tags?: any;
-    startTime?: number;
-    callerSpanContext?: SpanContext;
-}
+import PropagationRegistry from './propagators/propagation_registry';
+import TextMapPropagator from './propagators/textmap_propagator';
+import URLCodex from './propagators/url_codex';
+import StartSpanFields from './start_span_fields';
 
 export default class Tracer {
     _serviceName: string;
     _dispatcher: Dispatcher;
     _commonTags: any;
     _logger: any;
+    _registry: PropagationRegistry;
 
     constructor(serviceName: string,
                 dispatcher = new NoopDispatcher(),
@@ -47,6 +43,9 @@ export default class Tracer {
         this._serviceName = serviceName;
         this._dispatcher = dispatcher;
         this._logger = logger;
+        this._registry = new PropagationRegistry();
+        this._registry.register(opentracing.FORMAT_TEXT_MAP, new TextMapPropagator());
+        this._registry.register(opentracing.FORMAT_HTTP_HEADERS, new TextMapPropagator(new URLCodex()));
     }
 
     startSpan(operationName: string, fields?: StartSpanFields): Span {
@@ -76,7 +75,7 @@ export default class Tracer {
             }
         }
 
-        const ctx = this._createSpanContext(parent, fields.callerSpanContext);
+        const ctx = Tracer._createSpanContext(parent, fields.callerSpanContext);
         return this._startSpan(operationName, ctx, startTime, references, spanTags);
     }
 
@@ -91,7 +90,7 @@ export default class Tracer {
         return span;
     }
 
-    private _createSpanContext(parent: SpanContext, callerContext: SpanContext): SpanContext {
+    static _createSpanContext(parent: SpanContext, callerContext: SpanContext): SpanContext {
         if (!parent || !parent.isValid) {
             if (callerContext) {
                 return new SpanContext(callerContext.traceId(), callerContext.spanId(), callerContext.parentSpanId(), callerContext.baggage());
@@ -123,6 +122,32 @@ export default class Tracer {
         });
     }
 
+    inject(spanContext: SpanContext, format: string, carrier: any): void {
+        if (!spanContext) {
+            return;
+        }
+
+        const propagator = this._registry.propagator(format);
+        if (!propagator) {
+            throw new Error('injector for the given format is not supported');
+        }
+
+        propagator.inject(spanContext, carrier);
+    }
+
+    extract(format: string, carrier: any): SpanContext {
+        if (!carrier) {
+            return null;
+        }
+
+        const propagator = this._registry.propagator(format);
+        if (!propagator) {
+            throw new Error('extractor for the given format is not supported');
+        }
+
+        return propagator.extract(carrier);
+    }
+
     static initTracer(config): Tracer {
         if (config.disable) {
             return new opentracing.Tracer();
diff --git a/tests/tracer.spec.ts b/tests/tracer.spec.ts

Original file line number	Diff line number	Diff line change
`@@ -40,4 +40,8 @@ export default class InMemoryDispatcher implements Dispatcher {`
`40`	`40`	`callback();`
`41`	`41`	`}`
`42`	`42`	`}`
	`43`	`+`
	`44`	`+ spans(): Span[] {`
	`45`	`+ return this._spans;`
	`46`	`+ }`
`43`	`47`	`}`