@instana/shared-metrics 1.128.0 → 1.131.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@instana/shared-metrics",
-  "version": "1.128.0",
+  "version": "1.131.0",
   "description": "Internal metrics plug-in package for Node.js monitoring with Instana",
   "author": {
     "name": "Bastian Krol",
@@ -26,7 +26,7 @@
   "scripts": {
     "audit": "bin/prepare-audit.sh && npm audit --production; AUDIT_RESULT=$?; git checkout package-lock.json; exit $AUDIT_RESULT",
     "test": "npm run test:mocha",
-    "test:mocha": "mocha --sort --reporter mocha-multi --reporter-options spec=-,xunit=../../test-results/shared-metris/results.xml $(find test -iname '*test.js')",
+    "test:mocha": "mocha --sort --reporter mocha-multi --reporter-options spec=-,xunit=../../test-results/shared-metris/results.xml $(find test -iname '*test.js' -not -path '*node_modules*')",
     "test:debug": "WITH_STDOUT=true npm run test:mocha",
     "lint": "eslint src test",
     "verify": "npm run lint && npm test",
@@ -48,6 +48,10 @@
     {
       "name": "Emelia Smith",
       "email": "ThisIsMissEm@users.noreply.github.com"
+    },
+    {
+      "name": "Richard Gebhardt",
+      "email": "gebhardt@us.ibm.com"
     }
   ],
   "bugs": {
@@ -55,11 +59,11 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@instana/core": "1.128.0",
+    "@instana/core": "1.131.0",
     "detect-libc": "^1.0.3",
     "event-loop-lag": "^1.4.0",
     "recursive-copy": "^2.0.13",
-    "tar": "^5.0.5"
+    "tar": "^5.0.9"
   },
   "devDependencies": {
     "eslint": "^7.30.0",
@@ -74,5 +78,5 @@
     "gcstats.js": "1.0.0",
     "node-gyp": "^7.1.2"
   },
-  "gitHead": "a08cd7c136eecdf11278b3e927da313a15ab33e8"
+  "gitHead": "c143ddafc50f8305684638f5abff0ee847830408"
 }

package/src/dependencies.js

@@ -12,6 +12,9 @@ const { applicationUnderMonitoring } = require('@instana/core').util;
 
 let logger = require('@instana/core').logger.getLogger('metrics');
 
+const CountDownLatch = require('./util/CountDownLatch');
+const { DependencyDistanceCalculator, MAX_DEPTH } = require('./util/DependencyDistanceCalculator');
+
 /**
  * @param {import('@instana/core/src/logger').GenericLogger} _logger
  */
@@ -19,20 +22,31 @@ exports.setLogger = function setLogger(_logger) {
   logger = _logger;
 };
 
+/** @type {number} */
+exports.MAX_DEPENDENCIES = 750;
+
+/** @type {string} */
 exports.payloadPrefix = 'dependencies';
+
+/** @type {Object.<string, *>} */
+const preliminaryPayload = {};
+
 /** @type {Object.<string, *>} */
 exports.currentPayload = {};
 
-const MAX_ATTEMPTS = 20;
+exports.MAX_ATTEMPTS = 20;
+
 const DELAY = 1000;
 let attempts = 0;
 
 exports.activate = function activate() {
   attempts++;
+
+  const started = Date.now();
   applicationUnderMonitoring.getMainPackageJsonPathStartingAtMainModule((err, packageJsonPath) => {
     if (err) {
       return logger.warn('Failed to determine main package.json. Reason: %s %s ', err.message, err.stack);
-    } else if (!packageJsonPath && attempts < MAX_ATTEMPTS) {
+    } else if (!packageJsonPath && attempts < exports.MAX_ATTEMPTS) {
       logger.debug('Main package.json could not be found. Will try again later.');
       setTimeout(exports.activate, DELAY).unref();
       return;
@@ -48,7 +62,8 @@ exports.activate = function activate() {
             'Neither the package.json file nor the node_modules folder could be found. Stopping dependency analysis.'
           );
         }
-        addDependenciesFromDir(path.join(nodeModulesFolder));
+
+        addAllDependencies(path.join(nodeModulesFolder), started, null);
       });
       return;
     }
@@ -59,76 +74,198 @@ exports.activate = function activate() {
     } else {
       dependencyDir = path.join(path.dirname(packageJsonPath), 'node_modules');
     }
-    addDependenciesFromDir(dependencyDir);
+    addAllDependencies(dependencyDir, started, packageJsonPath);
   });
 };
 
 /**
+ * Finds all installed modules in the given dependencyDir (say, /path/to/app/node_modules) and saves the dependency with
+ * the associated version into preliminaryPayload.
+ *
  * @param {string} dependencyDir
+ * @param {number} started
+ * @param {string} packageJsonPath
  */
-function addDependenciesFromDir(dependencyDir) {
-  fs.readdir(dependencyDir, (readDirErr, dependencies) => {
-    if (readDirErr) {
-      return logger.warn('Cannot analyse dependencies due to %s', readDirErr.message);
+function addAllDependencies(dependencyDir, started, packageJsonPath) {
+  addDependenciesFromDir(dependencyDir, () => {
+    if (Object.keys(preliminaryPayload).length <= exports.MAX_DEPENDENCIES) {
+      exports.currentPayload = preliminaryPayload;
+      logger.debug(`Collection of dependencies took ${Date.now() - started} ms.`);
+      return;
     }
 
-    dependencies
-      .filter(
-        (
-          dependency // exclude the .bin directory
-        ) => dependency !== '.bin'
-      )
-      .forEach(dependency => {
-        if (dependency.indexOf('@') === 0) {
-          addDependenciesFromDir(path.join(dependencyDir, dependency));
-        } else {
-          const fullDirPath = path.join(dependencyDir, dependency);
-          // Only check directories. For example, yarn adds a .yarn-integrity file to /node_modules/ which we need to
-          // exclude, otherwise we get a confusing "Failed to identify version of .yarn-integrity dependency due to:
-          // ENOTDIR: not a directory, open '.../node_modules/.yarn-integrity/package.json'." in the logs.
-          fs.stat(fullDirPath, (statErr, stats) => {
-            if (statErr) {
-              return logger.warn('Cannot analyse dependency %s due to %s', fullDirPath, statErr.message);
-            }
-            if (stats.isDirectory()) {
-              const fullPackageJsonPath = path.join(fullDirPath, 'package.json');
-              addDependency(dependency, fullPackageJsonPath);
-            }
-          });
-        }
+    if (packageJsonPath) {
+      new DependencyDistanceCalculator().calculateDistancesFrom(packageJsonPath, distancesFromRoot => {
+        logger.debug(`Collection of dependencies took ${Date.now() - started} ms.`);
+        limitAndSet(distancesFromRoot);
       });
+    } else {
+      logger.debug(`Collection of dependencies took ${Date.now() - started} ms.`);
+      limitAndSet();
+    }
   });
 }
 
 /**
- * @param {*} dependency
- * @param {string} packageJsonPath
+ * Finds all installed modules in dependencyDir (say, /path/to/app/node_modules) and saves the dependency with the
+ * associated version into preliminaryPayload.
+ *
+ * @param {string} dependencyDir
+ * @param {() => void} callback
+ */
+function addDependenciesFromDir(dependencyDir, callback) {
+  fs.readdir(dependencyDir, (readDirErr, dependencies) => {
+    if (readDirErr || !dependencies) {
+      logger.warn('Cannot analyse dependencies due to %s', readDirErr.message);
+      callback();
+      return;
+    }
+
+    const filteredDependendencies = dependencies.filter(
+      (
+        dependency // exclude the .bin directory
+      ) => dependency !== '.bin'
+    );
+    if (filteredDependendencies.length === 0) {
+      callback();
+      return;
+    }
+
+    // This latch fires once all dependencies of the current directory in the node_modules tree have been analysed.
+    const countDownLatch = new CountDownLatch(filteredDependendencies.length);
+    countDownLatch.once('done', () => {
+      callback();
+    });
+
+    filteredDependendencies.forEach(dependency => {
+      if (dependency.indexOf('@') === 0) {
+        addDependenciesFromDir(path.join(dependencyDir, dependency), () => {
+          countDownLatch.countDown();
+        });
+      } else {
+        const fullDirPath = path.join(dependencyDir, dependency);
+        // Only check directories. For example, yarn adds a .yarn-integrity file to /node_modules/ which we need to
+        // exclude, otherwise we get a confusing "Failed to identify version of .yarn-integrity dependency due to:
+        // ENOTDIR: not a directory, open '.../node_modules/.yarn-integrity/package.json'." in the logs.
+        fs.stat(fullDirPath, (statErr, stats) => {
+          if (statErr) {
+            countDownLatch.countDown();
+            logger.warn('Cannot analyse dependency %s due to %s', fullDirPath, statErr.message);
+            return;
+          }
+          if (!stats.isDirectory()) {
+            countDownLatch.countDown();
+            return;
+          }
+
+          addDependency(dependency, fullDirPath, countDownLatch);
+        });
+      }
+    });
+  });
+}
+
+/**
+ * Parses the package.json file in the given directory and then adds the given dependency (with its version) to
+ * preliminaryPayload.
+ *
+ * @param {string} dependency
+ * @param {string} dependencyDirPath
+ * @param {import('./util/CountDownLatch')} countDownLatch
  */
-function addDependency(dependency, packageJsonPath) {
+function addDependency(dependency, dependencyDirPath, countDownLatch) {
+  const packageJsonPath = path.join(dependencyDirPath, 'package.json');
   fs.readFile(packageJsonPath, { encoding: 'utf8' }, (err, contents) => {
     if (err && err.code === 'ENOENT') {
       // This directory does not contain a package json. This happens for example for node_modules/.cache etc.
       // We can simply ignore this.
-      return logger.debug(`No package.json at ${packageJsonPath}, ignoring this directory.`);
+      countDownLatch.countDown();
+      logger.debug(`No package.json at ${packageJsonPath}, ignoring this directory.`);
+      return;
     } else if (err) {
-      return logger.info(
+      countDownLatch.countDown();
+      logger.info(
         'Failed to identify version of %s dependency due to: %s. This means that you will not be ' +
           'able to see details about this dependency within Instana.',
         dependency,
         err.message
       );
+      return;
     }
 
     try {
-      const pckg = JSON.parse(contents);
-      exports.currentPayload[pckg.name] = pckg.version;
-    } catch (subErr) {
+      const parsedPackageJson = JSON.parse(contents);
+      if (!preliminaryPayload[parsedPackageJson.name]) {
+        preliminaryPayload[parsedPackageJson.name] = parsedPackageJson.version;
+      }
+    } catch (parseErr) {
       return logger.info(
         'Failed to identify version of %s dependency due to: %s. This means that you will not be ' +
           'able to see details about this dependency within Instana.',
         dependency,
-        subErr.message
+        parseErr.message
       );
     }
+
+    const potentialNestedNodeModulesFolder = path.join(dependencyDirPath, 'node_modules');
+    fs.stat(potentialNestedNodeModulesFolder, (statErr, stats) => {
+      if (statErr || !stats.isDirectory()) {
+        countDownLatch.countDown();
+        return;
+      }
+      addDependenciesFromDir(potentialNestedNodeModulesFolder, () => {
+        countDownLatch.countDown();
+      });
+    });
   });
 }
+
+/**
+ * Limits the collected dependencies to exports.MAX_DEPENDENCIES entries and commits them to exports.currentPayload.
+ *
+ * @param {Object<string, any>} distances
+ */
+function limitAndSet(distances = {}) {
+  const keys = Object.keys(preliminaryPayload);
+  keys.sort(sortByDistance.bind(null, distances));
+
+  // After sorting, the most distant (and therefore, most uninteresting) packages are a the start of the array. For
+  // packages with the same distance, we sort in a reverse lexicographic order. That means, that if no distances are
+  // available at all, packages will be in reverse lexicographical order.
+  //
+  // At any rate, we start deleting collected depenencies from the payload at index 0, that is, we either remove the
+  // most distant ones or the ones that are at the end of the lexicographic order.
+  for (let i = 0; i < keys.length - exports.MAX_DEPENDENCIES; i++) {
+    delete preliminaryPayload[keys[i]];
+  }
+  exports.currentPayload = preliminaryPayload;
+}
+
+/**
+ * Compares the given dependencies by their distance.
+ *
+ * @param {Object<string, any>} distances
+ * @param {string} dependency1
+ * @param {string} dependency2
+ */
+function sortByDistance(distances, dependency1, dependency2) {
+  // To make troubleshooting easier, we always want to include the Instana dependencies, therefore they will be sorted
+  // to the end of the array.
+  const isInstana1 = dependency1.indexOf('instana') >= 0;
+  const isInstana2 = dependency2.indexOf('instana') >= 0;
+  if (isInstana1 && isInstana2) {
+    return dependency2.localeCompare(dependency1);
+  } else if (isInstana1) {
+    return 1;
+  } else if (isInstana2) {
+    return -1;
+  }
+
+  const d1 = distances[dependency1] || MAX_DEPTH + 1;
+  const d2 = distances[dependency2] || MAX_DEPTH + 1;
+  if (d1 === d2) {
+    // for the same distance, sort lexicographically
+    return dependency2.localeCompare(dependency1);
+  }
+  return d2 - d1;
+}

package/src/directDependencies.js

@@ -56,6 +56,7 @@ exports.activate = function activate() {
  * @param {string} packageJsonPath
  */
 function addDirectDependenciesFromMainPackageJson(packageJsonPath) {
+  const started = Date.now();
   fs.readFile(packageJsonPath, { encoding: 'utf8' }, (err, contents) => {
     if (err) {
       return logger.debug('Failed to analyze direct dependencies dependency due to: %s.', err.message);
@@ -67,7 +68,9 @@ function addDirectDependenciesFromMainPackageJson(packageJsonPath) {
       exports.currentPayload.peerDependencies = pckg.peerDependencies || {};
       exports.currentPayload.optionalDependencies = pckg.optionalDependencies || {};
       exports.currentPayload[pckg.name] = pckg.version;
+      logger.debug(`Collection of direct dependencies took ${Date.now() - started} ms.`);
     } catch (subErr) {
+      logger.debug(`Collection of direct dependencies took ${Date.now() - started} ms.`);
       return logger.debug('Failed to parse package.json %s dependency due to: %s', packageJsonPath, subErr.message);
     }
   });

package/src/index.js

@@ -5,6 +5,7 @@
 
 'use strict';
 
+/** @type {Array.<import('@instana/core/src/metrics').InstanaMetricsModule>} */
 const allMetrics = [
   require('./activeHandles'),
   require('./activeRequests'),
@@ -36,9 +37,9 @@ const setLogger = function (logger) {
 
 /**
  * @typedef {Object} InstanaSharedMetrics
- * @property {Array.<*>} allMetrics
- * @property {*} util
- * @property {*} setLogger
+ * @property {Array.<import('@instana/core/src/metrics').InstanaMetricsModule>} allMetrics
+ * @property {import('./util')} util
+ * @property {(logger: import('@instana/core/src/logger').GenericLogger) => void} setLogger
  */
 
 /** @type {InstanaSharedMetrics} */

package/src/util/CountDownLatch.js

@@ -0,0 +1,34 @@
+/*
+ * (c) Copyright IBM Corp. 2021
+ * (c) Copyright Instana Inc. and contributors 2021
+ */
+
+'use strict';
+
+const EventEmitter = require('events');
+const assert = require('assert');
+
+class CountDownLatch extends EventEmitter {
+  constructor(counter = 1) {
+    super();
+    assert(counter >= 0);
+    this.counter = counter;
+    this.doneEmitted = false;
+  }
+
+  countUp(increment = 1) {
+    this.counter += increment;
+  }
+
+  countDown(decrement = 1) {
+    if (this.counter >= decrement) {
+      this.counter -= decrement;
+      if (this.counter === 0 && !this.doneEmitted) {
+        this.emit('done');
+        this.doneEmitted = true;
+      }
+    }
+  }
+}
+
+module.exports = CountDownLatch;

package/src/util/DependencyDistanceCalculator.js

@@ -0,0 +1,250 @@
+/*
+ * (c) Copyright IBM Corp. 2021
+ * (c) Copyright Instana Inc. and contributors 2021
+ */
+
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+const CountDownLatch = require('./CountDownLatch');
+
+let logger = require('@instana/core').logger.getLogger('metrics');
+
+/**
+ * @param {import('@instana/core/src/logger').GenericLogger} _logger
+ */
+exports.setLogger = function setLogger(_logger) {
+  logger = _logger;
+};
+
+class DependencyDistanceCalculator {
+  /**
+   * Calculates the distance for all dependencies, starting at the given package.json file. Direct dependencies listed
+   * in the passed package.json have distance 1. Dependencies of those dependencies have distance 2, and so on. This is
+   * calculated by parsing package.json files recursively, traversing the tree of dependencies.
+   *
+   * @param {string} packageJsonPath the path to the package.json file to examine initially
+   * @param {(distances: Object<string, any>) => void} callback
+   */
+  calculateDistancesFrom(packageJsonPath, callback) {
+    this.started = Date.now();
+    assert.strictEqual(typeof packageJsonPath, 'string');
+    assert.strictEqual(typeof callback, 'function');
+    /** @type {Object.<string, any>} */
+    this.distancesFromRoot = {};
+
+    this.globalCountDownLatchAllPackages = new CountDownLatch(0);
+    this.globalCountDownLatchAllPackages.once('done', () => {
+      logger.debug(`Calculation of dependency distances took ${Date.now() - this.started} ms.`);
+      callback(this.distancesFromRoot);
+    });
+    this._calculateDistances(packageJsonPath, 1);
+  }
+
+  /**
+   * Calculates the distances for the dependencies in the given package.json file. Direct dependencies of the
+   * application have distance 1. Dependencies of those dependencies have distance 2, and so on. This is calculated by
+   * parsing package.json files recursively, traversing the tree of dependencies.
+   *
+   * @param {string} packageJsonPath The path to the package.json file to examine
+   * @param {number} distance The distance from the application along the tree of dependencies
+   */
+  _calculateDistances(packageJsonPath, distance) {
+    if (distance > module.exports.MAX_DEPTH) {
+      // Do not descend deeper than maxDepth nesting levels.
+      return;
+    }
+
+    // For each package.json that we find in the dependency tree, we initially increase the global count down latch
+    // by 3, that is, one for each type of dependencies (normal, optional, peer). Once we have in turn queued all
+    // dependencies found in this package.json for a particular dependency type, we decrement the global count down
+    // latch by one. When this has happend for all three types of dependencies, the net change for the global latch will
+    // be zero, but sub dependencies will already have been incremented the global count down latch.
+    this.globalCountDownLatchAllPackages.countUp(3);
+
+    // Read the associated package.json and parse it.
+    fs.readFile(packageJsonPath, { encoding: 'utf8' }, (err, contents) => {
+      if (err) {
+        logger.debug(
+          'Failed to calculate transitive distances for some dependencies, could not read package.json file at %s: %s.',
+          packageJsonPath,
+          err.message
+        );
+
+        // If we cannot parse the package.json or if it does not exist, we need to decrement by 3 immediately because we
+        // increment the latch by 3 for each node (see above).
+        this.globalCountDownLatchAllPackages.countDown(3);
+        return;
+      }
+
+      let parsedPackageJson;
+      try {
+        parsedPackageJson = JSON.parse(contents);
+      } catch (parseErr) {
+        logger.debug(
+          'Failed to calculate transitive distances for some dependencies, could not parse package.json file at %s: %s',
+          packageJsonPath,
+          parseErr.message
+        );
+        this.globalCountDownLatchAllPackages.countDown(3);
+        return;
+      }
+
+      // Each call to _calculateDistancesForOneType is guaranteed to decrease the global count down latch by exactly
+      // one, to offset the increment of 3 that we did for this node in the dependency tree initially.
+      this._calculateDistancesForOneType(parsedPackageJson.dependencies, distance);
+      this._calculateDistancesForOneType(parsedPackageJson.peerDependencies, distance);
+      this._calculateDistancesForOneType(parsedPackageJson.optionalDependencies, distance);
+    });
+  }
+
+  /**
+   * Iterates over the given set of dependencies to calculate their distances. The set of dependencies will what is
+   * defined in a package.json file for one particular type of dependencys (normal, optional, or peer).
+   *
+   * @param {Array<string>} dependencies The dependencies to analyze
+   * @param {number} distance How far the dependencies are from the root package
+   */
+  _calculateDistancesForOneType(dependencies, distance) {
+    if (!dependencies) {
+      this.globalCountDownLatchAllPackages.countDown();
+      return;
+    }
+    const keys = Object.keys(dependencies);
+    if (keys.length === 0) {
+      this.globalCountDownLatchAllPackages.countDown();
+      return;
+    }
+
+    // This local latch is initialized with the number of dependencies of the current package.json file for the
+    // particular dependency type (normal dependencies, optional ones, peer dependencies) we are analyzing at the
+    // moment. Once all sub dependencies for the current package and type have been either
+    //
+    // a) scheduled for analysis (and have in turn incremented the global count down latch), or
+    // b) have been found to not need further analysis,
+    //
+    // we consider the current node to be done and reduce the global counter/ accordingly.
+    const localCountDownLatchForThisNode = new CountDownLatch(keys.length);
+    localCountDownLatchForThisNode.once('done', () => {
+      this.globalCountDownLatchAllPackages.countDown();
+    });
+
+    for (let i = 0; i < keys.length; i++) {
+      const dependency = keys[i];
+      if (this.distancesFromRoot[dependency]) {
+        // We have seen this package before. Do not analyze this package again.
+        this.distancesFromRoot[dependency] = Math.min(distance, this.distancesFromRoot[dependency]);
+        localCountDownLatchForThisNode.countDown();
+        continue;
+      }
+
+      // We have not seen this package yet, store the distance for it.
+      this.distancesFromRoot[dependency] = distance;
+
+      // Queue this dependency up for further analysis. The local latch is only decremented after we have incremented
+      // the/ global latch for this dependency. This makes sure we do not stop the analysis too early.
+      this._handleTransitiveDependency(dependency, distance, localCountDownLatchForThisNode);
+    }
+  }
+
+  /**
+   * Handles a single dependency found in a package.json file.
+   *
+   * @param {string} dependency the name of the dependency to analyze
+   * @param {number} distance how far this dependency is from the root package
+   * @param {import('./CountDownLatch')} localCountDownLatchForThisNode
+   */
+  _handleTransitiveDependency(dependency, distance, localCountDownLatchForThisNode) {
+    let mainModulePath;
+    try {
+      mainModulePath = require.resolve(dependency);
+    } catch (requireResolveErr) {
+      // ignore
+      logger.debug(
+        `Ignoring failure to resolve the path to dependency ${dependency} for dependency distance calculation.`
+      );
+    }
+
+    if (!mainModulePath) {
+      // Could not find the package.json for this dependency so we cannot analyze it further, which means we are done
+      // with it.
+      localCountDownLatchForThisNode.countDown();
+      logger.debug(`No main module path for dependency ${dependency}.`);
+      return;
+    }
+
+    findPackageJsonFor(path.dirname(mainModulePath), (err, packageJsonPath) => {
+      if (err) {
+        localCountDownLatchForThisNode.countDown();
+        logger.debug(
+          `Ignoring failure to find the package.json file for dependency ${dependency} for dependency distance ` +
+            'calculation.',
+          err
+        );
+        return;
+      }
+
+      // Recurse one level deeper and queue the next package.json path for analysis.
+      this._calculateDistances(packageJsonPath, distance + 1);
+
+      // After the _calculateDistances call we have "handled" the package associated to packageJsonPath, that is, we
+      // have (synchronously) incremented the global latch for it. That is, unless we have hit the depth limit, but even
+      // then we consider that package to have been handled). Thus, we can now decrement the local latch for it.
+      localCountDownLatchForThisNode.countDown();
+    });
+  }
+}
+
+/**
+ * Finds the package.json file for a given directory, by starting in the given directory and then travelling the
+ * directory tree upwards until a package.json file is found.
+ *
+ * @param {string} dir
+ * @param {(err: Error, packageJsonPath: string) => void} callback
+ */
+function findPackageJsonFor(dir, callback) {
+  const pathToCheck = path.join(dir, 'package.json');
+  fs.stat(pathToCheck, (err, stats) => {
+    if (err) {
+      if (err.code === 'ENOENT') {
+        return searchInParentDir(dir, findPackageJsonFor, callback);
+      } else {
+        return process.nextTick(callback, err, null);
+      }
+    }
+
+    if (stats.isFile()) {
+      return process.nextTick(callback, null, pathToCheck);
+    } else {
+      return searchInParentDir(dir, findPackageJsonFor, callback);
+    }
+  });
+}
+
+/**
+ * Goes to the parent directory of the given dir and executes the function onParentDir on it.
+ *
+ * @param {string} dir
+ * @param {(parentDir: string, callback: Function) => void} onParentDir
+ * @param {(err: Error, packageJsonPath: string) => void} callback
+ */
+function searchInParentDir(dir, onParentDir, callback) {
+  const parentDir = path.resolve(dir, '..');
+  if (dir === parentDir) {
+    // We have arrived at the root of the file system hierarchy.
+    // findPackageJsonFor would have called callback asynchronously,
+    // so we use process.nextTick here to make all paths async.
+    return process.nextTick(callback, null, null);
+  }
+
+  return onParentDir(parentDir, callback);
+}
+
+module.exports = {
+  DependencyDistanceCalculator,
+  MAX_DEPTH: 15,
+  __moduleRefExportedForTest: module
+};