rollbar 2.26.4 → 3.0.0-alpha.2

package/test/server.transforms.test-utils.mjs

@@ -0,0 +1,62 @@
+/**
+ * Common test utilities for server transforms tests
+ */
+
+import Rollbar from '../src/server/rollbar.js';
+import merge from '../src/merge.js';
+
+export class CustomError extends Rollbar.Error {
+  constructor(message, nested) {
+    super(message, nested);
+  }
+}
+
+export const nodeVersion = process.versions.node
+  .split('.')
+  .map((v) => parseInt(v));
+
+export const isMinNodeVersion = (major, minor) =>
+  nodeVersion[0] > major ||
+  (nodeVersion[0] === major && nodeVersion[1] >= minor);
+
+export async function wait(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+export async function throwInScriptFile(filepath) {
+  // Dynamic imports inside setTimeout with async/await can create timing
+  // issues where the error escapes before Rollbar's handler can catch it.
+  const module = await import(filepath);
+  setTimeout(() => module.default(), 10);
+  await wait(500);
+}
+
+// Base test item factory for request-related tests
+export function createTestItem(overrides = {}) {
+  const base = {
+    request: {
+      headers: {
+        host: 'example.com',
+        'x-auth-token': '12345',
+      },
+      protocol: 'https',
+      url: '/some/endpoint',
+      ip: '192.192.192.1',
+      method: 'GET',
+      body: {
+        token: 'abc123',
+        something: 'else',
+      },
+      user: {
+        id: 42,
+        email: 'fake@example.com',
+      },
+    },
+    stuff: 'hey',
+    data: { other: 'thing' },
+  };
+
+  return merge(base, overrides);
+}

package/test/server.transport.mocha.test.mjs

@@ -0,0 +1,269 @@
+/* globals describe */
+/* globals it */
+
+import { expect } from 'chai';
+import Transport from '../src/server/transport.js';
+
+class TestTransport {
+  constructor(options, error, response, assertions) {
+    this.options = options;
+    this.error = error;
+    this.response = response;
+    this.requestOpts = null;
+    this.requestCallback = null;
+    this.assertions = assertions;
+  }
+
+  request(opts, cb) {
+    this.requestOpts = opts;
+    this.requestCallback = cb;
+    return new TestRequest(this.error, this.response, this);
+  }
+}
+
+class TestRequest {
+  constructor(error, response, transport) {
+    this.error = error;
+    this.responseData = response;
+    this.data = [];
+    this.events = {};
+    this.transport = transport;
+    this.response = null;
+  }
+
+  write(data) {
+    this.data.push(data);
+  }
+
+  on(event, cb) {
+    this.events[event] = cb;
+  }
+
+  end() {
+    if (this.transport.assertions) {
+      this.transport.assertions();
+    }
+    if (this.error) {
+      if (this.events['error']) {
+        this.events['error'](this.error);
+      }
+    } else {
+      this.response = new TestResponse();
+      this.transport.requestCallback(this.response);
+      if (this.response.events['data']) {
+        this.response.events['data'](this.responseData);
+      }
+      if (this.response.events['end']) {
+        this.response.events['end']();
+      }
+    }
+  }
+}
+
+class TestResponse {
+  constructor(options = {}) {
+    this.encoding = null;
+    this.events = {};
+    this.headers = options.headers || {};
+    this.statusCode = options.statusCode || 200;
+  }
+
+  setEncoding(s) {
+    this.encoding = s;
+  }
+
+  on(event, cb) {
+    this.events[event] = cb;
+  }
+}
+
+const transportFactory = (error, response, assertions) => (options) =>
+  new TestTransport(options, error, response, assertions);
+
+describe('transport', function () {
+  const t = new Transport();
+
+  describe('post', function () {
+    describe('base data', function () {
+      const baseData = {
+        accessToken: 'abc123',
+        options: {},
+        payload: {
+          access_token: 'abc123',
+          data: { a: 1 },
+        },
+      };
+
+      it('should have an error with no payload', function (done) {
+        const factory = transportFactory(
+          null,
+          '{"err": null, "result":"all good"}',
+        );
+
+        t.post(
+          baseData.accessToken,
+          baseData.options,
+          null,
+          (err, resp) => {
+            expect(err).to.exist;
+            expect(resp).to.not.exist;
+            done();
+          },
+          factory,
+        );
+      });
+
+      it('should have the right response data with a payload and no error', function (done) {
+        const factory = transportFactory(
+          null,
+          '{"err": null, "result":{"uuid":"42def", "message":"all good"}}',
+          function () {
+            expect(this.options.headers['Content-Type']).to.equal(
+              'application/json',
+            );
+            expect(this.options.headers['Content-Length']).to.be.a('number');
+            expect(this.options.headers['Content-Length']).to.be.above(0);
+            expect(this.options.headers['X-Rollbar-Access-Token']).to.equal(
+              baseData.accessToken,
+            );
+          },
+        );
+
+        t.post(
+          baseData.accessToken,
+          baseData.options,
+          baseData.payload,
+          (err, resp) => {
+            expect(err).to.not.exist;
+            expect(resp.message).to.equal('all good');
+            done();
+          },
+          factory,
+        );
+      });
+
+      it('should error with a payload and an error in the response', function (done) {
+        const factory = transportFactory(
+          null,
+          '{"err": "bork", "message":"things broke"}',
+          function () {
+            expect(this.options.headers['Content-Type']).to.equal(
+              'application/json',
+            );
+            expect(this.options.headers['Content-Length']).to.be.a('number');
+            expect(this.options.headers['Content-Length']).to.be.above(0);
+            expect(this.options.headers['X-Rollbar-Access-Token']).to.equal(
+              baseData.accessToken,
+            );
+          },
+        );
+
+        t.post(
+          baseData.accessToken,
+          baseData.options,
+          baseData.payload,
+          (err, resp) => {
+            expect(err).to.exist;
+            expect(err.message).to.match(/things broke/);
+            expect(resp).to.not.exist;
+            done();
+          },
+          factory,
+        );
+      });
+
+      it('should error with a payload and an error during sending', function (done) {
+        const factory = transportFactory(new Error('bork'), null, function () {
+          expect(this.options.headers['Content-Type']).to.equal(
+            'application/json',
+          );
+          expect(this.options.headers['Content-Length']).to.be.a('number');
+          expect(this.options.headers['Content-Length']).to.be.above(0);
+          expect(this.options.headers['X-Rollbar-Access-Token']).to.equal(
+            baseData.accessToken,
+          );
+        });
+
+        t.post(
+          baseData.accessToken,
+          baseData.options,
+          baseData.payload,
+          (err, resp) => {
+            expect(err).to.exist;
+            expect(err.message).to.match(/bork/);
+            expect(resp).to.not.exist;
+            done();
+          },
+          factory,
+        );
+      });
+    });
+
+    describe('with rate limiting', function () {
+      let transport;
+
+      beforeEach(function () {
+        transport = new Transport();
+      });
+
+      it('should transmit non-rate limited requests', function (done) {
+        const factory = transportFactory(
+          null,
+          '{"err": null, "result": "all good"}',
+        );
+        const response = new TestResponse({
+          statusCode: 200,
+          headers: {
+            'x-rate-limit-remaining': '1',
+            'x-rate-limit-remaining-seconds': '100',
+          },
+        });
+
+        expect(transport.rateLimitExpires).to.equal(0);
+
+        transport.handleResponse(response);
+
+        transport.post(
+          'token',
+          {},
+          'payload',
+          (err) => {
+            expect(err).to.not.exist;
+            expect(Math.floor(Date.now() / 1000)).to.be.at.least(
+              transport.rateLimitExpires,
+            );
+            done();
+          },
+          factory,
+        );
+      });
+
+      it('should drop rate limited requests and set timeout', function (done) {
+        const factory = transportFactory(new Error('bork'), null);
+        const response = new TestResponse({
+          statusCode: 429,
+          headers: {
+            'x-rate-limit-remaining': '0',
+            'x-rate-limit-remaining-seconds': '100',
+          },
+        });
+
+        transport.handleResponse(response);
+
+        transport.post(
+          'token',
+          {},
+          'payload',
+          (err) => {
+            expect(err.message).to.match(/Exceeded rate limit/);
+            expect(Math.floor(Date.now() / 1000)).to.be.below(
+              transport.rateLimitExpires,
+            );
+            done();
+          },
+          factory,
+        );
+      });
+    });
+  });
+});

package/test/telemetry.test.js

@@ -3,7 +3,8 @@
 /* globals it */
 /* globals sinon */
 
-var Telemeter = require('../src/telemetry');
+import Telemeter from '../src/telemetry.js';
+import Tracing from '../src/tracing/tracing.js';
 
 describe('Telemetry()', function () {
   it('should have all of the expected methods', function (done) {
@@ -47,6 +48,136 @@ describe('captureEvent', function () {
   });
 });
 
+describe('capture events', function () {
+  beforeEach(function () {
+    const tracing = new Tracing(
+      window,
+      {
+        resource: {
+          'service.name': 'Test',
+        },
+      }
+    );
+    tracing.initSession();
+    this.t = new Telemeter({includeItemsInTelemetry: true}, tracing);
+  });
+
+  it('should return a valid log event', function (done) {
+    const timestamp = 12345.678;
+    const event = this.t.captureLog('foo', 'info', null, timestamp);
+    expect(event.type).to.equal('log');
+    expect(event.level).to.equal('info');
+    expect(event.body.message).to.equal('foo');
+    expect(event.timestamp_ms).to.equal(timestamp);
+
+    expect(this.t.telemetrySpan).to.be.an('object');
+    const otelEvent = this.t.telemetrySpan.span.events[0];
+    expect(otelEvent.name).to.equal('rollbar-log-event');
+    expect(otelEvent.time).to.eql([ 12, 345678000 ]);
+    expect(otelEvent.attributes).to.eql({ message: 'foo', level: 'info' });
+    done();
+  });
+
+  it('should return a valid error event', function (done) {
+    const timestamp = 12345.678;
+    const error = new Error('foo');
+    const uuid = '12345-67890';
+    const event = this.t.captureError(error, 'info', uuid, timestamp);
+    expect(event.type).to.eql('error');
+    expect(event.level).to.equal('info');
+    expect(event.body.message).to.equal('foo');
+    expect(event.timestamp_ms).to.equal(timestamp);
+
+    expect(this.t.telemetrySpan).to.be.an('object');
+    const otelEvent = this.t.telemetrySpan.span.events[0];
+    expect(otelEvent.name).to.eql('rollbar-occurrence-event');
+    expect(otelEvent.time).to.eql([ 12, 345678000 ]);
+    expect(otelEvent.attributes).to.eql(
+      { type: 'error', 'occurrence.type': 'error', message: 'foo', level: 'info', uuid: uuid, 'occurrence.uuid': uuid }
+    );
+    done();
+  });
+
+  it('should return a valid message event', function (done) {
+    const timestamp = 12345.678;
+    const uuid = '12345-67890';
+    const item = { message: 'foo', level: 'info', uuid: uuid, timestamp: timestamp };
+    const event = this.t._captureRollbarItem(item);
+    expect(event.type).to.eql('log');
+    expect(event.level).to.equal('info');
+    expect(event.body.message).to.equal('foo');
+    expect(event.timestamp_ms).to.equal(timestamp);
+
+    expect(this.t.telemetrySpan).to.be.an('object');
+    const otelEvent = this.t.telemetrySpan.span.events[0];
+    expect(otelEvent.name).to.eql('rollbar-occurrence-event');
+    expect(otelEvent.time).to.eql([ 12, 345678000 ]);
+    expect(otelEvent.attributes).to.eql(
+      { type: 'message', 'occurrence.type': 'message', message: 'foo', level: 'info', uuid: uuid, 'occurrence.uuid': uuid }
+    );
+    done();
+  });
+
+  it('should return a valid navigation event', function (done) {
+    const timestamp = 12345.678;
+    const from = 'foo';
+    const to = 'bar';
+    const event = this.t.captureNavigation(from, to, null, timestamp);
+    expect(event.type).to.equal('navigation');
+    expect(event.level).to.equal('info');
+    expect(event.body.from).to.equal('foo');
+    expect(event.body.to).to.equal('bar');
+    expect(event.timestamp_ms).to.equal(timestamp);
+
+    expect(this.t.telemetrySpan).to.be.an('object');
+    const otelEvent = this.t.telemetrySpan.span.events[0];
+    expect(otelEvent.name).to.equal('rollbar-navigation-event');
+    expect(otelEvent.time).to.eql([ 12, 345678000 ]);
+    expect(otelEvent.attributes).to.eql({ 'previous.url.full': 'foo', 'url.full': 'bar' });
+    done();
+  });
+
+  it('should return a valid network event', function (done) {
+    const subtype = 'xhr';
+    const timestamp = 12345.678;
+    const metadata = {
+      url: 'https://example.com',
+      method: 'GET',
+      status_code: 400,
+      request_headers: { 'Content-Type': 'application/json' },
+      response: {
+        headers: { 'Content-Type': 'application/json' },
+      },
+      start_time_ms: timestamp,
+      end_time_ms: 12345678,
+    };
+    const event = this.t.captureNetwork(metadata, subtype, null, null);
+    expect(event.type).to.eql('network');
+    expect(event.level).to.equal('error');
+    expect(event.body.url).to.equal(metadata.url);
+    expect(event.body.method).to.equal(metadata.method);
+    expect(event.body.status_code).to.equal(metadata.status_code);
+    expect(event.timestamp_ms).to.equal(timestamp);
+
+    expect(this.t.telemetrySpan).to.be.an('object');
+    const otelEvent = this.t.telemetrySpan.span.events[0];
+    expect(otelEvent.name).to.eql('rollbar-network-event');
+    expect(otelEvent.time).to.eql([ 12, 345678000 ]);
+    expect(otelEvent.attributes).to.eql(
+      {
+        type: subtype,
+        method: metadata.method,
+        statusCode: metadata.status_code,
+        url: metadata.url,
+        'request.headers': JSON.stringify(metadata.request_headers),
+        'response.headers': JSON.stringify(metadata.response.headers),
+        'response.timeUnixNano': (metadata.end_time_ms * 1e6).toString(),
+      }
+    );
+    done();
+  });
+});
+
 describe('filterTelemetry', function () {
   it("should filter out events that don't match the test", function (done) {
     var options = {

package/test/tracing/contextManager.test.js

@@ -0,0 +1,28 @@
+/* globals describe */
+/* globals it */
+
+import { expect } from 'chai';
+
+import { ContextManager, createContextKey } from '../../src/tracing/contextManager.js';
+import { ROOT_CONTEXT } from '../../src/tracing/context.js';
+
+describe('ContextManager()', function () {
+  it('should process pending spans', function (done) {
+    const SPAN_KEY = createContextKey('Rollbar Context Key SPAN');
+    const contextManager = new ContextManager();
+
+    expect(contextManager.active()).to.equal(ROOT_CONTEXT);
+
+    let context = contextManager.active().setValue(SPAN_KEY, 'a')
+    let prevContext = contextManager.enterContext(context);
+
+    expect(prevContext).to.equal(ROOT_CONTEXT);
+    expect(contextManager.active()).to.equal(context);
+
+    contextManager.exitContext(prevContext);
+
+    expect(contextManager.active()).to.equal(ROOT_CONTEXT);
+
+    done();
+  });
+});