rollbar 2.26.3 → 2.26.4

package/test/server.telemetry.test.js

@@ -9,9 +9,11 @@ var https = require('https');
 
 process.env.NODE_ENV = process.env.NODE_ENV || 'test-node-env';
 var Rollbar = require('../src/server/rollbar');
+var { mergeOptions } = require('../src/server/telemetry/urlHelpers');
+const { URL } = require('url');
 
 function wait(ms) {
-  return new Promise(resolve => {
+  return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
 }
@@ -31,14 +33,16 @@ async function message(rollbar) {
 }
 
 function request(transport, url, options, body) {
-  return new Promise ((resolve, reject) => {
-    var req = url ? transport.request(url, options) : transport.request(options);
+  return new Promise((resolve, reject) => {
+    var req = url
+      ? transport.request(url, options)
+      : transport.request(options);
 
-    req.on('response', res => {
+    req.on('response', (res) => {
       resolve(res);
     });
 
-    req.on('error', err => {
+    req.on('error', (err) => {
       reject(err);
     });
 
@@ -51,12 +55,12 @@ function request(transport, url, options, body) {
 }
 
 function requestWithCallback(transport, options, body) {
-  return new Promise ((resolve, reject) => {
-    var req = transport.request(options, function(res){
+  return new Promise((resolve, reject) => {
+    var req = transport.request(options, function (res) {
       resolve(res);
     });
 
-    req.on('error', err => {
+    req.on('error', (err) => {
       reject(err);
     });
 
@@ -69,61 +73,77 @@ function requestWithCallback(transport, options, body) {
 }
 
 function stubPostWithResponse(url, status, headers, body) {
-  return nock(url)
-  .post('/api/users')
-  .reply(status, body, headers);
+  return nock(url).post('/api/users').reply(status, body, headers);
 }
 
 function stubGetWithResponse(url, status, headers, body) {
-  return nock(url)
-  .get('/api/users')
-  .reply(status, body, headers);
+  return nock(url).get('/api/users').reply(status, body, headers);
 }
 
 function stubGetWithError(url) {
-  return nock(url)
-  .get('/api/users')
-  .replyWithError('dns error');
+  return nock(url).get('/api/users').replyWithError('dns error');
 }
 
-var testHeaders1 = { 'Content-Type': 'application/json', 'X-access-token': '123' }
-var testHeaders2 = { 'authorization': 'abc', foo: '456' }
-var testHeaders3 = { 'content-type': 'application/json', foo: '123' }
-var testHeaders4 = { 'authorization': 'abc', bar: '456' }
+var testHeaders1 = {
+  'Content-Type': 'application/json',
+  'X-access-token': '123',
+};
+var testHeaders2 = { authorization: 'abc', foo: '456' };
+var testHeaders3 = { 'content-type': 'application/json', foo: '123' };
+var testHeaders4 = { authorization: 'abc', bar: '456' };
 var testBody1 = 'test body 1';
 var testBody2 = 'test body 2';
 var testMessage1 = 'test console message';
 var testMessage2 = 'test console error message';
 var testMessagePart = ', extra part';
 
-vows.describe('telemetry')
+vows
+  .describe('telemetry')
   .addBatch({
     'with log and network capture enabled': {
-      topic: function() {
+      topic: function () {
         var rollbar = new Rollbar({
           accessToken: 'abc123',
           captureUncaught: true,
-          autoInstrument: true
+          autoInstrument: true,
         });
         rollbar.testData = {};
         var notifier = rollbar.client.notifier;
         rollbar.testData.addItemStub = sinon.stub(notifier.queue, 'addItem');
-        rollbar.testData.getStub = stubGetWithResponse('http://example.com',  200, testHeaders3, testBody1);
-        rollbar.testData.postStub = stubPostWithResponse('https://example.com', 201, testHeaders4, testBody2);
-
-        var func = async function(callback) {
+        rollbar.testData.getStub = stubGetWithResponse(
+          'http://example.com',
+          200,
+          testHeaders3,
+          testBody1,
+        );
+        rollbar.testData.postStub = stubPostWithResponse(
+          'https://example.com',
+          201,
+          testHeaders4,
+          testBody2,
+        );
+
+        var func = async function (callback) {
           // Invoke telemetry events
           console.info(testMessage1, testMessagePart);
-          rollbar.testData.response1 = await request(http, 'http://example.com/api/users', { method: 'GET', headers: testHeaders1 });
+          rollbar.testData.response1 = await request(
+            http,
+            'http://example.com/api/users',
+            { method: 'GET', headers: testHeaders1 },
+          );
           console.error(testMessage2);
-          rollbar.testData.response2 = await request(https, 'https://example.com/api/users', { method: 'POST', headers: testHeaders2 });
+          rollbar.testData.response2 = await request(
+            https,
+            'https://example.com/api/users',
+            { method: 'POST', headers: testHeaders2 },
+          );
 
           await uncaught(rollbar);
           callback(rollbar);
-        }
+        };
         func(this.callback);
       },
-      'exception payload should have telemetry': function(r) {
+      'exception payload should have telemetry': function (r) {
         var addItemStub = r.testData.addItemStub;
         var response1 = r.testData.response1;
         var response2 = r.testData.response2;
@@ -140,23 +160,35 @@ vows.describe('telemetry')
         // Verify telemetry items and order
         assert.deepStrictEqual(telemetry[0].level, 'info');
         assert.deepStrictEqual(telemetry[0].type, 'log');
-        assert.deepStrictEqual(telemetry[0].body.message, 'test console message , extra part\n');
+        assert.deepStrictEqual(
+          telemetry[0].body.message,
+          'test console message , extra part\n',
+        );
 
         assert.deepStrictEqual(telemetry[1].level, 'info');
         assert.deepStrictEqual(telemetry[1].type, 'network');
         assert.deepStrictEqual(telemetry[1].body.method, 'GET');
-        assert.deepStrictEqual(telemetry[1].body.url, 'http://example.com/api/users');
+        assert.deepStrictEqual(
+          telemetry[1].body.url,
+          'http://example.com/api/users',
+        );
         assert.deepStrictEqual(telemetry[1].body.status_code, 200);
         assert.deepStrictEqual(telemetry[1].body.subtype, 'http');
 
         assert.deepStrictEqual(telemetry[2].level, 'error');
         assert.deepStrictEqual(telemetry[2].type, 'log');
-        assert.deepStrictEqual(telemetry[2].body.message, 'test console error message\n');
+        assert.deepStrictEqual(
+          telemetry[2].body.message,
+          'test console error message\n',
+        );
 
         assert.deepStrictEqual(telemetry[3].level, 'info');
         assert.deepStrictEqual(telemetry[3].type, 'network');
         assert.deepStrictEqual(telemetry[3].body.method, 'POST');
-        assert.deepStrictEqual(telemetry[3].body.url, 'https://example.com/api/users');
+        assert.deepStrictEqual(
+          telemetry[3].body.url,
+          'https://example.com/api/users',
+        );
         assert.deepStrictEqual(telemetry[3].body.status_code, 201);
         assert.deepStrictEqual(telemetry[3].body.subtype, 'http');
 
@@ -167,81 +199,129 @@ vows.describe('telemetry')
         assert.deepEqual(telemetry[3].body.response.headers, undefined);
 
         addItemStub.restore();
-      }
-    }
+      },
+    },
   })
   .addBatch({
     'with log and network capture enabled with headers enabled': {
-      topic: function() {
+      topic: function () {
         var rollbar = new Rollbar({
           accessToken: 'abc123',
           captureUncaught: true,
           autoInstrument: {
             network: true,
             networkResponseHeaders: true,
-            networkRequestHeaders: true
-          }
+            networkRequestHeaders: true,
+          },
         });
         rollbar.testData = {};
         var notifier = rollbar.client.notifier;
         rollbar.testData.addItemStub = sinon.stub(notifier.queue, 'addItem');
-        rollbar.testData.getStub = stubGetWithResponse('https://example.com', 200, testHeaders3, testBody1);
-        rollbar.testData.postStub = stubPostWithResponse('http://example.com', 201, testHeaders4, testBody2);
-
-        var func = async function(callback) {
+        rollbar.testData.getStub = stubGetWithResponse(
+          'https://example.com',
+          200,
+          testHeaders3,
+          testBody1,
+        );
+        rollbar.testData.postStub = stubPostWithResponse(
+          'http://example.com',
+          201,
+          testHeaders4,
+          testBody2,
+        );
+
+        var func = async function (callback) {
           // Invoke telemetry events
           console.info(testMessage1, testMessagePart);
-          rollbar.testData.response1 = await request(https, 'https://example.com/api/users', { method: 'GET', headers: testHeaders1 });
+          rollbar.testData.response1 = await request(
+            https,
+            'https://example.com/api/users',
+            { method: 'GET', headers: testHeaders1 },
+          );
           console.error(testMessage2);
-          rollbar.testData.response2 = await request(http, 'http://example.com/api/users', { method: 'POST', headers: testHeaders2 });
+          rollbar.testData.response2 = await request(
+            http,
+            'http://example.com/api/users',
+            { method: 'POST', headers: testHeaders2 },
+          );
 
           await message(rollbar);
           callback(rollbar);
-        }
+        };
         func(this.callback);
       },
-      'message payload should have telemetry': function(r) {
+      'message payload should have telemetry': function (r) {
         var addItemStub = r.testData.addItemStub;
 
         assert.isTrue(addItemStub.called);
         var telemetry = addItemStub.getCall(0).args[3].data.body.telemetry;
 
         // Verify headers captures, with scrubbing
-        assert.deepStrictEqual(telemetry[1].body.request_headers, { 'Content-Type': 'application/json', 'X-access-token': '********' });
-        assert.deepStrictEqual(telemetry[1].body.response.headers, { 'content-type': 'application/json', foo: '123' });
-        assert.deepStrictEqual(telemetry[3].body.request_headers, { authorization: '********', foo: '456' });
-        assert.deepStrictEqual(telemetry[3].body.response.headers, { authorization: '********', bar: '456' });
+        assert.deepStrictEqual(telemetry[1].body.request_headers, {
+          'Content-Type': 'application/json',
+          'X-access-token': '********',
+        });
+        assert.deepStrictEqual(telemetry[1].body.response.headers, {
+          'content-type': 'application/json',
+          foo: '123',
+        });
+        assert.deepStrictEqual(telemetry[3].body.request_headers, {
+          authorization: '********',
+          foo: '456',
+        });
+        assert.deepStrictEqual(telemetry[3].body.response.headers, {
+          authorization: '********',
+          bar: '456',
+        });
 
         addItemStub.restore();
-      }
-    }
+      },
+    },
   })
   .addBatch({
     'with telemetry disabled': {
-      topic: function() {
+      topic: function () {
         var rollbar = new Rollbar({
           accessToken: 'abc123',
-          captureUncaught: true
+          captureUncaught: true,
         });
         rollbar.testData = {};
         var notifier = rollbar.client.notifier;
         rollbar.testData.addItemStub = sinon.stub(notifier.queue, 'addItem');
-        rollbar.testData.getStub = stubGetWithResponse('https://example.com', 200, testHeaders3, testBody1);
-        rollbar.testData.postStub = stubPostWithResponse('https://example.com', 201, testHeaders4, testBody2);
-
-        var func = async function(callback) {
+        rollbar.testData.getStub = stubGetWithResponse(
+          'https://example.com',
+          200,
+          testHeaders3,
+          testBody1,
+        );
+        rollbar.testData.postStub = stubPostWithResponse(
+          'https://example.com',
+          201,
+          testHeaders4,
+          testBody2,
+        );
+
+        var func = async function (callback) {
           // Invoke telemetry events
           console.info(testMessage1, testMessagePart);
-          rollbar.testData.response1 = await request(https, 'https://example.com/api/users', { method: 'GET', headers: testHeaders1 });
+          rollbar.testData.response1 = await request(
+            https,
+            'https://example.com/api/users',
+            { method: 'GET', headers: testHeaders1 },
+          );
           console.error(testMessage2);
-          rollbar.testData.response2 = await request(https, 'https://example.com/api/users', { method: 'POST', headers: testHeaders2 });
+          rollbar.testData.response2 = await request(
+            https,
+            'https://example.com/api/users',
+            { method: 'POST', headers: testHeaders2 },
+          );
 
           await message(rollbar);
           callback(rollbar);
-        }
+        };
         func(this.callback);
       },
-      'payload should not have telemetry': function(r) {
+      'payload should not have telemetry': function (r) {
         var addItemStub = r.testData.addItemStub;
 
         assert.isTrue(addItemStub.called);
@@ -249,26 +329,26 @@ vows.describe('telemetry')
 
         // Verify telemetry is empty
         assert.deepEqual(telemetry, []);
-      }
-    }
+      },
+    },
   })
   .addBatch({
     'with callback request and error response': {
-      topic: function() {
+      topic: function () {
         var rollbar = new Rollbar({
           accessToken: 'abc123',
           captureUncaught: true,
           autoInstrument: {
             network: true,
             networkResponseHeaders: true,
-            networkRequestHeaders: true
-          }
+            networkRequestHeaders: true,
+          },
         });
         var notifier = rollbar.client.notifier;
         rollbar.testData = {};
         rollbar.testData.addItemStub = sinon.stub(notifier.queue, 'addItem');
 
-        var func = async function(callback) {
+        var func = async function (callback) {
           var options = {
             method: 'GET',
             protocol: 'https:',
@@ -279,18 +359,29 @@ vows.describe('telemetry')
 
           // Invoke telemetry events
           console.info(testMessage1, testMessagePart);
-          rollbar.testData.getStub = stubGetWithResponse('https://example.com', 200, testHeaders3, testBody1);
-          rollbar.testData.response1 = await requestWithCallback(https, options).catch((e) => e);
+          rollbar.testData.getStub = stubGetWithResponse(
+            'https://example.com',
+            200,
+            testHeaders3,
+            testBody1,
+          );
+          rollbar.testData.response1 = await requestWithCallback(
+            https,
+            options,
+          ).catch((e) => e);
           console.error(testMessage2);
           rollbar.testData.errorStub = stubGetWithError('https://example.com');
-          rollbar.testData.response2 = await requestWithCallback(https, options).catch((e) => e);
+          rollbar.testData.response2 = await requestWithCallback(
+            https,
+            options,
+          ).catch((e) => e);
 
           await message(rollbar);
           callback(rollbar);
-        }
+        };
         func(this.callback);
       },
-      'message payload should have telemetry or error info': function(r) {
+      'message payload should have telemetry or error info': function (r) {
         var addItemStub = r.testData.addItemStub;
         var response1 = r.testData.response1;
         var response2 = r.testData.response2;
@@ -304,15 +395,49 @@ vows.describe('telemetry')
         assert(response2 instanceof Error);
 
         // Verify telemetry
-        assert.deepStrictEqual(telemetry[1].body.request_headers, { 'Content-Type': 'application/json', 'X-access-token': '********' });
-        assert.deepStrictEqual(telemetry[1].body.response.headers, { 'content-type': 'application/json', foo: '123' });
-        assert.deepStrictEqual(telemetry[3].body.request_headers, { 'Content-Type': 'application/json', 'X-access-token': '********' });
+        assert.deepStrictEqual(telemetry[1].body.request_headers, {
+          'Content-Type': 'application/json',
+          'X-access-token': '********',
+        });
+        assert.deepStrictEqual(telemetry[1].body.response.headers, {
+          'content-type': 'application/json',
+          foo: '123',
+        });
+        assert.deepStrictEqual(telemetry[3].body.request_headers, {
+          'Content-Type': 'application/json',
+          'X-access-token': '********',
+        });
         assert.deepStrictEqual(telemetry[3].body.response, undefined);
         assert.deepStrictEqual(telemetry[3].body.status_code, 0);
         assert.deepStrictEqual(telemetry[3].body.error, 'Error: dns error');
 
-
         addItemStub.restore();
-      }
-    }
-  }).export(module, {error: false});
+      },
+    },
+  })
+  .addBatch({
+    'while using autoinstrument': {
+      topic: function () {
+        const optionsUsingStringUrl = mergeOptions(
+          'http://example.com/api/users',
+          { method: 'GET', headers: testHeaders1 },
+        );
+        const optionsUsingClassUrl = mergeOptions(
+          new URL('http://example.com/api/users'),
+          { method: 'GET', headers: testHeaders1 },
+        );
+
+        return {
+          optionsUsingStringUrl,
+          optionsUsingClassUrl,
+        };
+      },
+      'mergeOptions should correctly handle URL and options': function ({
+        optionsUsingStringUrl,
+        optionsUsingClassUrl,
+      }) {
+        assert.deepStrictEqual(optionsUsingStringUrl, optionsUsingClassUrl);
+      },
+    },
+  })
+  .export(module, { error: false });