feat: add baggage support to the opentracing shim

packages/opentelemetry-shim-opentracing/src/shim.ts

@@ -19,10 +19,12 @@ import {
   getExtractedSpanContext,
   NoopLogger,
   setExtractedSpanContext,
+  setCorrelationContext,
   setActiveSpan,
+  getCorrelationContext,
 } from '@opentelemetry/core';
 import * as opentracing from 'opentracing';
-import { defaultSetter } from '@opentelemetry/api';
+import { Context, CorrelationContext, defaultSetter } from '@opentelemetry/api';
 
 function translateReferences(references: opentracing.Reference[]): api.Link[] {
   const links: api.Link[] = [];
@@ -72,10 +74,15 @@ function getContextWithParent(options: opentracing.SpanOptions) {
  */
 export class SpanContextShim extends opentracing.SpanContext {
   private readonly _spanContext: api.SpanContext;
+  private _correlationContext: api.CorrelationContext;
 
-  constructor(spanContext: api.SpanContext) {
+  constructor(
+    spanContext: api.SpanContext,
+    correlationContext: CorrelationContext
+  ) {
     super();
     this._spanContext = spanContext;
+    this._correlationContext = correlationContext;
   }
 
   /**
@@ -85,6 +92,13 @@ export class SpanContextShim extends opentracing.SpanContext {
     return this._spanContext;
   }
 
+  /**
+   * Returns the underlying {@link api.CorrelationContext}
+   */
+  getCorrelationContext(): api.CorrelationContext {
+    return this._correlationContext;
+  }
+
   /**
    * Returns the trace ID as a string.
    */
@@ -98,6 +112,18 @@ export class SpanContextShim extends opentracing.SpanContext {
   toSpanId(): string {
     return this._spanContext.spanId;
   }
+
+  getBaggageItem(key: string): string | undefined {
+    const entry: api.EntryValue = this._correlationContext[key];
+    return entry === undefined ? undefined : entry.value;
+  }
+
+  setBaggageItem(key: string, value: string) {
+    this._correlationContext = Object.assign(
+      { [key]: { value } },
+      this._correlationContext
+    );
+  }
 }
 
 /**
@@ -125,29 +151,39 @@ export class TracerShim extends opentracing.Tracer {
       getContextWithParent(options)
     );
 
+    let correlationContext: CorrelationContext = {};
+    if (options.childOf) {
+      if (options.childOf instanceof SpanShim) {
+        const shimContext = options.childOf.context() as SpanContextShim;
+        correlationContext = shimContext.getCorrelationContext();
+      }
+    }
+
     if (options.tags) {
       span.setAttributes(options.tags);
     }
 
-    return new SpanShim(this, span);
+    return new SpanShim(this, span, correlationContext);
   }
 
   _inject(
     spanContext: opentracing.SpanContext,
     format: string,
     carrier: unknown
   ): void {
-    const opentelemSpanContext: api.SpanContext = (spanContext as SpanContextShim).getSpanContext();
+    const oTelSpanContext: api.SpanContext = (spanContext as SpanContextShim).getSpanContext();
+    const oTelSpanCorrelationContext: api.CorrelationContext = (spanContext as SpanContextShim).getCorrelationContext();
+
     if (!carrier || typeof carrier !== 'object') return;
     switch (format) {
       case opentracing.FORMAT_HTTP_HEADERS:
       case opentracing.FORMAT_TEXT_MAP: {
         api.propagation.inject(
           carrier,
           defaultSetter,
-          setExtractedSpanContext(
-            api.Context.ROOT_CONTEXT,
-            opentelemSpanContext
+          setCorrelationContext(
+            setExtractedSpanContext(api.Context.ROOT_CONTEXT, oTelSpanContext),
+            oTelSpanCorrelationContext
           )
         );
         return;
@@ -156,7 +192,7 @@ export class TracerShim extends opentracing.Tracer {
         this._logger.warn(
           'OpentracingShim.inject() does not support FORMAT_BINARY'
         );
-        // @todo: Implement binary format
+        // @todo: Implement binary formats
         return;
       }
       default:
@@ -167,13 +203,16 @@ export class TracerShim extends opentracing.Tracer {
     switch (format) {
       case opentracing.FORMAT_HTTP_HEADERS:
       case opentracing.FORMAT_TEXT_MAP: {
-        const context = getExtractedSpanContext(
+        const context: Context = api.propagation.extract(carrier);
+        const spanContext = getExtractedSpanContext(context);
+        const correlationContext = getCorrelationContext(
           api.propagation.extract(carrier)
         );
-        if (!context) {
+
+        if (!spanContext) {
           return null;
         }
-        return new SpanContextShim(context);
+        return new SpanContextShim(spanContext, correlationContext || {});
       }
       case opentracing.FORMAT_BINARY: {
         // @todo: Implement binary format
@@ -191,19 +230,23 @@ export class TracerShim extends opentracing.Tracer {
 /**
  * SpanShim wraps an {@link types.Span} and implements the OpenTracing Span API
  * around it.
- * @todo: Out of band baggage propagation is not currently supported.
- */
+ *
+ *  */
 export class SpanShim extends opentracing.Span {
   // _span is the original OpenTelemetry span that we are wrapping with
   // an opentracing interface.
   private readonly _span: api.Span;
   private readonly _contextShim: SpanContextShim;
   private readonly _tracerShim: TracerShim;
 
-  constructor(tracerShim: TracerShim, span: api.Span) {
+  constructor(
+    tracerShim: TracerShim,
+    span: api.Span,
+    correlationalCtx: CorrelationContext
+  ) {
     super();
     this._span = span;
-    this._contextShim = new SpanContextShim(span.context());
+    this._contextShim = new SpanContextShim(span.context(), correlationalCtx);
     this._tracerShim = tracerShim;
   }
 
@@ -295,12 +338,11 @@ export class SpanShim extends opentracing.Span {
   }
 
   getBaggageItem(key: string): string | undefined {
-    // TODO: should this go into the context?
-    return undefined;
+    return this._contextShim.getBaggageItem(key);
   }
 
   setBaggageItem(key: string, value: string): this {
-    // TODO: should this go into the context?
+    this._contextShim.setBaggageItem(key, value);
     return this;
   }
 

packages/opentelemetry-shim-opentracing/test/Shim.test.ts

@@ -135,7 +135,7 @@ describe('OpenTracing Shim', () => {
 
   describe('SpanContextShim', () => {
     it('returns the correct context', () => {
-      const shim = new SpanContextShim(INVALID_SPAN_CONTEXT);
+      const shim = new SpanContextShim(INVALID_SPAN_CONTEXT, {});
       assert.strictEqual(shim.getSpanContext(), INVALID_SPAN_CONTEXT);
       assert.strictEqual(shim.toTraceId(), INVALID_SPAN_CONTEXT.traceId);
       assert.strictEqual(shim.toSpanId(), INVALID_SPAN_CONTEXT.spanId);
@@ -190,7 +190,20 @@ describe('OpenTracing Shim', () => {
 
     it('can set and retrieve baggage', () => {
       span.setBaggageItem('baggage', 'item');
-      // TODO: baggage
+      const value = span.getBaggageItem('baggage');
+      assert.equal('item', value);
+
+      const childSpan = shimTracer.startSpan('child-span1', {
+        childOf: span,
+      });
+      childSpan.setBaggageItem('key2', 'item2');
+
+      // child should have parent baggage items.
+      assert.equal('item', childSpan.getBaggageItem('baggage'));
+      assert.equal('item2', childSpan.getBaggageItem('key2'));
+
+      // Parent shouldn't have the childr baggage item.
+      assert.equal(span.getBaggageItem('key2'), undefined);
     });
   });
 });