Adding propagators for textmap and http formats

Author: Ashish Aggarwal

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;
+    }
+}

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];
+    }
+}

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;
+}

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);
+    }
+}

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);
+    }
+}

src/tracer.ts

@@ -23,6 +23,9 @@ import SpanContext from './span_context';
 import NoopDispatcher from './dispatchers/noop';
 import NullLogger from './logger';
 import Utils from './utils';
+import PropagationRegistry from './propagators/propagation_registry';
+import TextMapPropagator from './propagators/textmap_propagator';
+import URLCodex from './propagators/url_codex';
 
 // startSpanFields is used for type-checking the Trace.startSpan().
 declare interface StartSpanFields {
@@ -38,6 +41,7 @@ export default class Tracer {
     _dispatcher: Dispatcher;
     _commonTags: any;
     _logger: any;
+    _registry: PropagationRegistry;
 
     constructor(serviceName: string,
                 dispatcher = new NoopDispatcher(),
@@ -47,6 +51,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 {
@@ -123,6 +130,32 @@ export default class Tracer {
         });
     }
 
+    inject(spanContext: SpanContext, format: string, carrier: any): void {
+        if (!spanContext) {
+            return;
+        }
+
+        const propagator = this._registry._propagators(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;
+        }
+
+        const propagator = this._registry._propagators(format);
+        if (!propagator) {
+            throw new Error('extracttor for the given format is not supported');
+        }
+
+        return propagator.extract(carrier);
+    }
+
     static initTracer(config): Tracer {
         if (config.disable) {
             return new opentracing.Tracer();