newrelic 9.0.0 → 9.0.3

package/lib/environment.js

@@ -5,9 +5,8 @@
 
 'use strict'
 
-const a = require('async')
 const path = require('path')
-const fs = require('./util/unwrapped-core').fs
+const { fsPromises } = require('./util/unwrapped-core')
 const os = require('os')
 const logger = require('./logger').child({ component: 'environment' })
 const stringify = require('json-stringify-safe')
@@ -31,8 +30,7 @@ let settings = Object.create(null)
  * Fetches the setting of the given name, defaulting to an empty array.
  *
  * @param {string} name - The name of the setting to look for.
- *
- * @return {Array.<string>} An array of values matching that name.
+ * @returns {Array.<string>} An array of values matching that name.
  */
 function getSetting(name) {
   return settings[name] || []
@@ -67,73 +65,47 @@ function clearSetting(name) {
  *
  * @param {string}    root          - Path to start listing packages from.
  * @param {Array}     [packages=[]] - Array to append found packages to.
- * @param {function}  callback      - Callback function.
- *
- * @return {Array} List of packages.
  */
-function listPackages(root, packages, callback) {
-  // listPackages(root, callback)
-  if (typeof packages === 'function') {
-    callback = packages
-    packages = []
-  }
+async function listPackages(root, packages = []) {
   _log('Listing packages in %s', root)
 
-  a.waterfall(
-    [
-      a.apply(fs.readdir, root),
-      function iterateDirs(dirs, cb) {
-        a.eachLimit(dirs, 2, forEachDir, cb)
-      }
-    ],
-    function onAllDirsRead(err) {
-      _log('Done listing packages in %s', root)
-      if (err) {
-        logger.trace(err, 'Could not list packages in %s (probably not an error)', root)
-        return callback()
-      }
-      callback(null, packages)
-    }
-  )
+  try {
+    const dirs = await fsPromises.readdir(root)
+    await Promise.all(dirs.map(forEachDir))
+    _log('Done listing packages in %s', root)
+  } catch (err) {
+    logger.trace(err, 'Could not list packages in %s (probably not an error)', root)
+  }
 
-  function forEachDir(dir, cb) {
+  async function forEachDir(dir) {
     _log('Checking package %s in %s', dir, root)
 
     // Skip npm's binary directory where it stores executables.
     if (dir === '.bin') {
       _log('Skipping .bin directory')
-      return setImmediate(cb)
+      return
     }
 
     // Recurse into module scopes.
     if (dir[0] === '@') {
       logger.trace('Recursing into scoped module directory %s', dir)
-      return listPackages(path.resolve(root, dir), packages, cb)
+      return listPackages(path.resolve(root, dir), packages)
     }
 
     // Read the package and pull out the name and version of it.
     const pkg = path.resolve(root, dir, 'package.json')
-    fs.readFile(pkg, function onPackageRead(err, pkgFile) {
+    let name = null
+    let version = null
+    try {
+      const pkgFile = await fsPromises.readFile(pkg)
       _log('Read package at %s', pkg)
-      if (err) {
-        logger.debug(err, 'Could not read %s.', pkg)
-        return cb()
-      }
-
-      let name = null
-      let version = null
-      try {
-        const pkgData = JSON.parse(pkgFile)
-        name = pkgData.name
-        version = pkgData.version
-      } catch (e) {
-        logger.debug(err, 'Could not parse package file %s.', pkg)
-      }
+      ;({ name, version } = JSON.parse(pkgFile))
+    } catch (err) {
+      logger.debug(err, 'Could not read %s.', pkg)
+    }
 
-      packages.push([name || dir, version || '<unknown>'])
-      _log('Package from %s added (%s@%s)', pkg, name, version)
-      cb()
-    })
+    packages.push([name || dir, version || '<unknown>'])
+    _log('Package from %s added (%s@%s)', pkg, name, version)
   }
 }
 
@@ -143,131 +115,73 @@ function listPackages(root, packages, callback) {
  * @param {string}    root        - Path to start listing dependencies from.
  * @param {Array}     [children]  - Array to append found dependencies to.
  * @param {object}    [visited]   - Map of visited directories.
- * @param {function}  callback    - Callback to send deps to.
- *
- * @return {Array} List of dependencies.
  */
-function listDependencies(root, children, visited, callback) {
-  // listDependencies(root, callback)
-  if (typeof children === 'function') {
-    callback = children
-    children = []
-    visited = Object.create(null)
-  }
-  // listDependencies(root, {children|visited}, callback)
-  if (typeof visited === 'function') {
-    callback = visited
-    if (Array.isArray(children)) {
-      visited = Object.create(null)
-    } else {
-      visited = children
-      children = []
-    }
-  }
+async function listDependencies(root, children = [], visited = Object.create(null)) {
   _log('Listing dependencies in %s', root)
 
-  a.waterfall(
-    [
-      a.apply(fs.readdir, root),
-      function iterateDirs(dirs, cb) {
-        a.eachLimit(dirs, 2, forEachEntry, cb)
-      }
-    ],
-    function onAllDirsRead(err) {
-      _log('Done listing dependencies in %s', root)
-      if (err) {
-        logger.trace(err, 'Could not read directories in %s (probably not an error)', root)
-        return callback()
-      }
-      callback(null, children)
-    }
-  )
+  try {
+    const dirs = await fsPromises.readdir(root)
+    await Promise.all(dirs.map(forEachEntry))
+    _log('Done listing dependencies in %s', root)
+  } catch (err) {
+    logger.trace(err, 'Could not read directories in %s (probably not an error)', root)
+  }
 
-  function forEachEntry(entry, cb) {
+  async function forEachEntry(entry) {
     _log('Checking dependencies in %s (%s)', entry, root)
 
     const candidate = path.resolve(root, entry, 'node_modules')
-    fs.realpath(candidate, function realPathCb(err, realCandidate) {
+    try {
+      const realCandidate = await fsPromises.realpath(candidate)
       _log('Resolved %s to real path %s', candidate, realCandidate)
-      if (err) {
-        // Don't care to log about files that don't exist.
-        if (err.code !== 'ENOENT') {
-          logger.debug(err, 'Failed to resolve candidate real path %s', candidate)
-        }
-        _log(err, 'Real path for %s failed', candidate)
-        return cb()
-      }
-
       // Make sure we haven't been to this directory before.
       if (visited[realCandidate]) {
         logger.trace('Not revisiting %s (from %s)', realCandidate, candidate)
-        return cb()
       }
       visited[realCandidate] = true
 
       // Load the packages and dependencies for this directory.
-      a.series(
-        [
-          a.apply(listPackages, realCandidate, children),
-          a.apply(listDependencies, realCandidate, children, visited)
-        ],
-        function onRecurseListComplete(loadErr) {
-          _log('Done with dependencies in %s', realCandidate)
-          if (loadErr) {
-            logger.debug(loadErr, 'Failed to list dependencies in %s', realCandidate)
-          }
-          cb()
-        }
-      )
-    })
+      await listPackages(realCandidate, children)
+      await listDependencies(realCandidate, children, visited)
+      _log('Done with dependencies in %s', realCandidate)
+    } catch (err) {
+      // Don't care to log about files that don't exist.
+      if (err.code !== 'ENOENT') {
+        logger.debug(err, 'Failed to resolve candidate real path %s', candidate)
+      }
+      _log(err, 'Real path for %s failed', candidate)
+    }
   }
 }
 
 /**
  * Build up a list of packages, starting from the current directory.
  *
- * @return {Object} Two lists, of packages and dependencies, with the
+ * @returns {object} Two lists, of packages and dependencies, with the
  *  appropriate names.
  */
-function getLocalPackages(callback) {
+async function getLocalPackages() {
   const packages = []
   const dependencies = []
   let candidate = process.cwd()
   const visited = Object.create(null)
   _log('Getting local packages')
 
-  a.whilst(
-    function checkCandidate(cb) {
-      return cb(null, candidate)
-    },
-    function iterate(cb) {
-      _log('Checking for local packages in %s', candidate)
-      const root = path.resolve(candidate, 'node_modules')
-      a.series(
-        [
-          a.apply(listPackages, root, packages),
-          a.apply(listDependencies, root, dependencies, visited)
-        ],
-        function onListComplete(err) {
-          _log('Done checking for local packages in %s', candidate)
-          const last = candidate
-          candidate = path.dirname(candidate)
-          if (last === candidate) {
-            candidate = null
-          }
-          cb(err)
-        }
-      )
-    },
-    function whileComplete(err) {
-      _log('Done getting local packages')
-      if (err) {
-        callback(err)
-      } else {
-        callback(null, { packages: packages, dependencies: dependencies })
-      }
+  while (candidate) {
+    _log('Checking for local packages in %s', candidate)
+    const root = path.resolve(candidate, 'node_modules')
+    await listPackages(root, packages)
+    await listDependencies(root, dependencies, visited)
+    _log('Done checking for local packages in %s', candidate)
+    const last = candidate
+    candidate = path.dirname(candidate)
+    if (last === candidate) {
+      candidate = null
     }
-  )
+  }
+
+  _log('Done getting local packages')
+  return { packages, dependencies }
 }
 
 /**
@@ -275,48 +189,40 @@ function getLocalPackages(callback) {
  * provided root directory.
  *
  * @param {string} root - Where to start looking -- doesn't add node_modules.
- *
- * @return {Object} Two lists, of packages and dependencies, with the
+ * @returns {object} Two lists, of packages and dependencies, with the
  *  appropriate names.
  */
-function getPackages(root, cb) {
+async function getPackages(root) {
   const packages = []
   const dependencies = []
   _log('Getting packages from %s', root)
 
-  a.series(
-    [a.apply(listPackages, root, packages), a.apply(listDependencies, root, dependencies)],
-    function onListComplete(err) {
-      _log('Done getting packages from %s', root)
-      if (err) {
-        cb(err)
-      } else {
-        cb(null, { packages: packages, dependencies: dependencies })
-      }
-    }
-  )
+  await listPackages(root, packages)
+  await listDependencies(root, dependencies)
+  _log('Done getting packages from %s', root)
+  return { packages, dependencies }
 }
 
 /**
  * Generate a list of globally-installed packages, if available / accessible
  * via the environment.
  *
- * @return {Object} Two lists, of packages and dependencies, with the
+ * @returns {object} Two lists, of packages and dependencies, with the
  *  appropriate names.
  */
-function getGlobalPackages(cb) {
+function getGlobalPackages() {
   _log('Getting global packages')
   if (process.config && process.config.variables) {
     const prefix = process.config.variables.node_prefix
     if (prefix) {
       const root = path.resolve(prefix, 'lib', 'node_modules')
       _log('Getting global packages from %s', root)
-      return getPackages(root, cb)
+      return getPackages(root)
     }
   }
 
   _log('No global packages to get')
-  setImmediate(cb, null, { packages: [], dependencies: [] })
+  return { packages: [], dependencies: [] }
 }
 
 /**
@@ -325,7 +231,8 @@ function getGlobalPackages(cb) {
  * package appears at most once, with all the versions joined into a
  * comma-delimited list.
  *
- * @return {Array.<string[]>} Sorted list of [name, version] pairs.
+ * @param packages
+ * @returns {Array.<string[]>} Sorted list of [name, version] pairs.
  */
 function flattenVersions(packages) {
   const info = Object.create(null)
@@ -383,12 +290,12 @@ function remapConfigSettings() {
   }
 }
 
-function getOtherPackages(callback) {
+async function getOtherPackages() {
   _log('Getting other packages')
   const other = { packages: [], dependencies: [] }
 
   if (!process.env.NODE_PATH) {
-    return callback(null, other)
+    return other
   }
 
   let paths
@@ -400,31 +307,25 @@ function getOtherPackages(callback) {
   }
   _log('Looking for other packages in %j', paths)
 
-  a.eachLimit(
-    paths,
-    2,
-    function listEachOtherPackage(nodePath, cb) {
-      if (nodePath[0] !== '/') {
-        nodePath = path.resolve(process.cwd(), nodePath)
-      }
-      _log('Getting other packages from %s', nodePath)
-      getPackages(nodePath, function onGetPackageFinish(err, nextSet) {
-        _log('Done getting other packages from %s', nodePath)
-        if (!err && nextSet) {
-          other.packages.push.apply(other.packages, nextSet.packages)
-          other.dependencies.push.apply(other.dependencies, nextSet.dependencies)
-        }
-        cb(err)
-      })
-    },
-    function onOtherFinish(err) {
-      _log('Done getting other packages')
-      callback(err, other)
+  const pathPromises = paths.map((nodePath) => {
+    if (nodePath[0] !== '/') {
+      nodePath = path.resolve(process.cwd(), nodePath)
     }
-  )
+    _log('Getting other packages from %s', nodePath)
+    return getPackages(nodePath)
+  })
+
+  const otherPackages = await Promise.all(pathPromises)
+  otherPackages.forEach((pkg) => {
+    other.packages.push.apply(other.packages, pkg.packages)
+    other.dependencies.push.apply(other.dependencies, pkg.dependencies)
+  })
+
+  _log('Done getting other packages')
+  return other
 }
 
-function getHomePackages(cb) {
+async function getHomePackages() {
   let homeDir = null
   if (process.platform === 'win32') {
     if (process.env.USERDIR) {
@@ -436,20 +337,14 @@ function getHomePackages(cb) {
 
   _log('Getting home packages from %s', homeDir)
   if (!homeDir) {
-    return cb(null, null)
+    return
   }
 
-  a.mapSeries(
-    {
-      home: path.resolve(homeDir, '.node_modules'),
-      homeOld: path.resolve(homeDir, '.node_libraries')
-    },
-    getPackages,
-    function onHomeFinish(err, packages) {
-      _log('Done getting home packages from %s', homeDir)
-      cb(err, packages)
-    }
-  )
+  const homePath = path.resolve(homeDir, '.node_modules')
+  const homeOldPath = path.resolve(homeDir, '.node_libraries')
+  const home = await getPackages(homePath)
+  const homeOld = await getPackages(homeOldPath)
+  return { home, homeOld }
 }
 
 /**
@@ -461,59 +356,47 @@ function getHomePackages(cb) {
  * This function works entirely via side effects using the addSetting
  * function.
  */
-function findPackages(cb) {
+async function findPackages() {
   _log('Finding all packages')
-  a.parallelLimit(
-    {
-      local: time(getLocalPackages),
-      global: time(getGlobalPackages),
-      other: time(getOtherPackages),
-      home: time(getHomePackages)
-    },
-    2,
-    function onPackageComplete(err, data) {
-      _log('Done finding all packages')
-      if (err) {
-        return cb(err)
-      }
-
-      const packages = data.local.packages
-      packages.push.apply(packages, data.global.packages)
-      packages.push.apply(packages, data.other.packages)
-
-      const dependencies = data.local.dependencies
-      dependencies.push.apply(dependencies, data.global.dependencies)
-      dependencies.push.apply(dependencies, data.other.dependencies)
-
-      if (data.home) {
-        if (data.home.home) {
-          packages.unshift.apply(packages, data.home.home.packages)
-          dependencies.unshift.apply(dependencies, data.home.home.dependencies)
-        }
-        if (data.home.homeOld) {
-          packages.unshift.apply(packages, data.home.homeOld.packages)
-          dependencies.unshift.apply(dependencies, data.home.homeOld.dependencies)
-        }
-      }
-
-      addSetting('Packages', flattenVersions(packages))
-      addSetting('Dependencies', flattenVersions(dependencies))
-      cb()
+  const pkgPromises = [
+    time(getLocalPackages),
+    time(getGlobalPackages),
+    time(getOtherPackages),
+    time(getHomePackages)
+  ]
+  const [local, global, other, home] = await Promise.all(pkgPromises)
+  _log('Done finding all packages')
+  const packages = local.packages
+  packages.push.apply(packages, global.packages)
+  packages.push.apply(packages, other.packages)
+
+  const dependencies = local.dependencies
+  dependencies.push.apply(dependencies, global.dependencies)
+  dependencies.push.apply(dependencies, other.dependencies)
+
+  if (home) {
+    if (home.home) {
+      packages.unshift.apply(packages, home.home.packages)
+      dependencies.unshift.apply(dependencies, home.home.dependencies)
+    }
+    if (home.homeOld) {
+      packages.unshift.apply(packages, home.homeOld.packages)
+      dependencies.unshift.apply(dependencies, home.homeOld.dependencies)
     }
-  )
+  }
+
+  addSetting('Packages', flattenVersions(packages))
+  addSetting('Dependencies', flattenVersions(dependencies))
 }
 
-function time(fn) {
+async function time(fn) {
   const name = fn.name
-  return function timeWrapper(cb) {
-    const start = Date.now()
-    logger.trace('Starting %s', name)
-    return fn(function wrappedCb() {
-      const end = Date.now()
-      logger.trace('Finished %s in %dms', name, end - start)
-      cb.apply(this, arguments)
-    })
-  }
+  const start = Date.now()
+  logger.trace('Starting %s', name)
+  const data = await fn()
+  const end = Date.now()
+  logger.trace('Finished %s in %dms', name, end - start)
+  return data
 }
 
 /**
@@ -565,7 +448,7 @@ function refreshSyncOnly() {
 /**
  * Reset settings and gather them, built to minimally refactor this file.
  */
-function refresh(cb) {
+async function refresh() {
   _log('Refreshing environment settings')
   refreshSyncOnly()
 
@@ -576,38 +459,34 @@ function refresh(cb) {
     settings.Packages = packages
     settings.Dependencies = dependencies
     _log('Using cached values')
-    setImmediate(cb)
-  } else {
-    _log('Fetching new package information')
-    findPackages(cb)
+    return
   }
+  _log('Fetching new package information')
+  await findPackages()
 }
 
 /**
  * Refreshes settings and returns the settings object.
  *
  * @private
- *
- * @param {function} cb - Callback to send results to.
+ * @returns {Promise}
  */
-function getJSON(cb) {
+async function getJSON() {
   _log('Getting environment JSON')
-  refresh(function onRefreshFinish(err) {
-    _log('Environment refresh finished')
-    if (err) {
-      cb(err)
-      return
-    }
+  try {
+    await refresh()
+  } catch (err) {
+    // swallow error
+  }
 
-    const items = []
-    Object.keys(settings).forEach(function settingKeysForEach(key) {
-      settings[key].forEach(function settingsValuesForEach(setting) {
-        items.push([key, setting])
-      })
+  const items = []
+  Object.keys(settings).forEach(function settingKeysForEach(key) {
+    settings[key].forEach(function settingsValuesForEach(setting) {
+      items.push([key, setting])
     })
-    _log('JSON got')
-    cb(null, items)
   })
+  _log('JSON got')
+  return items
 }
 
 // At startup, do the synchronous environment scanning stuff.
@@ -643,10 +522,10 @@ module.exports = {
     clearSetting('Dispatcher')
     clearSetting('Dispatcher Version')
   },
-  listPackages: listPackages,
-  getJSON: getJSON,
+  listPackages,
+  getJSON,
   get: getSetting,
-  refresh: refresh
+  refresh
 }
 
 /**

package/lib/instrumentation/grpc-js/grpc.js

@@ -78,9 +78,7 @@ function wrapStart(shim, original) {
         segment.addAttribute('grpc.statusCode', code)
         segment.addAttribute('grpc.statusText', details)
 
-        // Java captures client errors based on status code
-        // but has specific gRPC configuration to turn off
-        if (code !== 0) {
+        if (code !== 0 && shim.agent.config.grpc.record_errors) {
           // this is currently just creating an error from the details string
           shim.agent.errors.add(segment.transaction, details)
         }

package/lib/metrics/names.js

@@ -273,7 +273,8 @@ const LOGGING = {
     WARN: `${LOGGING_LINES_PREFIX}/WARN`,
     ERROR: `${LOGGING_LINES_PREFIX}/ERROR`,
     DEBUG: `${LOGGING_LINES_PREFIX}/DEBUG`,
-    TRACE: `${LOGGING_LINES_PREFIX}/TRACE`
+    TRACE: `${LOGGING_LINES_PREFIX}/TRACE`,
+    UNKNOWN: `${LOGGING_LINES_PREFIX}/UNKNOWN`
   },
   LIBS: {
     PINO: `${SUPPORTABILITY.LOGGING}/${NODEJS.PREFIX}pino/enabled`,