How to use stack-chain - 10 common examples

var createCallsiteRecord = require('callsite-record');
var stackTrace           = require('stack-chain');

var record = null;

// NOTE: Limit stack entries to this file
function stackFilter (err, frames) {
    return frames
        .filter(function (frame) {
            var filename = frame.getFileName();

            return filename === __filename || filename === require.resolve('callsite-record');
        });
}

stackTrace.filter.attach(stackFilter);

function func1 () {
    record = createCallsiteRecord({ byFunctionName: 'func1' });
}

(function func2 () {
    func1();
})();

stackTrace.filter.deattach(stackFilter);

module.exports = record;

const chain = require('stack-chain');
const asyncHook = require('async_hooks');

// Contains init asyncId of the active scope(s)
// Because we can't know when the root scope ends, a permanent Set is keept
// for the root scope.
const executionScopeInits = new Set();
let executionScopeDepth = 0;
// Contains the call site objects of all active scopes
const traces = new Map();

//
// Mainiputlate stack trace
//
// add lastTrace to the callSite array
chain.filter.attach(function (error, frames) {
  return frames.filter(function (callSite) {
    const name = callSite && callSite.getFileName();
    return (!name || (name !== 'async_hooks.js' && name !== 'internal/async_hooks.js'));
  });
});

chain.extend.attach(function (error, frames) {
  const lastTrace = traces.get(asyncHook.executionAsyncId());
  frames.push.apply(frames, lastTrace);
  return frames;
});

//
// Track handle objects
//
const hooks = asyncHook.createHook({

// Conditionally load development services if run from CLI
if (
  process.defaultApp &&
  process.env.NODE_ENV !== 'production' &&
  process.env.NODE_ENV !== 'test'
) {
  // active long stack trace
  require('trace'); // eslint-disable-line global-require
  const chain = require('stack-chain'); // eslint-disable-line global-require
  const sep = require('path').sep; // eslint-disable-line global-require

  // There is no limit for the size of the stack trace (v8 default is 10)
  Error.stackTraceLimit = Infinity;

  chain.filter.attach((error, frames) => {
    return frames.filter((callSite) => {
      const name = callSite && callSite.getFileName();
      const include = !(
        !name ||
        name.indexOf(sep) === -1 ||
        name.match(/internal\//) ||
        name.match(/tick/) ||
        name.match(/electron-preb/)
     );
      return include;
    });
  });

  /**
  * Load electron-debug, which loads devtron automatically.
  *

let executionScopeDepth = 0;
// Contains the call site objects of all active scopes
const traces = new Map();

//
// Mainiputlate stack trace
//
// add lastTrace to the callSite array
chain.filter.attach(function (error, frames) {
  return frames.filter(function (callSite) {
    const name = callSite && callSite.getFileName();
    return (!name || (name !== 'async_hooks.js' && name !== 'internal/async_hooks.js'));
  });
});

chain.extend.attach(function (error, frames) {
  const lastTrace = traces.get(asyncHook.executionAsyncId());
  frames.push.apply(frames, lastTrace);
  return frames;
});

//
// Track handle objects
//
const hooks = asyncHook.createHook({
  init: asyncInit,
  before: asyncBefore,
  after: asyncAfter,
  destroy: asyncDestroy
});
hooks.enable();

return filename === __filename || filename === require.resolve('callsite-record');
        });
}

stackTrace.filter.attach(stackFilter);

function func1 () {
    record = createCallsiteRecord({ byFunctionName: 'func1' });
}

(function func2 () {
    func1();
})();

stackTrace.filter.deattach(stackFilter);

module.exports = record;

filter() {
    this.currentFilter = stackChain.filter.attach((_err, frames) => {
      if (this.isErrorInCucumber(frames)) {
        return frames
      }
      const index = _.findIndex(frames, ::this.isFrameInCucumber)
      if (index === -1) {
        return frames
      }
      return frames.slice(0, index)
    })
  }

'use strict';

const chain = require('stack-chain');
const sep = require('path').sep;

chain.filter.attach(function (error, frames) {
  return frames.filter(function (callSite) {
    const name = callSite && callSite.getFileName();
    return (name && name.includes(sep) && !name.startsWith('internal'));
  });
});

function unfilter() {
  chain.filter.deattach(currentFilter);
}

function getCallSites(skip) {
  const limit = Error.stackTraceLimit;

  Error.stackTraceLimit = limit + skip;
  const stack = chain.callSite({
    extend: false,
    filter: true,
    slice: skip
  });
  Error.stackTraceLimit = limit;

  return stack;
}

AsyncWrap.prototype.stackTrace = function (skip) {
  const limit = Error.stackTraceLimit;
  const slice = skip + this.skip;

  Error.stackTraceLimit = limit + slice;
  const stack = chain.callSite({
    extend: false,
    filter: true,
    slice: slice
  });
  Error.stackTraceLimit = limit;

  return stack;
};