feat: pipe InstrumentationLibrary from Tracer to ReadableSpan

packages/opentelemetry-tracing/src/BasicTracerProvider.ts

@@ -47,7 +47,10 @@ export class BasicTracerProvider implements api.TracerProvider {
   getTracer(name: string, version = '*', config?: TracerConfig): Tracer {
     const key = `${name}@${version}`;
     if (!this._tracers.has(key)) {
-      this._tracers.set(key, new Tracer(config || this._config, this));
+      this._tracers.set(
+        key,
+        new Tracer(name, version, config || this._config, this)
+      );
     }
 
     return this._tracers.get(key)!;

packages/opentelemetry-tracing/src/Span.ts

@@ -18,6 +18,7 @@ import * as api from '@opentelemetry/api';
 import {
   hrTime,
   hrTimeDuration,
+  InstrumentationLibrary,
   isTimeInput,
   timeInputToHrTime,
 } from '@opentelemetry/core';
@@ -41,6 +42,7 @@ export class Span implements api.Span, ReadableSpan {
   readonly events: api.TimedEvent[] = [];
   readonly startTime: api.HrTime;
   readonly resource: Resource;
+  readonly instrumentationLibrary: InstrumentationLibrary;
   name: string;
   status: api.Status = {
     code: api.CanonicalCode.OK,
@@ -69,6 +71,7 @@ export class Span implements api.Span, ReadableSpan {
     this.links = links;
     this.startTime = timeInputToHrTime(startTime);
     this.resource = parentTracer.resource;
+    this.instrumentationLibrary = parentTracer.instrumentationLibrary;
     this._logger = parentTracer.logger;
     this._traceParams = parentTracer.getActiveTraceParams();
     this._spanProcessor = parentTracer.getActiveSpanProcessor();

packages/opentelemetry-tracing/src/Tracer.ts

@@ -19,6 +19,7 @@ import {
   ConsoleLogger,
   getActiveSpan,
   getParentSpanContext,
+  InstrumentationLibrary,
   isValid,
   NoRecordingSpan,
   randomSpanId,
@@ -39,12 +40,15 @@ export class Tracer implements api.Tracer {
   private readonly _sampler: api.Sampler;
   private readonly _traceParams: TraceParams;
   readonly resource: Resource;
+  readonly instrumentationLibrary: InstrumentationLibrary;
   readonly logger: api.Logger;
 
   /**
    * Constructs a new Tracer instance.
    */
   constructor(
+    name: string,
+    version: string,
     config: TracerConfig,
     private _tracerProvider: BasicTracerProvider
   ) {
@@ -53,6 +57,7 @@ export class Tracer implements api.Tracer {
     this._sampler = localConfig.sampler;
     this._traceParams = localConfig.traceParams;
     this.resource = _tracerProvider.resource;
+    this.instrumentationLibrary = new InstrumentationLibrary(name, version);
     this.logger = config.logger || new ConsoleLogger(config.logLevel);
   }
 

packages/opentelemetry-tracing/src/export/ReadableSpan.ts

@@ -24,6 +24,7 @@ import {
   TimedEvent,
 } from '@opentelemetry/api';
 import { Resource } from '@opentelemetry/resources';
+import { InstrumentationLibrary } from '@opentelemetry/core';
 
 export interface ReadableSpan {
   readonly name: string;
@@ -39,4 +40,5 @@ export interface ReadableSpan {
   readonly duration: HrTime;
   readonly ended: boolean;
   readonly resource: Resource;
+  readonly instrumentationLibrary: InstrumentationLibrary;
 }

packages/opentelemetry-tracing/test/Span.test.ts

@@ -29,6 +29,7 @@ import {
   hrTimeToMilliseconds,
   NoopLogger,
   hrTimeDuration,
+  InstrumentationLibrary,
 } from '@opentelemetry/core';
 
 const performanceTimeOrigin = hrTime();
@@ -230,6 +231,7 @@ describe('Span', () => {
     assert.deepStrictEqual(span.attributes, {});
     assert.deepStrictEqual(span.links, []);
     assert.deepStrictEqual(span.events, []);
+    assert.ok(span.instrumentationLibrary instanceof InstrumentationLibrary);
   });
 
   it('should return ReadableSpan with attributes', () => {

packages/opentelemetry-tracing/test/Tracer.test.ts

@@ -17,7 +17,12 @@
 import * as assert from 'assert';
 import { NoopSpan, Sampler, SamplingDecision } from '@opentelemetry/api';
 import { BasicTracerProvider, Tracer, Span } from '../src';
-import { NoopLogger, ALWAYS_SAMPLER, NEVER_SAMPLER } from '@opentelemetry/core';
+import {
+  InstrumentationLibrary,
+  NoopLogger,
+  ALWAYS_SAMPLER,
+  NEVER_SAMPLER,
+} from '@opentelemetry/core';
 
 describe('Tracer', () => {
   const tracerProvider = new BasicTracerProvider({
@@ -36,28 +41,52 @@ describe('Tracer', () => {
   }
 
   it('should create a Tracer instance', () => {
-    const tracer = new Tracer({}, tracerProvider);
+    const tracer = new Tracer('default', '0.0.1', {}, tracerProvider);
     assert.ok(tracer instanceof Tracer);
   });
 
   it('should respect NO_RECORD sampling result', () => {
-    const tracer = new Tracer({ sampler: NEVER_SAMPLER }, tracerProvider);
+    const tracer = new Tracer(
+      'default',
+      '0.0.1',
+      { sampler: NEVER_SAMPLER },
+      tracerProvider
+    );
     const span = tracer.startSpan('span1');
     assert.ok(span instanceof NoopSpan);
     span.end();
   });
 
   it('should respect RECORD_AND_SAMPLE sampling result', () => {
-    const tracer = new Tracer({ sampler: ALWAYS_SAMPLER }, tracerProvider);
+    const tracer = new Tracer(
+      'default',
+      '0.0.1',
+      { sampler: ALWAYS_SAMPLER },
+      tracerProvider
+    );
     const span = tracer.startSpan('span2');
     assert.ok(!(span instanceof NoopSpan));
     span.end();
   });
 
   it('should start a span with attributes in sampling result', () => {
-    const tracer = new Tracer({ sampler: new TestSampler() }, tracerProvider);
+    const tracer = new Tracer(
+      'default',
+      '0.0.1',
+      { sampler: new TestSampler() },
+      tracerProvider
+    );
     const span = tracer.startSpan('span3');
     assert.strictEqual((span as Span).attributes.testAttribute, 'foobar');
     span.end();
   });
+
+  it('should have an instrumentationLibrary', () => {
+    const tracer = new Tracer('default', '0.0.1', {}, tracerProvider);
+
+    const lib: InstrumentationLibrary = tracer.instrumentationLibrary;
+
+    assert.strictEqual(lib.name, 'default');
+    assert.strictEqual(lib.version, '0.0.1');
+  });
 });