@contrast/agentify 1.0.0 → 1.0.1

package/lib/function-hooks.js

@@ -97,7 +97,7 @@ module.exports = function (deps) {
 
         let result = code;
 
-        if (code.indexOf('ContrastMethods')) {
+        if (code.indexOf('ContrastMethods') > -1) {
           const unwritten = functionHooks.unwrite(code);
           functionHooks.cache.set(data.obj, unwritten);
           result = unwritten;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrast/agentify",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Configures Contrast agent services and instrumentation within an application",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Contrast Security <nodejs@contrastsecurity.com> (https://www.contrastsecurity.com)",

package/lib/contrast-methods.test.js

@@ -1,72 +0,0 @@
-'use strict';
-
-const { expect } = require('chai');
-const sinon = require('sinon');
-
-describe('agentify contrast-methods', function() {
-  let contrastMethods;
-  let core;
-
-  beforeEach(function() {
-    const mocks = require('../../test/mocks');
-    core = mocks.core();
-    core.logger = mocks.logger();
-    contrastMethods = require('./contrast-methods')(core);
-  });
-
-  describe('api.eval()', function() {
-    it('acts as identity function', function() {
-      [{}, null, 1, 'two', undefined].forEach(v => {
-        expect(v).to.equal(contrastMethods.api.eval(v));
-      });
-    });
-  });
-
-  describe('.getGlobal', function() {
-    it('returns global :)', function() {
-      expect(contrastMethods.getGlobal()).to.equal(global);
-    });
-  });
-
-  describe('.install', function() {
-    let globalMock;
-    let contrastMethods;
-
-    beforeEach(function() {
-      contrastMethods = require('./contrast-methods')(core);
-      globalMock = {};
-      sinon.stub(contrastMethods, 'getGlobal').returns(globalMock);
-    });
-
-    it('installs on global', function() {
-      expect(globalMock.ContrastMethods).not.to.exist;
-      contrastMethods.install();
-      expect(globalMock.ContrastMethods).to.exist;
-      expect(() => {
-        delete globalMock.ContrastMethods;
-      }).throw(/Cannot delete property/);
-    });
-
-    it('installs just once', function() {
-      expect(globalMock.ContrastMethods).not.to.exist;
-      contrastMethods.install();
-      contrastMethods.install();
-      expect(globalMock.ContrastMethods).to.equal(contrastMethods.api);
-    });
-
-    describe('installation failure handing', function() {
-      beforeEach(function() {
-        Object.defineProperty(globalMock, 'ContrastMethods', {
-          configurable: false,
-          value: 'does not matter for test'
-        });
-      });
-      it('logs error when global.ContrastMethods cannot be redefined', function() {
-        contrastMethods.install();
-        const [{ err }, description] = core.logger.error.getCall(0).args;
-        expect(description).to.eql('Unable to install global.ContrastMethods');
-        expect(err.message).to.eql('Cannot redefine property: ContrastMethods');
-      });
-    });
-  });
-});

package/lib/function-hooks.test.js

@@ -1,175 +0,0 @@
-'use strict';
-
-const { expect } = require('chai');
-const functionHooks = require('./function-hooks');
-
-describe('agentify function-hooks', function () {
-  let coreMock;
-
-  beforeEach(function () {
-    const mocks = require('../../test/mocks');
-
-    coreMock = mocks.core();
-    coreMock.patcher = mocks.patcher();
-    coreMock.logger = mocks.logger();
-    coreMock.depHooks = mocks.depHooks();
-    coreMock.scopes = mocks.scopes();
-    coreMock.rewriter = mocks.rewriter();
-  });
-
-  it('should install function hooks', function () {
-    functionHooks(coreMock);
-    coreMock.functionHooks.install();
-    expect(coreMock.functionHooks.installed).to.be.true;
-  });
-
-  it('should skip if it is already installed', function () {
-    functionHooks(coreMock);
-    coreMock.functionHooks.installed = true;
-    coreMock.functionHooks.install();
-
-    expect(coreMock.logger.debug).to.not.have.been.called;
-  });
-
-  it('should return cached value when the function is already called', function () {
-    const functionA = function sum(a, b) {
-      eval(global.ContrastMethods.eval('2 + 2'));
-      return a + b;
-    };
-
-    const cachedValue = 'cachedValue';
-
-    functionHooks(coreMock);
-
-    coreMock.functionHooks.cache.set(functionA, cachedValue);
-
-    const data = {
-      obj: functionA,
-    };
-
-    let result;
-    coreMock.patcher.patch.callsFake((prototype, method, options) => {
-      result = options.around(() => ({}), data);
-    });
-
-    coreMock.functionHooks.install();
-
-    expect(result).to.eql(cachedValue);
-  });
-
-  it('should call the function itself when the function is not hooked', function () {
-    const functionA = function sum(a, b) {
-      eval(global.ContrastMethods.eval('2 + 2'));
-      return a + b;
-    };
-
-    functionHooks(coreMock);
-
-    const data = {
-      obj: functionA,
-    };
-
-    let result;
-    coreMock.patcher.patch.callsFake((prototype, method, options) => {
-      result = options.around(functionA.toString.bind(functionA), data);
-    });
-
-    const unwriteResult = `function sum(a, b) {
-      eval(2 + 2);
-      return a + b;
-      }`;
-
-    coreMock.rewriter.unwrite.callsFake((data) => unwriteResult);
-
-    coreMock.functionHooks.install();
-
-    expect(result).to.eql(unwriteResult);
-    expect(coreMock.functionHooks.cache.get(data.obj)).to.eql(unwriteResult);
-  });
-
-  it('should the call the original function of the hooked function', function () {
-    const functionA = function sum(a, b) {
-      eval(global.ContrastMethods.eval('2 + 2'));
-      return a + b;
-    };
-
-    const functionB = function sum(a, b) {
-      eval(global.ContrastMethods.eval('2 + 2'));
-      return a + b + 2;
-    };
-
-    functionHooks(coreMock);
-
-    const weekMap = coreMock.patcher.hookedFunctions;
-    weekMap.set(functionA, { fn: functionB });
-
-    const data = {
-      obj: functionA,
-    };
-
-    let result;
-    coreMock.patcher.patch.callsFake((prototype, method, options) => {
-      result = options.around(functionA.toString.bind(functionA), data);
-    });
-
-    const unwriteResult = `function sum(a, b) {
-      eval(2 + 2);
-      return a + b + 2;
-      }`;
-
-    coreMock.rewriter.unwrite.callsFake((data) => unwriteResult);
-
-
-    coreMock.functionHooks.install();
-
-    expect(result).to.eql(unwriteResult);
-    expect(coreMock.functionHooks.cache.get(data.obj)).to.eql(unwriteResult);
-  });
-
-  it('should log warning message when there is a problem unwriting the code', function () {
-    const err = new Error('Error');
-    const functionA = function sum(a, b) {
-      eval(global.ContrastMethods.eval('2 + 2'));
-      return a + b;
-    };
-
-    functionHooks(coreMock);
-
-    const data = {
-      obj: functionA,
-    };
-
-    coreMock.patcher.patch.callsFake((prototype, method, options) => {
-      options.around(functionA.toString.bind(functionA), data);
-    });
-
-    coreMock.rewriter.unwrite.throws(err);
-
-    coreMock.functionHooks.install();
-
-    expect(coreMock.logger.warn).to.have.been.calledWith({ err, code: functionA.toString() }, 'Failed to unwrite function code');
-  });
-
-  it('should call the original toString if the function is not hooked', function() {
-    const functionA = () => 1;
-    functionHooks(coreMock);
-    coreMock.functionHooks.install();
-
-    const resultOfA = functionA.toString();
-
-    expect(resultOfA).to.eqls('() => 1');
-  });
-
-  it('should uninstall the hooks', function() {
-    const { toString } = Function.prototype;
-    const functionA = () => 1;
-    functionHooks(coreMock);
-    coreMock.functionHooks.install();
-    coreMock.functionHooks.uninstall();
-
-    const resultOfA = functionA.toString();
-
-    expect(resultOfA).to.eqls('() => 1');
-    expect(Function.prototype.toString).to.eqls(toString);
-  });
-});

package/lib/index.test.js

@@ -1,89 +0,0 @@
-'use strict';
-
-const chai = require('chai');
-const { expect } = chai;
-const sinon = require('sinon');
-
-describe('agentify', function() {
-  const Module = require('module');
-  let core;
-  let agentify;
-  let runMain;
-
-  beforeEach(function() {
-    const factory = require('.');
-    const mocks = require('../../test/mocks');
-
-    core = mocks.core();
-    core.logger = mocks.logger();
-    core.depHooks = mocks.depHooks();
-    core.scopes = mocks.scopes();
-    core.patcher = mocks.patcher();
-    agentify = factory(core);
-    runMain = sinon.stub(Module, 'runMain');
-  });
-
-  describe('factory', function() {
-    it('invoking with callback will initialize and patch runMain', async function() {
-      let ranFlag;
-
-      agentify((deps) => {
-        expect(deps).to.equal(core);
-        ranFlag = true;
-      }, {
-        svcList: ['depHooks']
-      });
-
-      await Module.runMain();
-
-      expect(ranFlag).to.be.true;
-      expect(runMain).to.be.called;
-      expect(core.depHooks.install).to.have.been.called;
-      expect(core.logger.error).not.to.been.called;
-    });
-
-    it('will not run install methods opts = { install: false }', async function() {
-      const a = agentify(() => {}, { install: false });
-      sinon.spy(a, 'install');
-
-      await Module.runMain();
-
-      expect(a.install).not.to.have.been.called;
-      expect(core.logger.error).not.called;
-    });
-
-    it('handles errors in pre runMain hook (init)', async function() {
-      const err = new Error('bonk');
-      const a = agentify(() => {
-        throw err;
-      });
-      sinon.spy(a, 'install');
-      sinon.spy(a, 'handleInstallFailure');
-
-      await Module.runMain();
-
-      expect(a.handleInstallFailure).to.have.been.calledWith(err);
-      expect(a.install).to.not.have.been.called;
-      expect(core.logger.error).calledWith({ err }, 'A fatal agent installation error has occurred. The application will be run without instrumentation.');
-    });
-
-    //
-    it('instantiation handles "unregistered" services', async function() {
-      agentify((deps) => 0, {
-        install: true,
-        svcList: ['foo']
-      });
-
-      // Having non-existent service in list is handled during initialization
-      await Module.runMain();
-
-      expect(core.logger.error).not.called;
-    });
-
-    it('requires init function arg', function() {
-      expect(() => {
-        agentify('not a function');
-      }).to.throw('Invalid usage: first argument must be a function');
-    });
-  });
-});

package/lib/instrumentation-locks.test.js

@@ -1,55 +0,0 @@
-'use strict';
-
-const { expect } = require('chai');
-const sinon = require('sinon');
-const Module = require('module');
-const instrumentationLocks = require('./instrumentation-locks');
-const mocks = require('../../test/mocks');
-
-describe('agentify instrumentation-locks', function () {
-  let core, storeSpy;
-
-  beforeEach(function () {
-    core = mocks.core();
-    core.logger = mocks.logger();
-    core.scopes = require('@contrast/scopes')(core);
-    core.patcher = require('@contrast/patcher')(core);
-    storeSpy = sinon.stub();
-
-    const origRequire = Module.prototype.require;
-    sinon.stub(Module.prototype, 'require').callsFake(function (...args) {
-      storeSpy(core.scopes.instrumentation.getStore());
-      return origRequire.call(this, ...args);
-    });
-
-    instrumentationLocks(core);
-    core.instrumentationLocks.install();
-  });
-
-  it('require gets called with instrumentation locked', function () {
-    // side effects are in place for this to exercise properly
-    require('crypto');
-    expect(storeSpy).to.have.been.calledWith({
-      lock: true,
-      name: 'Module.prototype.require',
-    });
-  });
-
-  it('will not run with lock if already locked', function () {
-    // side effects are in place for this to exercise properly
-    core.scopes.instrumentation.run({ lock: true, name: 'test' }, () => {
-      // target here is arbitrary
-      require('events');
-
-      expect(storeSpy).to.have.been.calledWith({
-        lock: true,
-        name: 'test',
-      });
-
-      expect(storeSpy).to.not.have.been.calledWith({
-        lock: true,
-        name: 'Module.prototype.require',
-      });
-    });
-  });
-});

package/lib/rewrite-hooks.test.js

@@ -1,76 +0,0 @@
-'use strict';
-
-const sinon = require('sinon');
-const { expect } = require('chai');
-const Module = require('module');
-
-const testCode = require.resolve('../test/resources/file');
-
-describe('agentify rewrite-hooks', function() {
-  let core, rewriteHooks, origCompileSpy;
-
-  beforeEach(function() {
-    const mocks = require('../../test/mocks');
-    core = mocks.core();
-    core.logger = mocks.logger();
-    core.agentify = mocks.agentify();
-    core.config = mocks.config();
-    core.config.agent.node.enable_rewrite = true;
-    core.rewriter = mocks.rewriter();
-    origCompileSpy = sinon.spy(Module.prototype, '_compile');
-    rewriteHooks = require('./rewrite-hooks')(core);
-    rewriteHooks.install();
-  });
-
-  afterEach(function() {
-    delete require.cache[testCode];
-    rewriteHooks.restore();
-  });
-
-  it('Should not rewrite code when enable_rewrite is false', function() {
-    sinon.restore();
-    core.config.agent.node.enable_rewrite = false;
-    rewriteHooks = require('./rewrite-hooks')(core);
-    rewriteHooks.install();
-    require('../test/resources/file');
-    expect(core.rewriter.rewrite).to.not.have.been.called;
-  });
-
-  it('Should rewrite code', function() {
-    require('../test/resources/file');
-    expect(core.rewriter.rewrite).to.have.been.calledWith(
-      sinon.match.string,
-      { filename: testCode }
-    );
-    expect(core.logger.error).to.not.have.been.called;
-    expect(origCompileSpy).to.have.been.calledWith(
-      "const ContrastMethods = global.ContrastMethods\n/* eslint-disable */\n'use strict'\nconst variable = 'variable';\n",
-      testCode
-    );
-  });
-
-  it('Should log error if module contains a SyntaxError', function() {
-    core.rewriter.rewrite.callsFake((content) => ({
-      code: content.replace('const variable', 'const variable const a')
-    }));
-    require('../test/resources/file');
-    expect(core.rewriter.rewrite).to.have.been.calledWith(
-      sinon.match.string,
-      { filename: testCode }
-    );
-    expect(core.logger.error).to.have.been.calledWith(
-      {
-        err: sinon.match({
-          message: 'Missing initializer in const declaration'
-        })
-      },
-      'Failed to compile rewritten code for %s, rewritten code %s, compiling original code.',
-      testCode,
-      sinon.match('const variable const a')
-    );
-    expect(origCompileSpy).to.have.been.calledWith(
-      "/* eslint-disable */\n'use strict'\nconst variable = 'variable';\n",
-      testCode
-    );
-  });
-});

package/lib/sources.test.js

@@ -1,196 +0,0 @@
-'use strict';
-
-const { expect } = require('chai');
-const sinon = require('sinon');
-const sourcesModule = require('./sources');
-
-describe('agentify sources', function () {
-  let mocks, coreMock, depHooksMock, patcherMock, loggerMock, scopesMock;
-
-  beforeEach(function () {
-    mocks = require('../../test/mocks');
-    loggerMock = mocks.logger();
-    patcherMock = mocks.patcher();
-    depHooksMock = mocks.depHooks();
-    scopesMock = mocks.scopes();
-    coreMock = {
-      logger: loggerMock,
-      patcher: patcherMock,
-      depHooks: depHooksMock,
-      scopes: scopesMock,
-    };
-  });
-
-  describe('attaching the sources module to the core object', function () {
-    it('attaches the module to the core object', function () {
-      const sources = sourcesModule(coreMock);
-      expect(coreMock).to.haveOwnProperty('sources');
-      expect(coreMock.sources).to.haveOwnProperty('install');
-      expect(sources).to.haveOwnProperty('install');
-      expect(sources).to.haveOwnProperty('functions');
-    });
-  });
-
-  describe('installing instrumentation for HTTP type of sources', function () {
-    let argumentsMap, httpMock, httpsMock, http2Mock, spdyMock;
-
-    beforeEach(function () {
-      httpMock = { name: 'http' };
-      httpsMock = { name: 'https' };
-      http2Mock = { name: 'http2' };
-      spdyMock = { name: 'spdy' };
-      const patchType = 'http-sources';
-      argumentsMap = {
-        http: {
-          source: httpMock,
-          patcherArgs: [
-            [httpMock, 'createServer', { name: 'httpServer', patchType }],
-          ],
-        },
-        https: {
-          source: httpsMock,
-          patcherArgs: [
-            [httpsMock, 'createServer', { name: 'httpsServer', patchType }],
-          ],
-        },
-        http2: {
-          source: http2Mock,
-          patcherArgs: [
-            [http2Mock, 'createServer', { name: 'http2Server', patchType }],
-            [
-              http2Mock,
-              'createSecureServer',
-              { name: 'http2SecureServer', patchType },
-            ],
-          ],
-        },
-        spdy: {
-          source: spdyMock,
-          patcherArgs: [
-            [spdyMock, 'createServer', { name: 'spdyServer', patchType }],
-          ],
-        },
-      };
-      coreMock.depHooks.resolve.callsFake((moduleMetadata, callback) =>
-        callback(argumentsMap[moduleMetadata.name].source)
-      );
-    });
-
-    it('should call patcher.patch with the correct arguments from depHooks.resolve', function () {
-      const sources = sourcesModule(coreMock);
-      sources.install();
-
-      const callOrder = ['http', 'https', 'http2', 'http2', 'spdy'];
-      let consecutiveCalls = 0;
-
-      for (let i = 0; i < callOrder.length; i++) {
-        consecutiveCalls = callOrder[i] == 'http2' ? consecutiveCalls : 0;
-        const argument = (callNumber, argIndex) =>
-          patcherMock.patch.getCall(callNumber).args[argIndex];
-        const expectedArgument = (callNumber, argIndex, consecutiveCalls) =>
-          argumentsMap[callOrder[callNumber]].patcherArgs[consecutiveCalls][
-            argIndex
-          ];
-
-        expect(argument(i, 0)).to.equal(
-          expectedArgument(i, 0, consecutiveCalls)
-        );
-        expect(argument(i, 1)).to.equal(
-          expectedArgument(i, 1, consecutiveCalls)
-        );
-        expect(argument(i, 2)).to.include(
-          expectedArgument(i, 2, consecutiveCalls)
-        );
-
-        if (callOrder[i] == 'http2' && !consecutiveCalls) {
-          consecutiveCalls++;
-        }
-      }
-
-      expect(patcherMock.patch).to.have.been.callCount(callOrder.length);
-    });
-  });
-
-  describe('functions', function () {
-    let emitAroundHook, createServerPostHook, dataObj;
-
-    beforeEach(function () {
-      ({
-        functions: { createServerPostHook, emitAroundHook },
-      } = sourcesModule(coreMock));
-    });
-
-    describe('createServerPostHook', function () {
-      let serverMock, prototypeMock;
-      beforeEach(function () {
-        serverMock = {};
-        prototypeMock = {
-          emit() {},
-        };
-        dataObj = {
-          result: serverMock,
-        };
-        Object.setPrototypeOf(serverMock, prototypeMock);
-      });
-
-      it('calls patcher.patch() if proper data argument is supplied', function () {
-        createServerPostHook('httpServer')(dataObj);
-        expect(loggerMock.error).to.not.have.been.called;
-        expect(patcherMock.patch).to.have.been.calledWith(
-          prototypeMock,
-          'emit',
-          {
-            name: 'server.emit',
-            patchType: 'req-async-storage',
-            around: sinon.match.func
-          }
-        );
-      });
-
-      it('calls logger.error() if none or invalid data argument is supplied', function () {
-        createServerPostHook('httpServer')({});
-        expect(loggerMock.error).to.have.been.calledWith(
-          'Unable to patch server prototype, continue without instrumentation'
-        );
-        Object.setPrototypeOf(serverMock, null);
-        createServerPostHook('httpServer')(serverMock);
-        expect(loggerMock.error).to.have.been.called.calledTwice;
-        expect(patcherMock.patch).to.not.have.been.called;
-      });
-    });
-
-    describe('emitAroundHook', function () {
-      let nextFn, reqMock, resMock, eventMock;
-      beforeEach(function () {
-        reqMock = () => {
-          this.method = 'GET';
-          this.url = 'http://localhost';
-        };
-        resMock = () => {};
-        eventMock = 'request';
-        dataObj = {
-          args: [eventMock, reqMock, resMock],
-        };
-        nextFn = function () {
-          return {
-            sourcesStore: scopesMock.sources.getStore(),
-          };
-        };
-      });
-
-      it('executes the hooked nextFn in the provided context if the event name is "request"', function () {
-        const result = emitAroundHook('httpServer')(nextFn, dataObj);
-        expect(result.sourcesStore).to.deep.include({
-          serverType: 'httpServer',
-        });
-      });
-
-      it('executes the hooked nextFn without binding it to a context if the event name is not "request"', function () {
-        eventMock = 'listen';
-        dataObj.args[0] = eventMock;
-        const result = emitAroundHook('httpServer')(nextFn, dataObj);
-        expect(result.sourcesStore).to.equal(undefined);
-      });
-    });
-  });
-});