rollbar 2.26.2 → 2.26.4

package/src/server/telemetry.js

@@ -1,13 +1,14 @@
 var http = require('http');
 var https = require('https');
 var _ = require('../utility');
+var replace = require('../utility/replace');
 var urlHelpers = require('./telemetry/urlHelpers');
 
 var defaults = {
   network: true,
   networkResponseHeaders: false,
   networkRequestHeaders: false,
-  log: true
+  log: true,
 };
 
 function Instrumenter(options, telemeter, rollbar) {
@@ -26,11 +27,11 @@ function Instrumenter(options, telemeter, rollbar) {
   this.diagnostic = rollbar.client.notifier.diagnostic;
   this.replacements = {
     network: [],
-    log: []
+    log: [],
   };
 }
 
-Instrumenter.prototype.configure = function(options) {
+Instrumenter.prototype.configure = function (options) {
   this.options = _.merge(this.options, options);
   var autoInstrument = options.autoInstrument;
   var oldSettings = _.merge(this.autoInstrument);
@@ -45,10 +46,14 @@ Instrumenter.prototype.configure = function(options) {
   this.instrument(oldSettings);
 };
 
-Instrumenter.prototype.instrument = function(oldSettings) {
+Instrumenter.prototype.instrument = function (oldSettings) {
   if (this.autoInstrument.network && !(oldSettings && oldSettings.network)) {
     this.instrumentNetwork();
-  } else if (!this.autoInstrument.network && oldSettings && oldSettings.network) {
+  } else if (
+    !this.autoInstrument.network &&
+    oldSettings &&
+    oldSettings.network
+  ) {
     this.deinstrumentNetwork();
   }
 
@@ -59,20 +64,32 @@ Instrumenter.prototype.instrument = function(oldSettings) {
   }
 };
 
-Instrumenter.prototype.deinstrumentNetwork = function() {
+Instrumenter.prototype.deinstrumentNetwork = function () {
   restore(this.replacements, 'network');
 };
 
-Instrumenter.prototype.instrumentNetwork = function() {
-  replace(http, 'request', networkRequestWrapper.bind(this), this.replacements, 'network');
-  replace(https, 'request', networkRequestWrapper.bind(this), this.replacements, 'network');
+Instrumenter.prototype.instrumentNetwork = function () {
+  replace(
+    http,
+    'request',
+    networkRequestWrapper.bind(this),
+    this.replacements,
+    'network',
+  );
+  replace(
+    https,
+    'request',
+    networkRequestWrapper.bind(this),
+    this.replacements,
+    'network',
+  );
 };
 
 function networkRequestWrapper(orig) {
   var telemeter = this.telemeter;
   var self = this;
 
-  return function(url, options, cb) {
+  return function (url, options, cb) {
     var mergedOptions = urlHelpers.mergeOptions(url, options, cb);
 
     var metadata = {
@@ -80,7 +97,7 @@ function networkRequestWrapper(orig) {
       url: urlHelpers.constructUrl(mergedOptions.options),
       status_code: null,
       start_time_ms: _.now(),
-      end_time_ms: null
+      end_time_ms: null,
     };
 
     if (self.autoInstrument.networkRequestHeaders) {
@@ -90,20 +107,24 @@ function networkRequestWrapper(orig) {
 
     // Call the original method with the original arguments and wrapped callback.
     var wrappedArgs = Array.from(arguments);
-    var wrappedCallback = responseCallbackWrapper(self.autoInstrument, metadata, mergedOptions.cb);
+    var wrappedCallback = responseCallbackWrapper(
+      self.autoInstrument,
+      metadata,
+      mergedOptions.cb,
+    );
     if (mergedOptions.cb) {
       wrappedArgs.pop();
     }
     wrappedArgs.push(wrappedCallback);
     var req = orig.apply(https, wrappedArgs);
 
-    req.on('error', err => {
+    req.on('error', (err) => {
       metadata.status_code = 0;
-      metadata.error = [err.name, err.message].join(': ') ;
+      metadata.error = [err.name, err.message].join(': ');
     });
 
     return req;
-  }
+  };
 }
 
 function responseCallbackWrapper(options, metadata, callback) {
@@ -118,51 +139,53 @@ function responseCallbackWrapper(options, metadata, callback) {
     if (callback) {
       return callback.apply(undefined, arguments);
     }
-  }
+  };
 }
 
-Instrumenter.prototype.captureNetwork = function(metadata, subtype, rollbarUUID) {
+Instrumenter.prototype.captureNetwork = function (
+  metadata,
+  subtype,
+  rollbarUUID,
+) {
   return this.telemeter.captureNetwork(metadata, subtype, rollbarUUID);
 };
 
-Instrumenter.prototype.deinstrumentConsole = function() {
+Instrumenter.prototype.deinstrumentConsole = function () {
   restore(this.replacements, 'log');
 };
 
-Instrumenter.prototype.instrumentConsole = function() {
+Instrumenter.prototype.instrumentConsole = function () {
   var telemeter = this.telemeter;
 
   var stdout = process.stdout;
-  replace(stdout, 'write', function(orig) {
-    return function(string) {
-      telemeter.captureLog(string, 'info');
-      return orig.apply(stdout, arguments);
-    }
-  }, this.replacements, 'log');
+  replace(
+    stdout,
+    'write',
+    function (orig) {
+      return function (string) {
+        telemeter.captureLog(string, 'info');
+        return orig.apply(stdout, arguments);
+      };
+    },
+    this.replacements,
+    'log',
+  );
 
   var stderr = process.stderr;
-  replace(stderr, 'write', function(orig) {
-    return function(string) {
-      telemeter.captureLog(string, 'error');
-      return orig.apply(stderr, arguments);
-    }
-  }, this.replacements, 'log');
+  replace(
+    stderr,
+    'write',
+    function (orig) {
+      return function (string) {
+        telemeter.captureLog(string, 'error');
+        return orig.apply(stderr, arguments);
+      };
+    },
+    this.replacements,
+    'log',
+  );
 };
 
-// TODO: These helpers are duplicated in src/browser/telemetry.js,
-// and may be candidates for extraction into a shared module.
-// It is recommended that before doing so, the author should allow
-// for more telemetry types to be implemented for the Node target
-// to ensure that the implementations of these helpers don't diverge.
-// If they do diverge, there's little point in the shared module.
-function replace(obj, name, replacement, replacements, type) {
-  var orig = obj[name];
-  obj[name] = replacement(orig);
-  if (replacements) {
-    replacements[type].push([obj, name, orig]);
-  }
-}
-
 function restore(replacements, type) {
   var b;
   while (replacements[type].length) {

package/src/server/transforms.js

@@ -6,7 +6,8 @@ var _ = require('../utility');
 var scrub = require('../scrub');
 
 function baseData(item, options, callback) {
-  var environment = (options.payload && options.payload.environment) || options.environment;
+  var environment =
+    (options.payload && options.payload.environment) || options.environment;
   var data = {
     timestamp: Math.round(item.timestamp / 1000),
     environment: item.environment || environment,
@@ -15,7 +16,7 @@ function baseData(item, options, callback) {
     framework: item.framework || options.framework,
     uuid: item.uuid,
     notifier: JSON.parse(JSON.stringify(options.notifier)),
-    custom: item.custom
+    custom: item.custom,
   };
 
   if (options.codeVersion) {
@@ -34,7 +35,7 @@ function baseData(item, options, callback) {
   data.server = {
     host: options.host,
     argv: process.argv.concat(),
-    pid: process.pid
+    pid: process.pid,
   };
 
   if (options.branch) {
@@ -53,7 +54,7 @@ function addMessageData(item, options, callback) {
   item.data.body = item.data.body || {};
   var message = item.message || 'Item sent with null or missing arguments.';
   item.data.body.message = {
-    body: message
+    body: message,
   };
   callback(null, item);
 }
@@ -93,9 +94,13 @@ function handleItemWithError(item, options, callback) {
     _.addErrorContext(item, errors);
   }
 
-  var cb = function(e) {
+  var cb = function (e) {
     if (e) {
-      item.message = item.err.message || item.err.description || item.message || String(item.err);
+      item.message =
+        item.err.message ||
+        item.err.description ||
+        item.message ||
+        String(item.err);
       item.diagnostic.buildTraceData = e.message;
       delete item.stackInfo;
     }
@@ -129,11 +134,13 @@ function addRequestData(item, options, callback) {
 
   if (req.route) {
     routePath = req.route.path;
-    item.data.context = baseUrl && baseUrl.length ? baseUrl + routePath : routePath;
+    item.data.context =
+      baseUrl && baseUrl.length ? baseUrl + routePath : routePath;
   } else {
     try {
       routePath = req.app._router.matchRequest(req).path;
-      item.data.context = baseUrl && baseUrl.length ? baseUrl + routePath : routePath;
+      item.data.context =
+        baseUrl && baseUrl.length ? baseUrl + routePath : routePath;
     } catch (ignore) {
       // Ignored
     }
@@ -151,7 +158,7 @@ function addRequestData(item, options, callback) {
     }
     item.data.person = person;
   } else if (req.user) {
-    item.data.person = {id: req.user.id};
+    item.data.person = { id: req.user.id };
     if (req.user.username && captureUsername) {
       item.data.person.username = req.user.username;
     }
@@ -163,7 +170,7 @@ function addRequestData(item, options, callback) {
     if (_.isFunction(userId)) {
       userId = userId();
     }
-    item.data.person = {id: userId};
+    item.data.person = { id: userId };
   }
 
   callback(null, item);
@@ -182,7 +189,7 @@ function addLambdaData(item, options, callback) {
     functionName: c.functionName,
     functionVersion: c.functionVersion,
     arn: c.invokedFunctionArn,
-    requestId: c.awsRequestId
+    requestId: c.awsRequestId,
   };
 
   item.data = item.data || {};
@@ -206,7 +213,9 @@ function scrubPayload(item, options, callback) {
 }
 
 function parseRequestBody(req, options) {
-  if (!req || !options.scrubRequestBody) { return }
+  if (!req || !options.scrubRequestBody) {
+    return;
+  }
 
   try {
     if (_.isString(req.body) && _isJsonContentType(req)) {
@@ -219,7 +228,9 @@ function parseRequestBody(req, options) {
 }
 
 function serializeRequestBody(req, options) {
-  if (!req || !options.scrubRequestBody) { return }
+  if (!req || !options.scrubRequestBody) {
+    return;
+  }
 
   try {
     if (_.isObject(req.body) && _isJsonContentType(req)) {
@@ -234,11 +245,15 @@ function serializeRequestBody(req, options) {
 /** Helpers **/
 
 function _isJsonContentType(req) {
-  return req.headers && req.headers['content-type'] && req.headers['content-type'].includes('json');
+  return (
+    req.headers &&
+    req.headers['content-type'] &&
+    req.headers['content-type'].includes('json')
+  );
 }
 
 function _buildTraceData(chain, options, item) {
-  return function(ex, cb) {
+  return function (ex, cb) {
     parser.parseException(ex, options, item, function (err, errData) {
       if (err) {
         return cb(err);
@@ -248,8 +263,8 @@ function _buildTraceData(chain, options, item) {
         frames: errData.frames,
         exception: {
           class: errData['class'],
-          message: errData.message
-        }
+          message: errData.message,
+        },
       });
 
       return cb(null);
@@ -268,11 +283,12 @@ function _extractIp(req) {
 function _buildRequestData(req) {
   var headers = req.headers || {};
   var host = headers.host || '<no host>';
-  var proto = req.protocol || ((req.socket && req.socket.encrypted) ? 'https' : 'http' );
+  var proto =
+    req.protocol || (req.socket && req.socket.encrypted ? 'https' : 'http');
   var parsedUrl;
   var baseUrl = req.baseUrl || '';
   if (_.isType(req.url, 'string')) {
-    var fullUrl = baseUrl && baseUrl.length ? baseUrl + req.url : req.url
+    var fullUrl = baseUrl && baseUrl.length ? baseUrl + req.url : req.url;
     parsedUrl = url.parse(fullUrl, true);
   } else {
     parsedUrl = req.url || {};
@@ -284,7 +300,7 @@ function _buildRequestData(req) {
     url: reqUrl,
     user_ip: _extractIp(req),
     headers: headers,
-    method: req.method
+    method: req.method,
   };
   if (parsedUrl.search && parsedUrl.search.length > 0) {
     data.GET = parsedUrl.query;
@@ -315,5 +331,5 @@ module.exports = {
   addErrorData: addErrorData,
   addRequestData: addRequestData,
   addLambdaData: addLambdaData,
-  scrubPayload: scrubPayload
+  scrubPayload: scrubPayload,
 };

package/src/server/transport.js

@@ -28,10 +28,16 @@ function Transport() {
   this.rateLimitExpires = 0;
 }
 
-Transport.prototype.get = function(accessToken, options, params, callback, transportFactory) {
+Transport.prototype.get = function (
+  accessToken,
+  options,
+  params,
+  callback,
+  transportFactory,
+) {
   var t;
   if (!callback || !_.isFunction(callback)) {
-    callback = function() {};
+    callback = function () {};
   }
   options = options || {};
   _.addParamsAndAccessTokenToPath(accessToken, options, params);
@@ -42,22 +48,33 @@ Transport.prototype.get = function(accessToken, options, params, callback, trans
     t = _transport(options);
   }
   if (!t) {
-    logger.error('Unknown transport based on given protocol: ' + options.protocol);
+    logger.error(
+      'Unknown transport based on given protocol: ' + options.protocol,
+    );
     return callback(new Error('Unknown transport'));
   }
-  var req = t.request(options, function(resp) {
-    this.handleResponse(resp, callback);
-  }.bind(this));
-  req.on('error', function(err) {
+  var req = t.request(
+    options,
+    function (resp) {
+      this.handleResponse(resp, callback);
+    }.bind(this),
+  );
+  req.on('error', function (err) {
     callback(err);
   });
   req.end();
-}
-
-Transport.prototype.post = function(accessToken, options, payload, callback, transportFactory) {
+};
+
+Transport.prototype.post = function (
+  accessToken,
+  options,
+  payload,
+  callback,
+  transportFactory,
+) {
   var t;
   if (!callback || !_.isFunction(callback)) {
-    callback = function() {};
+    callback = function () {};
   }
   if (_currentTime() < this.rateLimitExpires) {
     return callback(new Error('Exceeded rate limit'));
@@ -79,47 +96,55 @@ Transport.prototype.post = function(accessToken, options, payload, callback, tra
     t = _transport(options);
   }
   if (!t) {
-    logger.error('Unknown transport based on given protocol: ' + options.protocol);
+    logger.error(
+      'Unknown transport based on given protocol: ' + options.protocol,
+    );
     return callback(new Error('Unknown transport'));
   }
-  var req = t.request(options, function(resp) {
-    this.handleResponse(resp, _wrapPostCallback(callback));
-  }.bind(this));
-  req.on('error', function(err) {
+  var req = t.request(
+    options,
+    function (resp) {
+      this.handleResponse(resp, _wrapPostCallback(callback));
+    }.bind(this),
+  );
+  req.on('error', function (err) {
     callback(err);
   });
   if (writeData) {
     req.write(writeData);
   }
   req.end();
-}
+};
 
-Transport.prototype.updateRateLimit = function(resp) {
+Transport.prototype.updateRateLimit = function (resp) {
   var remaining = parseInt(resp.headers['x-rate-limit-remaining'] || 0);
-  var remainingSeconds = Math.min(MAX_RATE_LIMIT_INTERVAL, resp.headers['x-rate-limit-remaining-seconds'] || 0);
+  var remainingSeconds = Math.min(
+    MAX_RATE_LIMIT_INTERVAL,
+    resp.headers['x-rate-limit-remaining-seconds'] || 0,
+  );
   var currentTime = _currentTime();
 
-  if ((resp.statusCode === 429) && (remaining === 0)) {
+  if (resp.statusCode === 429 && remaining === 0) {
     this.rateLimitExpires = currentTime + remainingSeconds;
   } else {
     this.rateLimitExpires = currentTime;
   }
-}
+};
 
-Transport.prototype.handleResponse = function(resp, callback) {
+Transport.prototype.handleResponse = function (resp, callback) {
   this.updateRateLimit(resp);
 
   var respData = [];
   resp.setEncoding('utf8');
-  resp.on('data', function(chunk) {
+  resp.on('data', function (chunk) {
     respData.push(chunk);
   });
 
-  resp.on('end', function() {
+  resp.on('end', function () {
     respData = respData.join('');
     _parseApiResponse(respData, callback);
   });
-}
+};
 
 /** Helpers **/
 
@@ -138,7 +163,7 @@ function _headers(accessToken, options, data) {
 }
 
 function _transport(options) {
-  return {'http:': http, 'https:': https}[options.protocol];
+  return { 'http:': http, 'https:': https }[options.protocol];
 }
 
 function _parseApiResponse(data, callback) {
@@ -151,27 +176,32 @@ function _parseApiResponse(data, callback) {
 
   if (data.err) {
     logger.error('Received error: ' + data.message);
-    return callback(new Error('Api error: ' + (data.message || 'Unknown error')));
+    return callback(
+      new Error('Api error: ' + (data.message || 'Unknown error')),
+    );
   }
 
   callback(null, data);
 }
 
 function _wrapPostCallback(callback) {
-  return function(err, data) {
+  return function (err, data) {
     if (err) {
       return callback(err);
     }
     if (data.result && data.result.uuid) {
-      logger.log([
+      logger.log(
+        [
           'Successful api response.',
-          ' Link: https://rollbar.com/occurrence/uuid/?uuid=' + data.result.uuid
-      ].join(''));
+          ' Link: https://rollbar.com/occurrence/uuid/?uuid=' +
+            data.result.uuid,
+        ].join(''),
+      );
     } else {
       logger.log('Successful api response');
     }
     callback(null, data.result);
-  }
+  };
 }
 
 function _currentTime() {