rollbar 2.26.4 → 3.0.0-alpha.2

package/test/tracing/exporter.toPayload.test.js

@@ -0,0 +1,400 @@
+/* globals describe */
+/* globals it */
+/* globals beforeEach */
+/* globals afterEach */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { EventType } from '@rrweb/types';
+
+import { SpanExporter, spanExportQueue } from '../../src/tracing/exporter.js';
+import hrtime from '../../src/tracing/hrtime.js';
+import id from '../../src/tracing/id.js';
+import { standardPayload } from '../fixtures/replay/payloads.fixtures.js';
+
+describe('SpanExporter.toPayload()', function () {
+  let exporter;
+  let hrtimeStub;
+  let idStub;
+
+  beforeEach(function () {
+    spanExportQueue.length = 0;
+    exporter = new SpanExporter();
+
+    hrtimeStub = sinon.stub(hrtime, 'now').returns([1, 2]);
+    sinon.stub(hrtime, 'toNanos').returns(1000000000);
+    idStub = sinon.stub(id, 'gen').returns('1234567890abcdef');
+  });
+
+  afterEach(function () {
+    spanExportQueue.length = 0;
+    sinon.restore();
+  });
+
+  it('should return empty resourceSpans when queue is empty', function () {
+    const payload = exporter.toPayload();
+    expect(payload).to.deep.equal({ resourceSpans: [] });
+  });
+
+  it('should transform a simple span into OTLP format', function () {
+    const mockSpan = {
+      name: 'test-span',
+      spanContext: {
+        traceId: 'abcdef1234567890abcdef1234567890',
+        spanId: '1234567890abcdef',
+      },
+      startTime: hrtime.now(),
+      endTime: hrtime.now(),
+      attributes: {
+        'test.attribute': 'test-value',
+      },
+      events: [],
+      resource: {
+        attributes: {
+          'service.name': 'test-service',
+        },
+      },
+    };
+
+    exporter.export([mockSpan]);
+    const payload = exporter.toPayload();
+
+    expect(payload).to.have.property('resourceSpans').that.is.an('array');
+    expect(payload.resourceSpans).to.have.lengthOf(1);
+    expect(payload.resourceSpans[0]).to.have.property('resource');
+    expect(payload.resourceSpans[0])
+      .to.have.property('scopeSpans')
+      .that.is.an('array');
+    expect(payload.resourceSpans[0].scopeSpans).to.have.lengthOf(1);
+
+    const transformedSpan = payload.resourceSpans[0].scopeSpans[0].spans[0];
+    expect(transformedSpan).to.have.property('name', 'test-span');
+    expect(transformedSpan).to.have.property(
+      'traceId',
+      'abcdef1234567890abcdef1234567890',
+    );
+    expect(transformedSpan).to.have.property('spanId', '1234567890abcdef');
+
+    expect(transformedSpan).to.have.property('attributes').that.is.an('array');
+    const attribute = transformedSpan.attributes.find(
+      (attr) => attr.key === 'test.attribute',
+    );
+    expect(attribute).to.exist;
+    expect(attribute.value).to.have.property('stringValue', 'test-value');
+  });
+
+  it('should handle spans with different attribute types correctly', function () {
+    const mockSpan = {
+      name: 'attribute-test-span',
+      spanContext: {
+        traceId: 'abcdef1234567890abcdef1234567890',
+        spanId: '1234567890abcdef',
+      },
+      startTime: hrtime.now(),
+      endTime: hrtime.now(),
+      attributes: {
+        stringAttr: 'string-value',
+        intAttr: 42,
+        floatAttr: 3.14,
+        boolAttr: true,
+        nullAttr: null,
+        arrayAttr: [1, 'two', true],
+        objectAttr: { nested: 'value' },
+      },
+      events: [],
+      resource: {
+        attributes: {},
+      },
+    };
+
+    exporter.export([mockSpan]);
+    const payload = exporter.toPayload();
+    const attributes =
+      payload.resourceSpans[0].scopeSpans[0].spans[0].attributes;
+
+    const stringAttr = attributes.find((a) => a.key === 'stringAttr');
+    expect(stringAttr.value).to.have.property('stringValue', 'string-value');
+
+    const intAttr = attributes.find((a) => a.key === 'intAttr');
+    expect(intAttr.value).to.have.property('intValue', '42');
+
+    const floatAttr = attributes.find((a) => a.key === 'floatAttr');
+    expect(floatAttr.value).to.have.property('doubleValue', 3.14);
+
+    const boolAttr = attributes.find((a) => a.key === 'boolAttr');
+    expect(boolAttr.value).to.have.property('boolValue', true);
+
+    const nullAttr = attributes.find((a) => a.key === 'nullAttr');
+    expect(nullAttr.value).to.have.property('stringValue', '');
+
+    const arrayAttr = attributes.find((a) => a.key === 'arrayAttr');
+    expect(arrayAttr.value).to.have.property('arrayValue');
+    expect(arrayAttr.value.arrayValue.values).to.have.lengthOf(3);
+
+    const objectAttr = attributes.find((a) => a.key === 'objectAttr');
+    expect(objectAttr.value).to.have.property('kvlistValue');
+  });
+
+  it('should handle spans with events correctly', function () {
+    const eventTime = hrtime.now();
+
+    const mockSpan = {
+      name: 'event-test-span',
+      spanContext: {
+        traceId: 'abcdef1234567890abcdef1234567890',
+        spanId: '1234567890abcdef',
+      },
+      startTime: hrtime.now(),
+      endTime: hrtime.now(),
+      attributes: {},
+      events: [
+        {
+          name: 'test-event-1',
+          time: eventTime,
+          attributes: {
+            'event.key1': 'value1',
+          },
+        },
+        {
+          name: 'test-event-2',
+          time: eventTime,
+          attributes: {
+            'event.key2': 'value2',
+          },
+        },
+      ],
+      resource: {
+        attributes: {},
+      },
+    };
+
+    exporter.export([mockSpan]);
+    const payload = exporter.toPayload();
+    const events = payload.resourceSpans[0].scopeSpans[0].spans[0].events;
+
+    expect(events).to.have.lengthOf(2);
+    expect(events[0]).to.have.property('name', 'test-event-1');
+    expect(events[1]).to.have.property('name', 'test-event-2');
+
+    expect(events[0]).to.have.property('timeUnixNano').that.is.a('number');
+
+    const eventAttribute = events[0].attributes.find(
+      (a) => a.key === 'event.key1',
+    );
+    expect(eventAttribute).to.exist;
+    expect(eventAttribute.value).to.have.property('stringValue', 'value1');
+  });
+
+  it('should handle multiple spans with different scopes', function () {
+    const span1 = {
+      name: 'span1',
+      spanContext: {
+        traceId: 'abcdef1234567890abcdef1234567890',
+        spanId: '1111111111111111',
+      },
+      startTime: hrtime.now(),
+      endTime: hrtime.now(),
+      attributes: {},
+      events: [],
+      instrumentationScope: {
+        name: 'scope1',
+        version: '1.0.0',
+      },
+      resource: {
+        attributes: {},
+      },
+    };
+
+    const span2 = {
+      name: 'span2',
+      spanContext: {
+        traceId: 'abcdef1234567890abcdef1234567890',
+        spanId: '2222222222222222',
+      },
+      startTime: hrtime.now(),
+      endTime: hrtime.now(),
+      attributes: {},
+      events: [],
+      instrumentationScope: {
+        name: 'scope2',
+        version: '1.0.0',
+      },
+      resource: {
+        attributes: {},
+      },
+    };
+
+    const span3 = {
+      name: 'span3',
+      spanContext: {
+        traceId: 'abcdef1234567890abcdef1234567890',
+        spanId: '3333333333333333',
+      },
+      startTime: hrtime.now(),
+      endTime: hrtime.now(),
+      attributes: {},
+      events: [],
+      instrumentationScope: {
+        name: 'scope1',
+        version: '1.0.0',
+      },
+      resource: {
+        attributes: {},
+      },
+    };
+
+    exporter.export([span1, span2, span3]);
+    const payload = exporter.toPayload();
+
+    expect(payload.resourceSpans).to.have.lengthOf(1);
+    expect(payload.resourceSpans[0].scopeSpans).to.have.lengthOf(2);
+
+    const scope1 = payload.resourceSpans[0].scopeSpans.find(
+      (s) => s.scope.name === 'scope1',
+    );
+    const scope2 = payload.resourceSpans[0].scopeSpans.find(
+      (s) => s.scope.name === 'scope2',
+    );
+
+    expect(scope1).to.exist;
+    expect(scope2).to.exist;
+
+    expect(scope1.spans).to.have.lengthOf(2);
+    expect(scope2.spans).to.have.lengthOf(1);
+  });
+
+  it('should use default scope for spans without instrumentation scope', function () {
+    const mockSpan = {
+      name: 'no-scope-span',
+      spanContext: {
+        traceId: 'abcdef1234567890abcdef1234567890',
+        spanId: '1234567890abcdef',
+      },
+      startTime: hrtime.now(),
+      endTime: hrtime.now(),
+      attributes: {},
+      events: [],
+      resource: {
+        attributes: {},
+      },
+      // No instrumentationScope property
+    };
+
+    exporter.export([mockSpan]);
+    const payload = exporter.toPayload();
+
+    const scope = payload.resourceSpans[0].scopeSpans[0].scope;
+    expect(scope).to.deep.equal({
+      name: 'default',
+      version: '1.0.0',
+      attributes: [],
+    });
+  });
+
+  it('should produce a payload compatible with standardPayload fixture', function () {
+    const span = {
+      name: 'rrweb-replay-recording',
+      spanContext: {
+        traceId: 'abcdef1234567890abcdef1234567890',
+        spanId: '1234567890abcdef',
+      },
+      startTime: hrtime.now(),
+      endTime: hrtime.now(),
+      attributes: {
+        'rollbar.replay.id': 'test-replay-id',
+      },
+      events: [
+        {
+          name: 'rrweb-replay-events',
+          time: hrtime.now(),
+          attributes: {
+            eventType: String(EventType.Meta),
+            json: '{}',
+          },
+        },
+        {
+          name: 'rrweb-replay-events',
+          time: hrtime.now(),
+          attributes: {
+            eventType: String(EventType.FullSnapshot),
+            json: '{}',
+          },
+        },
+      ],
+      instrumentationScope: {
+        name: 'rollbar.js',
+        version: '1.0.0',
+      },
+      resource: {
+        attributes: {
+          'service.name': 'test_service',
+          'rollbar.environment': 'testenv',
+        },
+      },
+    };
+
+    exporter.export([span]);
+    const payload = exporter.toPayload();
+
+    const expected = JSON.parse(JSON.stringify(standardPayload));
+    const actualSpan = payload.resourceSpans[0].scopeSpans[0].spans[0];
+
+    expect(actualSpan.traceId).to.equal('abcdef1234567890abcdef1234567890');
+    expect(actualSpan.spanId).to.equal('1234567890abcdef');
+
+    expect(actualSpan.startTimeUnixNano).to.equal(1000000000);
+    expect(actualSpan.endTimeUnixNano).to.equal(1000000000);
+
+    actualSpan.events.forEach((event) => {
+      expect(event.timeUnixNano).to.equal(1000000000);
+    });
+
+    function createComparablePayload(payload) {
+      const clone = JSON.parse(JSON.stringify(payload));
+
+      // Remove fields with dynamic values that we verified separately
+      const span = clone.resourceSpans[0].scopeSpans[0].spans[0];
+      delete span.traceId;
+      delete span.spanId;
+      delete span.parentSpanId;
+      delete span.startTimeUnixNano;
+      delete span.endTimeUnixNano;
+      delete span.kind;
+
+      span.events.forEach((event) => {
+        delete event.timeUnixNano;
+      });
+
+      return clone;
+    }
+
+    const comparablePayload = createComparablePayload(payload);
+    const comparableStandard = createComparablePayload(standardPayload);
+
+    expect(
+      comparablePayload.resourceSpans[0].scopeSpans[0].spans[0].name,
+    ).to.deep.equal(
+      comparableStandard.resourceSpans[0].scopeSpans[0].spans[0].name,
+      'Span names should match',
+    );
+
+    expect(
+      comparablePayload.resourceSpans[0].scopeSpans[0].spans[0].attributes,
+    ).to.deep.equal(
+      comparableStandard.resourceSpans[0].scopeSpans[0].spans[0].attributes,
+      'Span attributes should match',
+    );
+
+    expect(
+      comparablePayload.resourceSpans[0].scopeSpans[0].spans[0].events,
+    ).to.deep.equal(
+      comparableStandard.resourceSpans[0].scopeSpans[0].spans[0].events,
+      'Span events should match',
+    );
+
+    expect(comparablePayload).to.deep.equal(
+      comparableStandard,
+      'Complete payload structure should match',
+    );
+  });
+});

package/test/tracing/id.test.js

@@ -0,0 +1,24 @@
+/* globals describe */
+/* globals it */
+
+import { expect } from 'chai';
+import id from '../../src/tracing/id.js';
+
+describe('id', function () {
+  it('should generate random hex id of specified byte length', function (done) {
+    const id8 = id.gen(8);
+    const id16 = id.gen(16);
+    const id32 = id.gen(32);
+
+    expect(id8).to.match(/^[a-f0-9]{16}$/);
+    expect(id16).to.match(/^[a-f0-9]{32}$/);
+    expect(id32).to.match(/^[a-f0-9]{64}$/);
+
+    const defaultId = id.gen();
+    expect(defaultId).to.match(/^[a-f0-9]{32}$/);
+
+    expect(id.gen()).to.not.equal(id.gen());
+
+    done();
+  });
+});

package/test/tracing/span.test.js

@@ -0,0 +1,183 @@
+/* globals describe */
+/* globals it */
+
+import { expect } from 'chai';
+
+import { Span } from '../../src/tracing/span.js';
+import { SpanExporter, spanExportQueue } from '../../src/tracing/exporter.js';
+import { SpanProcessor } from '../../src/tracing/spanProcessor.js';
+import { ROOT_CONTEXT } from '../../src/tracing/context.js';
+import hrtime from '../../src/tracing/hrtime.js';
+
+const spanOptions = function (options = {}) {
+  const exporter = new SpanExporter();
+  const spanProcessor = new SpanProcessor(exporter);
+
+  return {
+    resource: {
+      attributes: {
+        'service.name': 'unknown_service',
+        'telemetry.sdk.language': 'webjs',
+        'telemetry.sdk.name': 'rollbar',
+        'telemetry.sdk.version': '0.1.0',
+      },
+    },
+    scope: {
+      name: 'testScope',
+      version: '0.1.0',
+    },
+    session: {
+      id: 'ffd1f2e0e3ecaf2eaf0ac4c6c68154eb',
+    },
+    context: ROOT_CONTEXT,
+    spanContext: {
+      traceId: 'c7ab72d0c1457d0162d12dbed77a6cb4',
+      spanId: 'f51f610441990163',
+      traceFlags: 0,
+      traceState: '',
+    },
+    name: 'testSpan',
+    kind: 'internal',
+    parentSpanId: 'c44638e654c52eff',
+    spanProcessor: spanProcessor,
+    ...options,
+  };
+};
+
+const expectReadableSpan = function (span, overrides = {}) {
+  const expected = {
+    name: 'testSpan',
+    kind: 'internal',
+    spanContext: {
+      traceId: 'c7ab72d0c1457d0162d12dbed77a6cb4',
+      spanId: 'f51f610441990163',
+      traceFlags: 0,
+      traceState: '',
+    },
+    parentSpanId: 'c44638e654c52eff',
+    startTime: [0, 0],
+    endTime: [0, 0],
+    status: { code: 0, message: '' },
+    attributes: { 'session.id': 'ffd1f2e0e3ecaf2eaf0ac4c6c68154eb' },
+    links: [],
+    events: [],
+    duration: 0,
+    ended: false,
+    resource: {
+      attributes: {
+        'service.name': 'unknown_service',
+        'telemetry.sdk.language': 'webjs',
+        'telemetry.sdk.name': 'rollbar',
+        'telemetry.sdk.version': '0.1.0',
+      },
+    },
+    instrumentationScope: {
+      name: 'testScope',
+      version: '0.1.0',
+    },
+    droppedAttributesCount: 0,
+    droppedEventsCount: 0,
+    droppedLinksCount: 0,
+    ...overrides,
+  };
+
+  expect(span.span.name).to.equal(expected.name);
+  expect(span.span.kind).to.equal(expected.kind);
+  expect(span.span.spanContext).to.deep.equal(expected.spanContext);
+  expect(span.span.parentSpanId).to.equal(expected.parentSpanId);
+  expect(span.span.endTime).to.deep.equal(expected.endTime);
+  expect(span.span.status).to.deep.equal(expected.status);
+  expect(span.span.attributes).to.deep.equal(expected.attributes);
+  expect(span.span.links).to.deep.equal(expected.links);
+  expect(span.span.events).to.deep.equal(expected.events);
+  expect(span.span.duration).to.equal(expected.duration);
+  expect(span.span.ended).to.equal(expected.ended);
+  expect(span.span.resource).to.deep.equal(expected.resource);
+  expect(span.span.instrumentationScope).to.deep.equal(
+    expected.instrumentationScope,
+  );
+  expect(span.span.droppedAttributesCount).to.equal(
+    expected.droppedAttributesCount,
+  );
+  expect(span.span.droppedEventsCount).to.equal(expected.droppedEventsCount);
+  expect(span.span.droppedLinksCount).to.equal(expected.droppedLinksCount);
+};
+
+describe('Span()', function () {
+  it('should create a readable span', function (done) {
+    const overrides = [];
+    const span = new Span(spanOptions());
+
+    expectReadableSpan(span);
+
+    const attributes = {
+      key1: 'value1',
+      key2: 'value2',
+    };
+    span.setAttributes(attributes);
+
+    const eventTime = hrtime.now();
+    const events = [
+      {
+        name: 'event1',
+        attributes: {
+          key1: 'value1',
+          key2: 'value2',
+        },
+      },
+      {
+        name: 'event2',
+        attributes: {
+          key1: 'value1',
+          key2: 'value2',
+        },
+      },
+    ];
+
+    for (const event of events) {
+      span.addEvent(event.name, event.attributes, eventTime);
+      Object.assign(event, { time: eventTime, droppedAttributesCount: 0 });
+    }
+    Object.assign(overrides, {
+      attributes: {
+        'session.id': 'ffd1f2e0e3ecaf2eaf0ac4c6c68154eb',
+        ...attributes,
+      },
+      events: events,
+    });
+
+    expectReadableSpan(span, overrides);
+
+    const endTime = hrtime.now();
+    const endAttributes = {
+      key3: 'value3',
+      key4: 'value4',
+    };
+    span.end(endAttributes, endTime);
+
+    Object.assign(overrides, {
+      attributes: {
+        ...overrides.attributes,
+        ...endAttributes,
+      },
+      endTime: endTime,
+      ended: true,
+    });
+    expectReadableSpan(span, overrides);
+
+    done();
+  });
+
+  it('should keep valid state', function (done) {
+    const span = new Span(spanOptions());
+    expect(span.isRecording()).to.equal(true);
+    expect(span.spanId).to.match(/^[a-f0-9]{16}$/);
+    expect(span.traceId).to.match(/^[a-f0-9]{32}$/);
+
+    span.end();
+    expect(span.isRecording()).to.equal(false);
+    expect(span.export()).to.deep.equal(span.span);
+
+    done();
+  });
+});

package/test/tracing/spanProcessor.test.js

@@ -0,0 +1,73 @@
+/* globals describe */
+/* globals it */
+
+import { expect } from 'chai';
+
+import { Span } from '../../src/tracing/span.js';
+import { SpanExporter, spanExportQueue } from '../../src/tracing/exporter.js';
+import { SpanProcessor } from '../../src/tracing/spanProcessor.js';
+import { ROOT_CONTEXT } from '../../src/tracing/context.js';
+
+const spanOptions = function (options = {}) {
+  return {
+    resource: {
+      attributes: {
+        'service.name': 'unknown_service',
+        'telemetry.sdk.language': 'webjs',
+        'telemetry.sdk.name': 'rollbar',
+        'telemetry.sdk.version': '0.1.0',
+      },
+    },
+    scope: {
+      name: 'testScope',
+      version: '0.1.0',
+    },
+    session: {
+      id: 'ffd1f2e0e3ecaf2eaf0ac4c6c68154eb',
+    },
+    context: ROOT_CONTEXT,
+    spanContext: {
+      traceId: 'c7ab72d0c1457d0162d12dbed77a6cb4',
+      spanId: 'f51f610441990163',
+      traceFlags: 0,
+      traceState: '',
+    },
+    name: 'testSpan',
+    kind: 'internal',
+    parentSpanId: 'c44638e654c52eff',
+    ...options,
+  };
+}
+
+describe('SpanProcessor()', function () {
+  it('should process pending spans', function (done) {
+    const exporter = new SpanExporter();
+    const spanProcessor = new SpanProcessor(exporter);
+
+    expect(spanProcessor.pendingSpans.size).to.equal(0);
+
+    const overrides = {
+      spanProcessor: spanProcessor,
+    };
+    const span1 = new Span(spanOptions(overrides));
+
+    Object.assign(overrides, {
+      spanContext: {
+        traceId: 'c7ab72d0c1457d0162d12dbed77a6cb5',
+        spanId: '41990164f51f6104',
+        traceFlags: 0,
+        traceState: '',
+      },
+    });
+    const span2 = new Span(spanOptions(overrides));
+
+    expect(spanProcessor.pendingSpans.size).to.equal(2);
+
+    span2.end();
+    span1.end();
+
+    expect(spanProcessor.pendingSpans.size).to.equal(0);
+
+    done();
+  });
+});