feat: add instrumentation library and update collector exporter

packages/opentelemetry-core/package.json

@@ -10,7 +10,7 @@
   "types": "build/src/index.d.ts",
   "repository": "open-telemetry/opentelemetry-js",
   "scripts": {
-    "test": "nyc ts-mocha -p tsconfig.json test/**/*.test.ts --exclude 'test/platform/browser/**/*.ts'",
+    "test": "nyc ts-mocha -p tsconfig.json 'test/**/*.test.ts' --exclude 'test/platform/browser/**/*.ts'",
     "test:browser": "nyc karma start --single-run",
     "tdd": "npm run tdd:node",
     "tdd:node": "npm run test -- --watch-extensions ts --watch",

packages/opentelemetry-core/src/common/types.ts

@@ -42,3 +42,8 @@ export interface ShimWrapped {
   __unwrap: Function;
   __original: Function;
 }
+
+export interface InstrumentationLibrary {
+  readonly name: string;
+  readonly version: string;
+}

packages/opentelemetry-exporter-collector/src/transform.ts

@@ -30,6 +30,7 @@ import {
 } from './CollectorExporterBase';
 import { COLLECTOR_SPAN_KIND_MAPPING, opentelemetryProto } from './types';
 import ValueType = opentelemetryProto.common.v1.ValueType;
+import { InstrumentationLibrary } from '@opentelemetry/core';
 
 /**
  * Converts attributes
@@ -202,11 +203,10 @@ export function toCollectorExportTraceServiceRequest<
   collectorExporterBase: CollectorExporterBase<T>,
   name = ''
 ): opentelemetryProto.collector.trace.v1.ExportTraceServiceRequest {
-  const spansToBeSent: opentelemetryProto.trace.v1.Span[] = spans.map(span =>
-    toCollectorSpan(span)
-  );
-  const resource: Resource =
-    spans.length > 0 ? spans[0].resource : Resource.empty();
+  const groupedSpans: Map<
+    Resource,
+    Map<core.InstrumentationLibrary, ReadableSpan[]>
+  > = groupSpans(spans);
 
   const additionalAttributes = Object.assign(
     {},
@@ -215,23 +215,60 @@ export function toCollectorExportTraceServiceRequest<
       'service.name': collectorExporterBase.serviceName,
     }
   );
-  const protoResource: opentelemetryProto.resource.v1.Resource = toCollectorResource(
-    resource,
-    additionalAttributes
-  );
-  const instrumentationLibrarySpans: opentelemetryProto.trace.v1.InstrumentationLibrarySpans = {
-    spans: spansToBeSent,
-    instrumentationLibrary: {
-      name: name || `${core.SDK_INFO.NAME} - ${core.SDK_INFO.LANGUAGE}`,
-      version: core.SDK_INFO.VERSION,
-    },
-  };
-  const resourceSpan: opentelemetryProto.trace.v1.ResourceSpans = {
-    resource: protoResource,
-    instrumentationLibrarySpans: [instrumentationLibrarySpans],
+
+  return {
+    resourceSpans: toCollectorResourceSpans(groupedSpans, additionalAttributes),
   };
+}
 
+/**
+ * Takes an array of spans and groups them by resource and instrumentation
+ * library
+ * @param spans spans
+ */
+export function groupSpans(
+  spans: ReadableSpan[]
+): Map<Resource, Map<core.InstrumentationLibrary, ReadableSpan[]>> {
+  return spans.reduce((spanMap, span) => {
+    //group by resource
+    let resourceSpans = spanMap.get(span.resource);
+    if (!resourceSpans) {
+      resourceSpans = new Map<core.InstrumentationLibrary, ReadableSpan[]>();
+      spanMap.set(span.resource, resourceSpans);
+    }
+    //group by instrumentation library
+    let libSpans = resourceSpans.get(span.instrumentationLibrary);
+    if (!libSpans) {
+      libSpans = new Array<ReadableSpan>();
+      resourceSpans.set(span.instrumentationLibrary, libSpans);
+    }
+    libSpans.push(span);
+    return spanMap;
+  }, new Map<Resource, Map<core.InstrumentationLibrary, ReadableSpan[]>>());
+}
+
+function toCollectorInstrumentationLibrarySpans(
+  instrumentationLibrary: InstrumentationLibrary,
+  spans: ReadableSpan[]
+): opentelemetryProto.trace.v1.InstrumentationLibrarySpans {
   return {
-    resourceSpans: [resourceSpan],
+    spans: spans.map(toCollectorSpan),
+    instrumentationLibrary,
   };
 }
+
+function toCollectorResourceSpans(
+  groupedSpans: Map<Resource, Map<core.InstrumentationLibrary, ReadableSpan[]>>,
+  baseAttributes: Attributes
+): opentelemetryProto.trace.v1.ResourceSpans[] {
+  return Array.from(groupedSpans, ([resource, libSpans]) => {
+    return {
+      resource: toCollectorResource(resource, baseAttributes),
+      instrumentationLibrarySpans: Array.from(
+        libSpans,
+        ([instrumentationLibrary, spans]) =>
+          toCollectorInstrumentationLibrarySpans(instrumentationLibrary, spans)
+      ),
+    };
+  });
+}

packages/opentelemetry-exporter-collector/test/common/transform.test.ts

@@ -14,11 +14,13 @@
  * limitations under the License.
  */
 
-import { Attributes, TimedEvent } from '@opentelemetry/api';
+import { Attributes, TimedEvent, TraceFlags } from '@opentelemetry/api';
 import * as assert from 'assert';
 import * as transform from '../../src/transform';
 import { ensureSpanIsCorrect, mockedReadableSpan } from '../helper';
 import { Resource } from '@opentelemetry/resources';
+import { InstrumentationLibrary } from '@opentelemetry/core';
+import { ReadableSpan } from '@opentelemetry/tracing';
 
 describe('transform', () => {
   describe('toCollectorAttributes', () => {
@@ -119,4 +121,176 @@ describe('transform', () => {
       });
     });
   });
+
+  describe('groupSpans', () => {
+    it('should group by resource', () => {
+      const resource1: Resource = new Resource({ name: 'resource 1' });
+      const resource2: Resource = new Resource({ name: 'resource 2' });
+      const instrumentationLibrary: InstrumentationLibrary = {
+        name: 'lib1',
+        version: '0.0.1',
+      };
+
+      const span1: ReadableSpan = {
+        name: 'span1',
+        kind: 0,
+        spanContext: {
+          traceId: '1f1008dc8e270e85c40a0d7c3939b278',
+          spanId: '5e107261f64fa53e',
+          traceFlags: TraceFlags.SAMPLED,
+        },
+        parentSpanId: '78a8915098864388',
+        startTime: [1574120165, 429803070],
+        endTime: [1574120165, 438688070],
+        ended: true,
+        status: { code: 0 },
+        attributes: {},
+        links: [],
+        events: [],
+        duration: [0, 8885000],
+        resource: resource1,
+        instrumentationLibrary,
+      };
+
+      const span2: ReadableSpan = {
+        name: 'span2',
+        kind: 0,
+        spanContext: {
+          traceId: '1f1008dc8e270e85c40a0d7c3939b278',
+          spanId: 'f64fa53e5e107261',
+          traceFlags: TraceFlags.SAMPLED,
+        },
+        parentSpanId: '86438878a8915098',
+        startTime: [1575120165, 439803070],
+        endTime: [1575120165, 448688070],
+        ended: true,
+        status: { code: 0 },
+        attributes: {},
+        links: [],
+        events: [],
+        duration: [0, 8775000],
+        resource: resource2,
+        instrumentationLibrary,
+      };
+
+      const span3: ReadableSpan = {
+        name: 'span3',
+        kind: 0,
+        spanContext: {
+          traceId: '1f1008dc8e270e85c40a0d7c3939b278',
+          spanId: '07261f64fa53e5e1',
+          traceFlags: TraceFlags.SAMPLED,
+        },
+        parentSpanId: 'a891578098864388',
+        startTime: [1575120165, 439803070],
+        endTime: [1575120165, 448688070],
+        ended: true,
+        status: { code: 0 },
+        attributes: {},
+        links: [],
+        events: [],
+        duration: [0, 8775000],
+        resource: resource2,
+        instrumentationLibrary,
+      };
+
+      const expected = new Map([
+        [resource1, new Map([[instrumentationLibrary, [span1]]])],
+        [resource2, new Map([[instrumentationLibrary, [span2, span3]]])],
+      ]);
+
+      const result = transform.groupSpans([span1, span2, span3]);
+
+      assert.deepStrictEqual(result, expected);
+    });
+
+    it('should group by instrumentation library', () => {
+      const resource: Resource = new Resource({ name: 'resource 1' });
+      const instrumentationLibrary1: InstrumentationLibrary = {
+        name: 'lib1',
+        version: '0.0.1',
+      };
+      const instrumentationLibrary2: InstrumentationLibrary = {
+        name: 'lib2',
+        version: '0.0.2',
+      };
+
+      const span1: ReadableSpan = {
+        name: 'span1',
+        kind: 0,
+        spanContext: {
+          traceId: '1f1008dc8e270e85c40a0d7c3939b278',
+          spanId: '5e107261f64fa53e',
+          traceFlags: TraceFlags.SAMPLED,
+        },
+        parentSpanId: '78a8915098864388',
+        startTime: [1574120165, 429803070],
+        endTime: [1574120165, 438688070],
+        ended: true,
+        status: { code: 0 },
+        attributes: {},
+        links: [],
+        events: [],
+        duration: [0, 8885000],
+        resource,
+        instrumentationLibrary: instrumentationLibrary1,
+      };
+
+      const span2: ReadableSpan = {
+        name: 'span2',
+        kind: 0,
+        spanContext: {
+          traceId: '1f1008dc8e270e85c40a0d7c3939b278',
+          spanId: 'f64fa53e5e107261',
+          traceFlags: TraceFlags.SAMPLED,
+        },
+        parentSpanId: '78a8915098864388',
+        startTime: [1575120165, 439803070],
+        endTime: [1575120165, 448688070],
+        ended: true,
+        status: { code: 0 },
+        attributes: {},
+        links: [],
+        events: [],
+        duration: [0, 8775000],
+        resource,
+        instrumentationLibrary: instrumentationLibrary1,
+      };
+
+      const span3: ReadableSpan = {
+        name: 'span3',
+        kind: 0,
+        spanContext: {
+          traceId: '1f1008dc8e270e85c40a0d7c3939b278',
+          spanId: '07261f64fa53e5e1',
+          traceFlags: TraceFlags.SAMPLED,
+        },
+        parentSpanId: 'a891578098864388',
+        startTime: [1575120165, 439803070],
+        endTime: [1575120165, 448688070],
+        ended: true,
+        status: { code: 0 },
+        attributes: {},
+        links: [],
+        events: [],
+        duration: [0, 8775000],
+        resource: resource,
+        instrumentationLibrary: instrumentationLibrary2,
+      };
+
+      const expected = new Map([
+        [
+          resource,
+          new Map([
+            [instrumentationLibrary1, [span1, span2]],
+            [instrumentationLibrary2, [span3]],
+          ]),
+        ],
+      ]);
+
+      const result = transform.groupSpans([span1, span2, span3]);
+
+      assert.deepStrictEqual(result, expected);
+    });
+  });
 });

packages/opentelemetry-exporter-collector/test/helper.ts

@@ -105,6 +105,7 @@ export const mockedReadableSpan: ReadableSpan = {
     version: 1,
     cost: 112.12,
   }),
+  instrumentationLibrary: { name: 'default', version: '0.0.1' },
 };
 
 export function ensureExportedEventsAreCorrect(

packages/opentelemetry-exporter-jaeger/test/jaeger.test.ts

@@ -143,6 +143,10 @@ describe('JaegerExporter', () => {
         events: [],
         duration: [32, 800000000],
         resource: Resource.empty(),
+        instrumentationLibrary: {
+          name: 'default',
+          version: '0.0.1',
+        },
       };
 
       exporter.export([readableSpan], (result: ExportResult) => {

packages/opentelemetry-exporter-jaeger/test/transform.test.ts

@@ -75,6 +75,10 @@ describe('transform', () => {
           version: 1,
           cost: 112.12,
         }),
+        instrumentationLibrary: {
+          name: 'default',
+          version: '0.0.1',
+        },
       };
 
       const thriftSpan = spanToThrift(readableSpan);
@@ -169,6 +173,10 @@ describe('transform', () => {
         events: [],
         duration: [32, 800000000],
         resource: Resource.empty(),
+        instrumentationLibrary: {
+          name: 'default',
+          version: '0.0.1',
+        },
       };
 
       const thriftSpan = spanToThrift(readableSpan);
@@ -234,6 +242,10 @@ describe('transform', () => {
         events: [],
         duration: [32, 800000000],
         resource: Resource.empty(),
+        instrumentationLibrary: {
+          name: 'default',
+          version: '0.0.1',
+        },
       };
 
       const thriftSpan = spanToThrift(readableSpan);
@@ -273,6 +285,10 @@ describe('transform', () => {
         events: [],
         duration: [32, 800000000],
         resource: Resource.empty(),
+        instrumentationLibrary: {
+          name: 'default',
+          version: '0.0.1',
+        },
       };
 
       const thriftSpan = spanToThrift(readableSpan);