rollbar 2.26.3 → 3.0.0-alpha.1

package/webpack.config.js

@@ -8,154 +8,115 @@ var outputPath = path.resolve(__dirname, 'dist');
 
 var defaultsPlugin = new webpack.DefinePlugin(defaults);
 var uglifyPlugin = new TerserPlugin({
-  parallel: true
+  parallel: true,
 });
 
 var snippetConfig = {
   name: 'snippet',
   entry: {
-    'rollbar.snippet': './src/browser/bundles/rollbar.snippet.js'
+    'rollbar.snippet': './src/browser/bundles/rollbar.snippet.js',
   },
   output: {
     path: outputPath,
-    filename: '[name].js'
+    filename: '[name].js',
   },
   plugins: [defaultsPlugin],
   module: {
     rules: [
       {
-        enforce: 'pre',
         test: /\.js$/,
-        loader: 'eslint-loader',
+        loader: 'babel-loader',
         exclude: [/node_modules/, /vendor/],
-        options: {
-          failOnError: true,
-          configFile: path.resolve(__dirname, '.eslintrc')
-        }
       },
-      {
-        test: /\.js$/,
-        loader: 'strict-loader',
-        exclude: [/node_modules/, /vendor/]
-      }
     ],
-  }
+  },
 };
 
 var pluginConfig = {
   name: 'plugins',
   entry: {
-    'jquery': './src/browser/plugins/jquery.js'
+    jquery: './src/browser/plugins/jquery.js',
   },
   output: {
     path: outputPath + '/plugins/',
-    filename: '[name].min.js'
+    filename: '[name].min.js',
   },
   plugins: [defaultsPlugin],
   module: {
     rules: [
       {
-        enforce: 'pre',
         test: /\.js$/,
-        loader: 'eslint-loader',
+        loader: 'babel-loader',
         exclude: [/node_modules/, /vendor/],
-        options: {
-          failOnError: true,
-          configFile: path.resolve(__dirname, '.eslintrc')
-        }
       },
-      {
-        test: /\.js$/,
-        loader: 'strict-loader',
-        exclude: [/node_modules/, /vendor/]
-      }
     ],
-  }
+  },
 };
 
 var vanillaConfigBase = {
   entry: {
-    'rollbar': './src/browser/bundles/rollbar.js'
+    rollbar: './src/browser/bundles/rollbar.js',
   },
   output: {
-    path: outputPath
+    path: outputPath,
   },
+  target: ['web', 'es5'],
   plugins: [defaultsPlugin],
   devtool: 'hidden-source-map',
   module: {
     rules: [
       {
-        enforce: 'pre',
         test: /\.js$/,
-        loader: 'eslint-loader',
+        loader: 'babel-loader',
         exclude: [/node_modules/, /vendor/],
-        options: {
-          failOnError: true,
-          configFile: path.resolve(__dirname, '.eslintrc')
-        }
       },
-      {
-        test: /\.js$/,
-        loader: 'strict-loader',
-        exclude: [/node_modules/, /vendor/]
-      }
     ],
-  }
+  },
 };
 
 var UMDConfigBase = {
   entry: {
-    'rollbar.umd': ['./src/browser/bundles/rollbar.js']
+    'rollbar.umd': ['./src/browser/bundles/rollbar.js'],
   },
   output: {
     path: outputPath,
     library: 'rollbar',
     libraryTarget: 'umd',
-    globalObject: 'this'
+    globalObject: 'this',
   },
+  target: ['web', 'es5'],
   devtool: 'source-map',
   module: {
     rules: [
       {
-        enforce: 'pre',
         test: /\.js$/,
-        loader: 'eslint-loader',
+        loader: 'babel-loader',
         exclude: [/node_modules/, /vendor/],
-        options: {
-          failOnError: true,
-          configFile: path.resolve(__dirname, '.eslintrc')
-        }
       },
-      {
-        test: /\.js$/,
-        loader: 'strict-loader',
-        exclude: [/node_modules/, /vendor/]
-      }
     ],
-  }
+  },
 };
 
 var noConflictConfigBase = extend({}, UMDConfigBase);
 noConflictConfigBase.entry = {
-  'rollbar.noconflict.umd': ['./src/browser/bundles/rollbar.noconflict.js']
+  'rollbar.noconflict.umd': ['./src/browser/bundles/rollbar.noconflict.js'],
 };
 
 var namedAMDConfigBase = extend({}, UMDConfigBase);
 namedAMDConfigBase.entry = {
-  'rollbar.named-amd': namedAMDConfigBase.entry['rollbar.umd']
+  'rollbar.named-amd': namedAMDConfigBase.entry['rollbar.umd'],
 };
 namedAMDConfigBase.output = extend({}, namedAMDConfigBase.output);
 namedAMDConfigBase.output.library = 'rollbar';
 namedAMDConfigBase.output.libraryTarget = 'amd';
 
-
 var config = [snippetConfig, pluginConfig];
 
 function optimizationConfig(minimizer) {
   return {
     minimize: minimizer ? true : false,
-    minimizer: minimizer ? [minimizer] : []
-  }
+    minimizer: minimizer ? [minimizer] : [],
+  };
 }
 
 function addVanillaToConfig(webpackConfig, filename, extraPlugins, minimizer) {
@@ -168,7 +129,7 @@ function addVanillaToConfig(webpackConfig, filename, extraPlugins, minimizer) {
 
   vanillaConfig.optimization = optimizationConfig(minimizer);
 
-  vanillaConfig.output = extend({filename: filename}, vanillaConfig.output);
+  vanillaConfig.output = extend({ filename: filename }, vanillaConfig.output);
 
   webpackConfig.push(vanillaConfig);
 }
@@ -182,13 +143,17 @@ function addUMDToConfig(webpackConfig, filename, extraPlugins, minimizer) {
 
   UMDConfig.optimization = optimizationConfig(minimizer);
 
-  UMDConfig.output = extend({filename: filename}, UMDConfig.output);
+  UMDConfig.output = extend({ filename: filename }, UMDConfig.output);
 
   webpackConfig.push(UMDConfig);
 }
 
-
-function addNoConflictToConfig(webpackConfig, filename, extraPlugins, minimizer) {
+function addNoConflictToConfig(
+  webpackConfig,
+  filename,
+  extraPlugins,
+  minimizer,
+) {
   var basePlugins = [defaultsPlugin];
   var noConflictConfig = extend({}, noConflictConfigBase);
 
@@ -197,12 +162,14 @@ function addNoConflictToConfig(webpackConfig, filename, extraPlugins, minimizer)
 
   noConflictConfig.optimization = optimizationConfig(minimizer);
 
-  noConflictConfig.output = extend({filename: filename}, noConflictConfig.output);
+  noConflictConfig.output = extend(
+    { filename: filename },
+    noConflictConfig.output,
+  );
 
   webpackConfig.push(noConflictConfig);
 }
 
-
 function addNamedAMDToConfig(webpackConfig, filename, extraPlugins, minimizer) {
   var basePlugins = [defaultsPlugin];
   var AMDConfig = extend({}, namedAMDConfigBase);
@@ -212,12 +179,11 @@ function addNamedAMDToConfig(webpackConfig, filename, extraPlugins, minimizer) {
 
   AMDConfig.optimization = optimizationConfig(minimizer);
 
-  AMDConfig.output = extend({filename: filename}, AMDConfig.output);
+  AMDConfig.output = extend({ filename: filename }, AMDConfig.output);
 
   webpackConfig.push(AMDConfig);
 }
 
-
 function generateBuildConfig(name, plugins, minimizer) {
   addVanillaToConfig(config, name, plugins, minimizer);
   addUMDToConfig(config, name, plugins, minimizer);

package/.eslintignore

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

package/.gitmodules

@@ -1,3 +0,0 @@
-[submodule "vendor/JSON-js"]
-	path = vendor/JSON-js
-	url = https://github.com/rollbar/JSON-js.git

package/test/server.lambda.test.js

@@ -1,177 +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});