@contrast/agent-bundle 5.42.0 → 5.46.0

package/node_modules/@contrast/perf/lib/index.test.js

@@ -1,547 +0,0 @@
-'use strict';
-
-const { EventEmitter } = require('node:events');
-const Perf = require('.');
-
-const { expect } = require('chai');
-
-describe('perf', function () {
-  describe('Perf class', function () {
-    it('constructs a new instance with a prefix', function() {
-      const perf = new Perf('test');
-      expect(perf).instanceOf(Perf);
-      expect(perf).property('prefix', 'test');
-      expect(perf).property('timings')
-        .instanceOf(Map);
-      expect(Perf.all.get('test')).equal(perf.timings);
-    });
-
-    it('constructs a new instance without a prefix', function() {
-      const perf = new Perf();
-      expect(perf).instanceOf(Perf);
-      expect(perf).property('prefix', '');
-      expect(perf).property('timings')
-        .instanceOf(Map);
-      expect(Perf.all.get('')).equal(perf.timings);
-    });
-
-    // can't test this dynamically because it's set at load time. should
-    // it be dynamic? should it be per-instance?
-    // ['0', 'not-one', ''].forEach(setting => {
-    //   const bool = setting === '1';
-    //   it(`isEnabled is ${bool} when CSI_PERF is ${setting}`, function() {
-    //     process.env.CSI_PERF = setting;
-    //     //const perf = new Perf();
-    //     expect(Perf.isEnabled).equal(setting === '1');
-    //   });
-    // });
-  });
-
-  describe('wrapInit functions', function () {
-    let perf;
-    beforeEach(function() {
-      Perf.isEnabled = false;
-      Perf.all.clear();
-      perf = new Perf('wrap-test');
-    });
-
-    it('wrapInit returns the original function when Perf is not enabled', function() {
-      Perf.isEnabled = false;
-      function init() {
-        return {
-          install() {
-            return 'i-am-install';
-          }
-        };
-      }
-      const wrapped = perf.wrapInit(init, 'tag');
-      expect(wrapped).equal(init);
-    });
-
-    it('wrapInit returns a wrapped function when Perf is enabled', async function() {
-      Perf.isEnabled = true;
-
-      async function install() {
-        return 'i-am-install';
-      }
-      function init() {
-        return {
-          install
-        };
-      }
-
-      // wrap init
-      const wrapped = perf.wrapInit(init, 'tag');
-      expect(wrapped).not.equal(init);
-      expect(wrapped).instanceOf(Function);
-
-      // invoke the wrapped function
-      const result = wrapped();
-      expect(result.install).not.equal(install);
-      expect(result.install).instanceOf(Function);
-
-      // invoke install (an async function)
-      let installResult = result.install();
-      expect(installResult).instanceOf(Promise);
-      installResult = await installResult;
-      expect(installResult).equal('i-am-install');
-
-      expect(Perf.all.get('wrap-test')).equal(perf.timings);
-      expect(perf.timings.size).equal(2);
-      expect(perf.timings.get('wrap-test:tag:init')).instanceOf(Array)
-        .length(2);
-      expect(perf.timings.get('wrap-test:tag:install')).instanceOf(Array)
-        .length(2);
-    });
-  });
-
-  describe('wrapReporter functions', function() {
-    let perf;
-    beforeEach(function() {
-      Perf.isEnabled = false;
-      Perf.all.clear();
-      perf = new Perf('wrap-test');
-    });
-
-    it('wrapReporter returns original class when Perf not enabled', function() {
-      Perf.isEnabled = false;
-      class Reporter {
-        constructor() { }
-        get() { }
-        post() { }
-        put() { }
-      }
-
-      const wrapped = new Perf().wrapReporter(Reporter);
-      expect(wrapped).equal(Reporter);
-    });
-
-    it('wrapReporter returns a subclass when Perf is enabled', async function() {
-      Perf.isEnabled = true;
-      class Reporter {
-        constructor() { }
-
-        /* eslint-disable */
-        async get() { return 'i-am-get'; }
-        async post() { return 'i-am-post'; }
-        async put() { return 'i-am-put'; }
-        /* eslint-enable */
-      }
-      const wrapped = perf.wrapReporter(Reporter);
-      expect(wrapped).not.equal(Reporter);
-      expect(wrapped).instanceOf(Function);
-
-      const reporter = new wrapped();
-      expect(reporter).instanceOf(Reporter);
-
-      for (const method of ['get', 'post', 'put']) {
-        expect(reporter[method]).instanceOf(Function);
-        let result = reporter[method]();
-        expect(result).instanceOf(Promise);
-        result = await result;
-        expect(result).equal(`i-am-${method}`);
-      }
-
-      expect(Perf.all.get('wrap-test')).equal(perf.timings);
-      expect(perf.timings.size).equal(3);
-      expect(perf.timings.get('wrap-test:Reporter:get')).instanceOf(Array)
-        .length(2);
-      expect(perf.timings.get('wrap-test:Reporter:post')).instanceOf(Array)
-        .length(2);
-      expect(perf.timings.get('wrap-test:Reporter:put')).instanceOf(Array)
-        .length(2);
-    });
-  });
-
-  describe('wrapPinoInstance functions', function() {
-    let perf;
-    beforeEach(function() {
-      Perf.isEnabled = false;
-      Perf.all.clear();
-      perf = new Perf('wrap-test');
-    });
-    it('wrapPinoInstance returns original when Perf not enabled', function() {
-      Perf.isEnabled = false;
-      const pino = {
-        info() { },
-        warn() { },
-        error() { },
-        trace() { },
-        debug() { },
-        fatal() { },
-      };
-      const wrapped = perf.wrapPinoInstance(pino);
-      expect(wrapped).equal(pino);
-    });
-
-    it('wrapPinoInstance wraps instance when Perf is enabled', function() {
-      Perf.isEnabled = true;
-      /* eslint-disable */
-      const originals = {
-        info() { return 'i-am-info' },
-        warn() { return 'i-am-warn' },
-        error() { return 'i-am-error' },
-        trace() { return 'i-am-trace' },
-        debug() { return 'i-am-debug' },
-        fatal() { return 'i-am-fatal' },
-      };
-      /* eslint-enable */
-
-      const pino = {
-        info: originals.info,
-        warn: originals.warn,
-        error: originals.error,
-        trace: originals.trace,
-        debug: originals.debug,
-        fatal: originals.fatal,
-      };
-      const wrapped = perf.wrapPinoInstance(pino);
-      expect(wrapped).instanceOf(Object);
-
-      for (const method of ['info', 'warn', 'error', 'trace', 'debug', 'fatal']) {
-        expect(wrapped[method]).instanceOf(Function);
-        expect(wrapped[method]).not.equal(originals[method]);
-        expect(wrapped[method]()).equal(`i-am-${method}`);
-        const result = wrapped[method]();
-        expect(result).equal(`i-am-${method}`);
-      }
-
-      expect(Perf.all.get('wrap-test')).equal(perf.timings);
-      expect(perf.timings.size).equal(6);
-      for (const method of ['info', 'warn', 'error', 'trace', 'debug', 'fatal']) {
-        expect(perf.timings.get(`pino:${method}`)).instanceOf(Array)
-          .length(2);
-      }
-    });
-  });
-
-  describe('wrapEmitter functions', function() {
-    let perf;
-    let emitter;
-    beforeEach(function() {
-      Perf.isEnabled = false;
-      Perf.all.clear();
-      perf = new Perf('wrap-emitter-test');
-      emitter = new EventEmitter();
-    });
-
-    it('wrapEmitter returns the original function when Perf is not enabled', function() {
-      Perf.isEnabled = false;
-      const wrapped = perf.wrapEmitter(emitter, 'messages');
-      expect(wrapped).equal(emitter);
-    });
-
-    it('wrapEmitter returns a wrapped function when Perf is enabled', async function() {
-      Perf.isEnabled = true;
-      const perfName = 'emitter';
-      perf = new Perf(perfName);
-
-      const calls = [];
-      function handler(event, ...args) {
-        calls.push([event, ...args]);
-        return 'i-am-handler';
-      }
-
-      const originalEmitter = emitter;
-      const originalOn = emitter.on;
-
-      const tag = 'messages';
-
-      const wrapped = perf.wrapEmitter(emitter, tag);
-      expect(wrapped.on).not.equal(originalOn);
-      expect(wrapped).instanceOf(EventEmitter);
-      expect(emitter).equal(originalEmitter);
-
-      wrapped.on('event-one', handler);
-      wrapped.on('event-two', handler);
-
-      wrapped.emit('event-one', 1, 'one');
-      wrapped.emit('event-two', 2, 'two');
-
-      expect(calls).deep.equal([
-        [1, 'one'],
-        [2, 'two'],
-      ]);
-
-      /* eslint-disable newline-per-chained-call */
-      expect(Perf.all.get(perfName)).equal(perf.timings);
-      expect(perf.timings.size).equal(2);
-
-      const eventOneTimings = perf.timings.get(`${perfName}:${tag}:on:event-one`);
-      expect(eventOneTimings).an('array').length(2);
-      expect(eventOneTimings[0]).equal(1); // count
-      expect(eventOneTimings[1]).a('bigint');
-
-      const eventTwoTimings = perf.timings.get(`${perfName}:${tag}:on:event-two`);
-      expect(eventTwoTimings).an('array').length(2);
-      expect(eventTwoTimings[0]).equal(1); // count
-      expect(eventTwoTimings[1]).a('bigint');
-    });
-  });
-
-  describe('wrap sync and async functions', function() {
-    let perf;
-    beforeEach(function() {
-      Perf.isEnabled = false;
-      Perf.all.clear();
-      perf = new Perf('wrap-test');
-    });
-
-    for (const enabled of [true, false]) {
-      it(`wrapSync wraps original function when Perf is ${enabled ? 'enabled' : 'disabled'}`, function() {
-        Perf.isEnabled = enabled;
-        const original = function xyzzy() {
-          return 'i-am-original';
-        };
-        const wrapped = perf.wrapSync(original, 'tag');
-        expect(wrapped).not.equal(original);
-
-        const result = wrapped();
-        expect(result).equal('i-am-original');
-
-        expect(Perf.all.get('wrap-test')).equal(perf.timings);
-        expect(perf.timings.size).equal(1);
-        expect(perf.timings.get('wrap-test:tag:xyzzy')).instanceOf(Array)
-          .length(2);
-      });
-    }
-
-    for (const enabled of [true, false]) {
-      it(`wrapAsync wraps original function when Perf is ${enabled ? 'enabled' : 'disabled'}`, async function() {
-        Perf.isEnabled = enabled;
-        const original = async function xyzzy() {
-          return new Promise(resolve => setTimeout(() => resolve('i-am-original'), 10));
-        };
-        const wrapped = perf.wrapAsync(original, 'tag');
-        expect(wrapped).not.equal(original);
-
-        const result = await wrapped();
-        expect(result).equal('i-am-original');
-
-        expect(Perf.all.get('wrap-test')).equal(perf.timings);
-        expect(perf.timings.size).equal(1);
-        expect(perf.timings.get('wrap-test:tag:xyzzy')).instanceOf(Array)
-          .length(2);
-      });
-    }
-  });
-});
-
-describe('Perf map functions', function() {
-  let perf;
-
-  before(function() {
-    Perf.all.clear();
-  });
-
-  beforeEach(function() {
-    perf = new Perf('map-test');
-  });
-  afterEach(function() {
-    //console.log(Perf.all);
-  });
-
-  // record, recordExcluding
-  it('records a timing', function() {
-    const start = process.hrtime.bigint();
-    perf.record('record', start);
-    expect(Perf.all.get('map-test')).equal(perf.timings);
-    expect(perf.timings.get('record')).instanceOf(Array)
-      .length(2);
-  });
-
-  it('records a timing excluding a delta time', function() {
-    const start = process.hrtime.bigint();
-    perf.recordExcluding('recordExcluding', start, 100_000n);
-    expect(Perf.all.get('map-test')).equal(perf.timings);
-    expect(perf.timings.get('recordExcluding')).instanceOf(Array)
-      .length(2);
-    // it's a bit gross to force it negative, but allows testing
-    // that the supplied value was subtracted.
-    const [_, delta] = perf.timings.get('recordExcluding');
-    //expect(Number(n)).equal(1);
-    // .lt(0n) works but .gt(-100_000n) throws "expected -82267 to be a
-    // number or date", so convert the bigint.
-    expect(Number(delta)).lt(0).gt(-100_000); // eslint-disable-line
-    //console.log(n, delta);
-  });
-});
-
-describe('Collected stats', function() {
-  before(function() {
-    Perf.all.clear();
-  });
-
-  it('calculates stats when done', function() {
-    let fn;
-    const perf = new Perf('stats-test', { hrtime: () => fn() });
-
-    for (let i = 0; i < 10; i++) {
-      fn = function() {
-        return BigInt(i * 1_000_000);
-      };
-      perf.record('stats', 0n);
-    }
-    const stats = perf.getStats(perf.timings);
-
-    expect(stats).instanceOf(Map);
-    expect(stats.size).equal(1);
-    expect(stats.get('stats')).deep.equal({
-      n: 10,
-      totalMicros: 45_000,
-      mean: 4500,
-    });
-  });
-
-  it('calculates streaming stats', function() {
-    let fn;
-    const perf = new Perf('streaming-test', { streaming: true, hrtime: () => fn() });
-    for (let i = 0; i < 10; i++) {
-      fn = function() {
-        return BigInt(i * 1_000_000);
-      };
-      perf.record('streaming', 0n);
-    }
-    const stats = perf.getStats();
-
-    expect(stats).instanceOf(Map);
-    expect(stats.size).equal(1);
-    const streamingStats = stats.get('streaming');
-    expect(streamingStats.n).equal(10);
-    expect(streamingStats.totalMicros).equal(45_000n);
-    expect(streamingStats.mean).equal(4500);
-    expect(streamingStats.min).equal(0n);
-    expect(streamingStats.max).equal(9000n);
-    // verified with https://www.standarddeviationcalculator.io/
-    expect(streamingStats.popStddev).equal(2872.28);
-    expect(streamingStats.sampleStddev).equal(3027.65);
-  });
-});
-
-describe('test prototype', function() {
-  const instances = [];
-  const values = {
-    'instance-0': [10, 20, 30],
-    'instance-1': [100, 200, 300],
-    'instance-2': [1000, 2000, 3000],
-    'streaming': [10000, 20000, 30000],
-  };
-  let firstMark;
-  before(async function() {
-    Perf.all.clear();
-    const prefixes = Object.keys(values);
-    for (let i = 0; i < 4; i++) {
-      const prefix = prefixes[i];
-      const options = {
-        streaming: prefix === 'streaming',
-        hrtime: () => BigInt(values[prefix].shift())
-      };
-      instances.push(new Perf(prefix, options));
-      for (let j = 0; j < 3; j++) {
-        instances[i].record('test', 0n);
-      }
-    }
-  });
-
-  it('dumps some stuff', function() {
-    // make a bunch of perf instances
-    const i0 = instances[0].timings;
-    const i1 = instances[1].timings;
-    const i2 = instances[2].timings;
-    const i3 = instances[3].timings;
-
-    expect(i0).deep.equal(new Map([['test', [3, 60n]]]));
-    expect(i1).deep.equal(new Map([['test', [3, 600n]]]));
-    expect(i2).deep.equal(new Map([['test', [3, 6000n]]]));
-    // maybe Perf should expose RunningStats?
-    expect(i3).instanceOf(Map);
-    expect(i3.size).equal(1);
-    const i3stats = i3.get('test');
-    expect(i3stats).property('n', 3);
-    expect(i3stats).property('totalMicros', 60n); // it's been converted to microseconds.
-
-    Perf.mark('listening');
-
-    expect(Perf.marks.get('listening')).instanceOf(Map);
-    const mark0 = Perf.marks.get('listening').get('instance-0');
-    const mark1 = Perf.marks.get('listening').get('instance-1');
-    const mark2 = Perf.marks.get('listening').get('instance-2');
-    const mark3 = Perf.marks.get('listening').get('streaming');
-
-    expect(mark0).deep.equal(new Map([['test', [3, 60n]]]));
-    expect(mark1).deep.equal(new Map([['test', [3, 600n]]]));
-    expect(mark2).deep.equal(new Map([['test', [3, 6000n]]]));
-
-    const s3 = mark3.get('test');
-    expect(s3).property('n', 3);
-    expect(s3).property('totalMicros', 60n);
-
-    /* eslint-disable */
-    expect(i0).instanceOf(Map).property('size', 0);
-    expect(i1).instanceOf(Map).property('size', 0);
-    expect(i2).instanceOf(Map).property('size', 0);
-    expect(i3).instanceOf(Map).property('size', 0);
-    /* eslint-enable */
-
-  });
-
-  it('gets the same answer for the streaming stats', async function() {
-    // duplicate the existing listening stats
-    firstMark = new Map(Perf.marks.get('listening'));
-    const firstMarkMaps = {};
-    for (const [prefix, data] of firstMark) {
-      firstMarkMaps[prefix] = new Map(data);
-    }
-
-    // add two more perf measurements
-    const values = {
-      'instance-0': [40, 50],
-      'instance-1': [400, 500],
-      'instance-2': [4000, 5000],
-      'streaming': [40000, 50000],
-    };
-    const prefixes = Object.keys(values);
-    for (let i = 0; i < 4; i++) {
-      const prefix = prefixes[i];
-      instances[i].hrtime = { bigint: () => BigInt(values[prefix].shift()) };
-      for (let j = 0; j < 2; j++) {
-        instances[i].record('test', 0n);
-      }
-    }
-
-    expect(Perf.marks.get('listening')).instanceOf(Map);
-    const all0 = Perf.all.get('instance-0');
-    const all1 = Perf.all.get('instance-1');
-    const all2 = Perf.all.get('instance-2');
-    const all3 = Perf.all.get('streaming');
-
-    expect(all0).deep.equal(new Map([['test', [2, 90n]]]));
-    expect(all1).deep.equal(new Map([['test', [2, 900n]]]));
-    expect(all2).deep.equal(new Map([['test', [2, 9000n]]]));
-
-    let s3 = all3.get('test');
-    expect(s3).property('n', 2);
-    expect(s3).property('totalMicros', 90n);
-
-    // ask for another mark of the same prefix. it should merge non-streaming
-    // and *not* replace streaming stats.
-    Perf.mark('listening');
-
-    /* eslint-disable */
-    expect(Perf.marks.get('listening')).instanceOf(Map);
-    const mark0 = Perf.marks.get('listening').get('instance-0');
-    const mark1 = Perf.marks.get('listening').get('instance-1');
-    const mark2 = Perf.marks.get('listening').get('instance-2');
-    const mark3 = Perf.marks.get('listening').get('streaming');
-    /* eslint-enable */
-
-    // simple stats are aggregated
-    expect(mark0).deep.equal(new Map([['test', [5, 150n]]]));
-    expect(mark1).deep.equal(new Map([['test', [5, 1500n]]]));
-    expect(mark2).deep.equal(new Map([['test', [5, 15000n]]]));
-    // streaming stats don't change
-    s3 = mark3.get('test');
-    expect(s3).property('n', 3);
-    expect(s3).property('totalMicros', 60n);
-  });
-});

package/node_modules/@contrast/perf/lib/tsconfig.json

@@ -1,31 +0,0 @@
-{
-  "extends": "@tsconfig/node16/tsconfig.json",
-  "compilerOptions": {
-    // Enable constraints that allow a TypeScript project to be used with project references.
-    // See more: https://www.typescriptlang.org/tsconfig#composite
-    // We need this in all of our modules.
-    "composite": true,
-    // Tells TypeScript to read JS files, as
-    // normally they are ignored as source files
-    "allowJs": true,
-    "rootDir": "./",
-    // Generate d.ts files
-    "declaration": true,
-    // This compiler run should
-    // only output d.ts files
-    "emitDeclarationOnly": true,
-    // Types should go into this directory.
-    // Removing this would place the .d.ts files
-    // next to the .js files
-    "outDir": "../types",
-    // go to js file when using IDE functions like
-    // "Go to Definition" in VSCode
-    "declarationMap": true
-  },
-  "references": [
-    {
-      "path": "../../common/src/tsconfig.json"
-    }
-  ],
-  "exclude": ["../types", "**/*.spec.*", "**/*.test.*"]
-}

package/node_modules/@contrast/protect/lib/input-tracing/install/spdy.js

@@ -1,63 +0,0 @@
-/*
- * Copyright: 2025 Contrast Security, Inc
- * Contact: support@contrastsecurity.com
- * License: Commercial
-
- * NOTICE: This Software and the patented inventions embodied within may only be
- * used as part of Contrast Security’s commercial offerings. Even though it is
- * made available through public repositories, use of this Software is subject to
- * the applicable End User Licensing Agreement found at
- * https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
- * between Contrast Security and the End User. The Software may not be reverse
- * engineered, modified, repackaged, sold, redistributed or otherwise used in a
- * way not consistent with the End User License Agreement.
- */
-
-'use strict';
-
-const { patchType } = require('../constants');
-
-module.exports = function(core) {
-  const {
-    scopes: { instrumentation },
-    patcher,
-    depHooks,
-    protect,
-    protect: { inputTracing }
-  } = core;
-
-  function install() {
-    depHooks.resolve({ name: 'spdy', version: '<5' }, spdy => {
-      const name = 'spdy.response.end';
-      patcher.patch(spdy.response, 'end', {
-        name,
-        patchType,
-        pre({ args, obj: response, hooked }) {
-          if (instrumentation.isLocked()) return;
-
-          const sourceContext = protect.getSourceContext();
-
-          if (!sourceContext) return;
-
-          const value = args[0]?.toString();
-          if (!value) return;
-
-          const sinkContext = {
-            name,
-            value,
-            stacktraceOpts: { constructorOpt: hooked },
-          };
-
-          response.spdyStream.once('finish', () => response.emit('finish'));
-          inputTracing.handleReflectedXss(sourceContext, sinkContext);
-        }
-      });
-    });
-  }
-
-  const spdyInstrumentation = inputTracing.spdyInstrumentation = {
-    install
-  };
-
-  return spdyInstrumentation;
-};

package/node_modules/@contrast/reporter/node_modules/sonic-boom/.taprc.yaml

@@ -1,11 +0,0 @@
-coverage: true
-flow: false
-ts: false
-jsx: false
-timeout: 240
-check-coverage: false
-
-reporter: terse
-
-files:
-  - 'test/**/*.test.js'

package/node_modules/@contrast/reporter/node_modules/sonic-boom/test/destroy.test.js

@@ -1,49 +0,0 @@
-'use strict'
-
-const fs = require('fs')
-const SonicBoom = require('../')
-const { file, runTests } = require('./helper')
-
-runTests(buildTests)
-
-function buildTests (test, sync) {
-  // Reset the umask for testing
-  process.umask(0o000)
-
-  test('destroy', (t) => {
-    t.plan(5)
-
-    const dest = file()
-    const fd = fs.openSync(dest, 'w')
-    const stream = new SonicBoom({ fd, sync })
-
-    t.ok(stream.write('hello world\n'))
-    stream.destroy()
-    t.throws(() => { stream.write('hello world\n') })
-
-    fs.readFile(dest, 'utf8', function (err, data) {
-      t.error(err)
-      t.equal(data, 'hello world\n')
-    })
-
-    stream.on('finish', () => {
-      t.fail('finish emitted')
-    })
-
-    stream.on('close', () => {
-      t.pass('close emitted')
-    })
-  })
-
-  test('destroy while opening', (t) => {
-    t.plan(1)
-
-    const dest = file()
-    const stream = new SonicBoom({ dest })
-
-    stream.destroy()
-    stream.on('close', () => {
-      t.pass('close emitted')
-    })
-  })
-}