rollbar 2.26.4 → 3.0.0-alpha.2

package/test/tracing/tracing.test.js

@@ -0,0 +1,105 @@
+/* globals describe */
+/* globals it */
+
+import { expect } from 'chai';
+
+import { ContextManager, createContextKey } from '../../src/tracing/contextManager.js';
+import { Session } from '../../src/tracing/session.js';
+import { SpanExporter, spanExportQueue } from '../../src/tracing/exporter.js';
+import { SpanProcessor } from '../../src/tracing/spanProcessor.js';
+import { Tracer } from '../../src/tracing/tracer.js';
+import { ROOT_CONTEXT } from '../../src/tracing/context.js';
+import Tracing from '../../src/tracing/tracing';
+
+const tracingOptions = function (options = {}) {
+  return {
+    resource: {
+      'service.name': 'unknown_service',
+      'telemetry.sdk.language': 'webjs',
+      'telemetry.sdk.name': 'rollbar',
+      'telemetry.sdk.version': '0.1.0',
+    },
+    version: '0.1.0',
+    ...options,
+  };
+};
+
+describe('Tracing()', function () {
+  it('should initialize', function (done) {
+    const options = tracingOptions();
+    const t = new Tracing(window, options);
+    t.initSession()
+
+    expect(t).to.have.property('initSession').and.to.be.a('function');
+    expect(t).to.have.property('createTracer').and.to.be.a('function');
+    expect(t).to.have.property('getTracer').and.to.be.a('function');
+    expect(t).to.have.property('getSpan').and.to.be.a('function');
+    expect(t).to.have.property('setSpan').and.to.be.a('function');
+    expect(t).to.have.property('with').and.to.be.a('function');
+    expect(t).to.have.property('withSpan').and.to.be.a('function');
+
+    expect(t.contextManager).to.be.an.instanceOf(ContextManager);
+    expect(t.session).to.be.an.instanceOf(Session);
+    expect(t.exporter).to.be.an.instanceOf(SpanExporter);
+    expect(t.spanProcessor).to.be.an.instanceOf(SpanProcessor);
+    expect(t.tracer).to.be.an.instanceOf(Tracer);
+
+    expect(t.options.resource).to.deep.equal(options.resource);
+    expect(t.options.version).to.equal(options.version);
+    expect(t.session.session.id).to.match(/^[a-f0-9]{32}$/)
+    done();
+  });
+
+  it('should create and export spans', function (done) {
+    const options = tracingOptions();
+    const t = new Tracing(window, options);
+    t.initSession()
+
+    expect(t.sessionId).to.match(/^[a-f0-9]{32}$/);
+
+    const span = t.startSpan('test.span');
+
+    expect(span.span.name).to.equal('test.span')
+    expect(span.span.spanContext.traceId).to.match(/^[a-f0-9]{32}$/)
+    expect(span.span.spanContext.spanId).to.match(/^[a-f0-9]{16}$/)
+    expect(span.span.resource.attributes['service.name']).to.equal('unknown_service')
+    expect(span.span.instrumentationScope.name).to.equal('rollbar-browser-js')
+    expect(span.span.instrumentationScope.version).to.equal('0.1.0')
+    expect(span.isRecording()).to.equal(true)
+    expect(t.contextManager.active()).to.equal(ROOT_CONTEXT)
+
+    const context = t.setSpan(t.contextManager.active(), span)
+
+    expect(context).to.not.equal(ROOT_CONTEXT)
+
+    const prevContext = t.contextManager.enterContext(context)
+
+    expect(t.contextManager.active()).to.not.equal(ROOT_CONTEXT)
+    expect(prevContext).to.equal(ROOT_CONTEXT)
+
+    t.contextManager.exitContext(prevContext)
+
+    expect(t.contextManager.active()).to.equal(ROOT_CONTEXT)
+    expect(t.spanProcessor.pendingSpans.has(span.span.spanContext.spanId)).to.be.true
+    expect(spanExportQueue.length).to.equal(0)
+
+    span.end()
+
+    expect(span.isRecording()).to.equal(false)
+    expect(t.spanProcessor.pendingSpans.has(span.span.spanContext.spanId)).to.be.false
+    expect(spanExportQueue.length).to.equal(1)
+
+    done();
+  });
+
+  it('should generate ids', function (done) {
+    const options = tracingOptions();
+    const t = new Tracing(window, options);
+
+    const replayId = t.idGen(8);
+
+    expect(replayId).to.match(/^[a-f0-9]{16}$/);
+
+    done();
+  });
+});

package/test/transforms.test.js

@@ -2,8 +2,8 @@
 /* globals describe */
 /* globals it */
 
-var _ = require('../src/utility');
-var t = require('../src/transforms');
+import _ from '../src/utility.js';
+import t from '../src/transforms.js';
 
 function itemFromArgs(args) {
   var item = _.createItem(args);

package/test/truncation.test.js

@@ -2,8 +2,8 @@
 /* globals describe */
 /* globals it */
 
-var t = require('../src/truncation');
-var utility = require('../src/utility');
+import t from '../src/truncation.js';
+import utility from '../src/utility.js';
 utility.setupJSON();
 
 describe('truncate', function () {

package/test/utility.test.js

@@ -3,9 +3,9 @@
 /* globals it */
 /* globals sinon */
 
-var _ = require('../src/utility');
-var utility = require('../src/utility');
-var polyfillJSON = require('../vendor/JSON-js/json3');
+import _ from '../src/utility.js';
+import utility from '../src/utility.js';
+import polyfillJSON from '../vendor/JSON-js/json3.js';
 
 utility.setupJSON();
 
@@ -448,7 +448,7 @@ describe('merge', function () {
   });
 });
 
-var traverse = require('../src/utility/traverse');
+import traverse from '../src/utility/traverse.js';
 describe('traverse', function () {
   describe('should call the func for every key,value', function () {
     it('simple object', function (done) {
@@ -618,7 +618,13 @@ describe('addParamsAndAccessTokenToPath', function () {
 });
 
 describe('json3', function () {
-  var setupCustomJSON = require('../vendor/JSON-js/json3.js');
+  let setupCustomJSON;
+
+  before(async function () {
+    const module = await import('../vendor/JSON-js/json3.js');
+    setupCustomJSON = module.default;
+  });
+
   it('should replace stringify if not there', function () {
     var j = {};
     setupCustomJSON(j);
@@ -767,7 +773,7 @@ describe('set', function () {
   });
 });
 
-var scrub = require('../src/scrub');
+import scrub from '../src/scrub.js';
 describe('scrub', function () {
   it('should not redact fields that are okay', function () {
     var data = {
@@ -924,3 +930,35 @@ describe('formatArgsAsString', function () {
   });
   */
 });
+
+describe('addItemAttributes', function () {
+  it('should skip undefined values', function () {
+    const item = { data: {} };
+    const attributes = [
+      { key: 'replay_id', value: '12345' },
+      { key: 'session_id', value: undefined },
+    ];
+    _.addItemAttributes(item.data, attributes);
+    expect(item.data.attributes).to.be.an('array');
+    expect(item.data.attributes.length).to.equal(1);
+    expect(item.data.attributes[0].key).to.equal('replay_id');
+    expect(item.data.attributes[0].value).to.equal('12345');
+  });
+});
+
+describe('getItemAttribute', function () {
+  it('should skip undefined values', function () {
+    const item = {
+      data: {
+        attributes: [
+          { key: 'replay_id', value: '12345' },
+          { key: 'session_id', value: '67890' },
+        ],
+      },
+    };
+    let value = _.getItemAttribute(item.data, 'replay_id');
+    expect(value).to.equal('12345');
+    value = _.getItemAttribute(item.data, 'session_id');
+    expect(value).to.equal('67890');
+  });
+});

package/webpack.config.js

@@ -24,18 +24,8 @@ var snippetConfig = {
   module: {
     rules: [
       {
-        enforce: 'pre',
         test: /\.js$/,
-        loader: 'eslint-loader',
-        exclude: [/node_modules/, /vendor/],
-        options: {
-          failOnError: true,
-          configFile: path.resolve(__dirname, '.eslintrc'),
-        },
-      },
-      {
-        test: /\.js$/,
-        loader: 'strict-loader',
+        loader: 'babel-loader',
         exclude: [/node_modules/, /vendor/],
       },
     ],
@@ -54,19 +44,9 @@ var pluginConfig = {
   plugins: [defaultsPlugin],
   module: {
     rules: [
-      {
-        enforce: 'pre',
-        test: /\.js$/,
-        loader: 'eslint-loader',
-        exclude: [/node_modules/, /vendor/],
-        options: {
-          failOnError: true,
-          configFile: path.resolve(__dirname, '.eslintrc'),
-        },
-      },
       {
         test: /\.js$/,
-        loader: 'strict-loader',
+        loader: 'babel-loader',
         exclude: [/node_modules/, /vendor/],
       },
     ],
@@ -80,23 +60,14 @@ var vanillaConfigBase = {
   output: {
     path: outputPath,
   },
+  target: ['web', 'es5'],
   plugins: [defaultsPlugin],
   devtool: 'hidden-source-map',
   module: {
     rules: [
       {
-        enforce: 'pre',
         test: /\.js$/,
-        loader: 'eslint-loader',
-        exclude: [/node_modules/, /vendor/],
-        options: {
-          failOnError: true,
-          configFile: path.resolve(__dirname, '.eslintrc'),
-        },
-      },
-      {
-        test: /\.js$/,
-        loader: 'strict-loader',
+        loader: 'babel-loader',
         exclude: [/node_modules/, /vendor/],
       },
     ],
@@ -113,22 +84,13 @@ var UMDConfigBase = {
     libraryTarget: 'umd',
     globalObject: 'this',
   },
+  target: ['web', 'es5'],
   devtool: 'source-map',
   module: {
     rules: [
-      {
-        enforce: 'pre',
-        test: /\.js$/,
-        loader: 'eslint-loader',
-        exclude: [/node_modules/, /vendor/],
-        options: {
-          failOnError: true,
-          configFile: path.resolve(__dirname, '.eslintrc'),
-        },
-      },
       {
         test: /\.js$/,
-        loader: 'strict-loader',
+        loader: 'babel-loader',
         exclude: [/node_modules/, /vendor/],
       },
     ],

package/.eslintignore

@@ -1,7 +0,0 @@
-node_modules
-vendor
-lib
-dist
-release
-test
-examples

package/test/server.lambda.test.js

@@ -1,194 +0,0 @@
-'use strict';
-
-var assert = require('assert');
-var vows = require('vows');
-var sinon = require('sinon');
-
-process.env.NODE_ENV = process.env.NODE_ENV || 'test-node-env';
-var Rollbar = require('../src/server/rollbar');
-
-function promisePending(promise, callback) {
-  var testValue = 'test-pending';
-
-  // Detect if a given promise is pending/unfulfilled using the
-  // behavior of Promise.race(), which always returns the first
-  // already resolved promise in the array.
-  Promise.race([promise, Promise.resolve(testValue)])
-    .then(function (value) {
-      if (value === testValue) {
-        return callback(true);
-      } else {
-        return callback(false);
-      }
-    })
-    .catch(function (_error) {
-      return callback(false);
-    });
-}
-
-function fakePostItem(_item, callback) {
-  // 1000ms simulates low API response, and allows testing the state before completion.
-  setTimeout(function () {
-    callback();
-  }, 1000);
-}
-
-var stubContext = {
-  getRemainingTimeInMillis: function () {
-    return 2000;
-  },
-};
-
-vows
-  .describe('lambda')
-  .addBatch({
-    'async handler sends message': {
-      topic: function () {
-        var rollbar = new Rollbar({
-          accessToken: 'abc123',
-          captureUncaught: true,
-          captureLambdaTimeouts: false,
-        });
-        var api = rollbar.client.notifier.queue.api;
-        rollbar.requestStub = sinon
-          .stub(api, 'postItem')
-          .callsFake(fakePostItem);
-
-        rollbar.testHandlerInstance = rollbar.lambdaHandler(
-          async (_event, _context) => {
-            // Testing the condition where the client handler sends a message before exit.
-            // The Rollbar wrapper should send, and should not resolve until the API request
-            // has completed.
-            rollbar.info('lambda test message');
-            return 'done';
-          },
-        );
-
-        return rollbar;
-      },
-      'invokes handler and receives promise': function (r) {
-        var handler = r.testHandlerInstance;
-
-        // rollbar.lambdaHandler in the above topic should have returned a
-        // handler with the correct signature. (The callback handler is length = 3)
-        assert.equal(handler.length, 2);
-        assert.equal(handler.name, 'rollbarAsyncLambdaHandler');
-
-        // The rollbar.wait() in the wrapper should prevent this from
-        // resolving until the response is received.
-        r.testPromise = handler({}, stubContext);
-      },
-      'after handler invoked': {
-        topic: function (r) {
-          var callback = this.callback;
-
-          // This timeout allows a few extra ticks so that without the wait in
-          // the wrapper this test should fail.
-          setTimeout(function () {
-            promisePending(r.testPromise, function (pending) {
-              r.promiseIsPending = pending;
-              callback(r);
-            });
-          }, 10);
-        },
-        'promise is pending': function (r) {
-          assert.isTrue(r.promiseIsPending);
-        },
-        'after promise resolved': {
-          topic: function (r) {
-            var callback = this.callback;
-
-            r.testPromise.then(function (value) {
-              assert.equal(value, 'done');
-              callback(r);
-            });
-          },
-          'sends message before exit': function (r) {
-            var requestStub = r.requestStub;
-
-            // If the handler is allowed to exit prematurely, this will fail.
-            assert.isTrue(requestStub.called);
-            var data = requestStub.getCall(0).args[0];
-            assert.equal(data.body.message.body, 'lambda test message');
-
-            requestStub.reset();
-          },
-        },
-      },
-    },
-  })
-  .addBatch({
-    'async handler catches exception': {
-      topic: function () {
-        var rollbar = new Rollbar({
-          accessToken: 'abc123',
-          captureUncaught: true,
-          captureLambdaTimeouts: false,
-        });
-        var api = rollbar.client.notifier.queue.api;
-        rollbar.requestStub = sinon
-          .stub(api, 'postItem')
-          .callsFake(fakePostItem);
-
-        rollbar.testHandlerInstance = rollbar.lambdaHandler(
-          async (_event, _context) => {
-            // Testing the condition where the client handler throws.
-            // The Rollbar wrapper should catch and report, and should not reject
-            // until the API request has completed.
-            throw new Error('lambda test error');
-          },
-        );
-
-        return rollbar;
-      },
-      'invokes handler and receives promise': function (r) {
-        var handler = r.testHandlerInstance;
-
-        // rollbar.lambdaHandler in the above topic should have returned a
-        // handler with the correct signature. (The callback handler is length = 3)
-        assert.equal(handler.length, 2);
-        assert.equal(handler.name, 'rollbarAsyncLambdaHandler');
-
-        // The rollbar.wait() in the wrapper should prevent this from
-        // resolving until the response is received.
-        r.testPromise = handler({}, stubContext);
-      },
-      'after handler invoked': {
-        topic: function (r) {
-          var callback = this.callback;
-
-          promisePending(r.testPromise, function (pending) {
-            r.promiseIsPending = pending;
-            callback(r);
-          });
-        },
-        'promise is pending': function (r) {
-          assert.isTrue(r.promiseIsPending);
-        },
-        'after promise rejected': {
-          topic: function (r) {
-            var callback = this.callback;
-
-            r.testPromise.catch(function (error) {
-              assert.equal(error.message, 'lambda test error');
-              callback(r);
-            });
-          },
-          'sends message before exit': function (r) {
-            var requestStub = r.requestStub;
-
-            // If the handler is allowed to exit prematurely, this will fail.
-            assert.isTrue(requestStub.called);
-            var data = requestStub.getCall(0).args[0];
-            assert.equal(
-              data.body.trace_chain[0].exception.message,
-              'lambda test error',
-            );
-
-            requestStub.reset();
-          },
-        },
-      },
-    },
-  })
-  .export(module, { error: false });