newrelic 9.7.0 → 9.7.2

package/lib/environment.js

@@ -10,6 +10,7 @@ const { fsPromises } = require('./util/unwrapped-core')
 const os = require('os')
 const logger = require('./logger').child({ component: 'environment' })
 const stringify = require('json-stringify-safe')
+const asyncEachLimit = require('./util/async-each-limit')
 const DISPATCHER_VERSION = 'Dispatcher Version'
 
 // As of 1.7.0 you can no longer dynamically link v8
@@ -72,7 +73,7 @@ async function listPackages(root, packages = []) {
 
   try {
     const dirs = await fsPromises.readdir(root)
-    await Promise.all(dirs.map(forEachDir))
+    await asyncEachLimit(dirs, forEachDir, 2)
     _log('Done listing packages in %s', root)
   } catch (err) {
     logger.trace(err, 'Could not list packages in %s (probably not an error)', root)
@@ -122,7 +123,7 @@ async function listDependencies(root, children = [], visited = Object.create(nul
 
   try {
     const dirs = await fsPromises.readdir(root)
-    await Promise.all(dirs.map(forEachEntry))
+    await asyncEachLimit(dirs, forEachEntry, 2)
     _log('Done listing dependencies in %s', root)
   } catch (err) {
     logger.trace(err, 'Could not read directories in %s (probably not an error)', root)
@@ -232,7 +233,7 @@ function getGlobalPackages() {
  * package appears at most once, with all the versions joined into a
  * comma-delimited list.
  *
- * @param packages
+ * @param {Array} packages list of packages to process
  * @returns {Array.<string[]>} Sorted list of [name, version] pairs.
  */
 function flattenVersions(packages) {
@@ -308,15 +309,18 @@ async function getOtherPackages() {
   }
   _log('Looking for other packages in %j', paths)
 
-  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 asyncEachLimit(
+    paths,
+    (nodePath) => {
+      if (nodePath[0] !== '/') {
+        nodePath = path.resolve(process.cwd(), nodePath)
+      }
+      _log('Getting other packages from %s', nodePath)
+      return getPackages(nodePath)
+    },
+    2
+  )
 
-  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)
@@ -470,7 +474,7 @@ async function refresh() {
  * Refreshes settings and returns the settings object.
  *
  * @private
- * @returns {Promise}
+ * @returns {Promise} the updated/refreshed settings
  */
 async function getJSON() {
   _log('Getting environment JSON')

package/lib/errors/error-collector.js

@@ -5,13 +5,12 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 25] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 const errorsModule = require('./index')
 
 const logger = require('../logger').child({ component: 'error_tracer' })
 const urltils = require('../util/urltils')
 const Exception = require('../errors').Exception
+const Transaction = require('../transaction')
 const errorHelper = require('./helper')
 const createError = errorsModule.createError
 const createEvent = errorsModule.createEvent
@@ -75,6 +74,7 @@ class ErrorCollector {
    *
    * @param {?Transaction}  transaction -
    * @param {Error}         exception   - The error to be checked.
+   * @returns {boolean} whether or not the exception has already been tracked
    */
   _haveSeen(transaction, exception) {
     const txId = transaction ? transaction.id : 'Unknown'
@@ -109,12 +109,78 @@ class ErrorCollector {
     return false
   }
 
+  /**
+   * Helper method for processing errors that are created with .noticeError()
+   *
+   * @param {Transaction} transaction the collected exception's transaction
+   * @param {number} collectedErrors the number of errors we've successfully .collect()-ed
+   * @returns {number} the new number of errors successfully .collect()-ed
+   */
+  _processUserErrors(transaction, collectedErrors) {
+    if (transaction.userErrors.length) {
+      for (let i = 0; i < transaction.userErrors.length; i++) {
+        const exception = transaction.userErrors[i]
+        if (this.collect(transaction, exception)) {
+          ++collectedErrors
+        }
+      }
+    }
+
+    return collectedErrors
+  }
+
+  /**
+   * Helper method for processing exceptions on the transaction (transaction.exceptions array)
+   *
+   * @param {Transaction} transaction the transaction being processed
+   * @param {number} collectedErrors the number of errors successfully .collect()-ed
+   * @param {number} expectedErrors the number of collected errors that were expected
+   * @returns {Array.<number>} the updated [collectedErrors, expectedErrors] numbers post-processing
+   */
+  _processTransactionExceptions(transaction, collectedErrors, expectedErrors) {
+    for (let i = 0; i < transaction.exceptions.length; i++) {
+      const exception = transaction.exceptions[i]
+      if (this.collect(transaction, exception)) {
+        ++collectedErrors
+        // if we could collect it, then check if expected
+        if (
+          urltils.isExpectedError(this.config, transaction.statusCode) ||
+          errorHelper.isExpectedException(transaction, exception.error, this.config, urltils)
+        ) {
+          ++expectedErrors
+        }
+      }
+    }
+
+    return [collectedErrors, expectedErrors]
+  }
+
+  /**
+   * Helper method for processing an inferred error based on Transaction metadata
+   *
+   * @param {Transaction} transaction the transaction being processed
+   * @param {number} collectedErrors the number of errors successfully .collect()-ed
+   * @param {number} expectedErrors the number of collected errors that were expected
+   * @returns {Array.<number>} the updated [collectedErrors, expectedErrors] numbers post-processing
+   */
+  _processTransactionErrors(transaction, collectedErrors, expectedErrors) {
+    if (this.collect(transaction)) {
+      ++collectedErrors
+      if (urltils.isExpectedError(this.config, transaction.statusCode)) {
+        ++expectedErrors
+      }
+    }
+
+    return [collectedErrors, expectedErrors]
+  }
+
   /**
    * Every finished transaction goes through this handler, so do as little as
    * possible.
    *
-   * @param {Transaction} transaction
-   * @returns {number} The number of unexpected errors
+   * TODO: Prob shouldn't do any work if errors fully disabled.
+   *
+   * @param {Transaction} transaction the completed transaction
    */
   onTransactionFinished(transaction) {
     if (!transaction) {
@@ -124,48 +190,30 @@ class ErrorCollector {
       return
     }
 
-    // TODO: Prob shouldn't do any work if errors fully disabled.
-
     // collect user errors even if status code is ignored
     let collectedErrors = 0
     let expectedErrors = 0
 
     // errors from noticeError are currently exempt from
     // ignore and exclude rules
-    if (transaction.userErrors.length) {
-      for (let i = 0; i < transaction.userErrors.length; i++) {
-        const exception = transaction.userErrors[i]
-        if (this.collect(transaction, exception)) {
-          ++collectedErrors
-        }
-      }
-    }
+    collectedErrors = this._processUserErrors(transaction, collectedErrors)
 
     const isErroredTransaction = urltils.isError(this.config, transaction.statusCode)
     const isIgnoredErrorStatusCode = urltils.isIgnoredError(this.config, transaction.statusCode)
 
-    const isExpectedErrorStatusCode = urltils.isExpectedError(this.config, transaction.statusCode)
-
     // collect other exceptions only if status code is not ignored
     if (transaction.exceptions.length && !isIgnoredErrorStatusCode) {
-      for (let i = 0; i < transaction.exceptions.length; i++) {
-        const exception = transaction.exceptions[i]
-        if (this.collect(transaction, exception)) {
-          ++collectedErrors
-          // if we could collect it, then check if expected
-          if (
-            isExpectedErrorStatusCode ||
-            errorHelper.isExpectedException(transaction, exception.error, this.config, urltils)
-          ) {
-            ++expectedErrors
-          }
-        }
-      }
-    } else if (isErroredTransaction && this.collect(transaction)) {
-      ++collectedErrors
-      if (isExpectedErrorStatusCode) {
-        ++expectedErrors
-      }
+      ;[collectedErrors, expectedErrors] = this._processTransactionExceptions(
+        transaction,
+        collectedErrors,
+        expectedErrors
+      )
+    } else if (isErroredTransaction) {
+      ;[collectedErrors, expectedErrors] = this._processTransactionErrors(
+        transaction,
+        collectedErrors,
+        expectedErrors
+      )
     }
 
     const unexpectedErrors = collectedErrors - expectedErrors
@@ -226,9 +274,8 @@ class ErrorCollector {
    * NOTE: this interface is unofficial and may change in future.
    *
    * @param {?Transaction}  transaction  Transaction associated with the error.
-   * @param {Exception}  exception The Exception to be traced.
-   * @param error
-   * @param customAttributes
+   * @param {*} error The error passed into `API#noticeError()`
+   * @param {object} customAttributes custom attributes to add to the error
    */
   addUserError(transaction, error, customAttributes) {
     if (!error) {
@@ -263,13 +310,38 @@ class ErrorCollector {
    *
    * @param  {?Transaction}  transaction  Transaction associated with the error.
    * @param  {?Exception}  exception  The Exception object to be traced.
-   * @returns  {bool}  True if the error was collected.
+   * @returns  {boolean}  True if the error was collected.
    */
-  collect(transaction, exception) {
-    if (!exception) {
-      exception = new Exception({})
+  collect(transaction, exception = new Exception({})) {
+    if (!this._isValidException(exception, transaction)) {
+      return false
     }
 
+    const errorTrace = createError(transaction, exception, this.config)
+    this._maybeRecordErrorMetrics(errorTrace, transaction)
+
+    // defaults true in config/index. can be modified server-side
+    if (this.config.collect_errors) {
+      this.traceAggregator.add(errorTrace)
+    }
+
+    if (this.config.error_collector.capture_events === true) {
+      const priority = (transaction && transaction.priority) || Math.random()
+      const event = createEvent(transaction, errorTrace, exception.timestamp, this.config)
+      this.eventAggregator.add(event, priority)
+    }
+
+    return true
+  }
+
+  /**
+   * Helper method for ensuring that a collected exception/transaction combination can be collected
+   *
+   * @param {object} exception the exception to validate
+   * @param {Transaction} transaction the Transaction to validate, if exception is malformed we'll try to fallback to transaction data
+   * @returns {boolean} whether or not the exception/transaction combo has everything needed for processing
+   */
+  _isValidException(exception, transaction) {
     if (exception.error) {
       if (this._haveSeen(transaction, exception.error)) {
         return false
@@ -288,10 +360,20 @@ class ErrorCollector {
 
     if (exception.error) {
       logger.trace(exception.error, 'Got exception to trace:')
+    } else {
+      logger.trace(transaction, 'Got transaction error to trace:')
     }
 
-    const errorTrace = createError(transaction, exception, this.config)
+    return true
+  }
 
+  /**
+   * Helper method for recording metrics about errors depending on the type of error that happened
+   *
+   * @param {Array} errorTrace list of error information
+   * @param {Transaction} transaction the transaction associated with the trace
+   */
+  _maybeRecordErrorMetrics(errorTrace, transaction) {
     const isExpectedError = true === errorTrace[4].intrinsics['error.expected']
 
     if (isExpectedError) {
@@ -307,19 +389,6 @@ class ErrorCollector {
         }
       }
     }
-
-    // defaults true in config/index. can be modified server-side
-    if (this.config.collect_errors) {
-      this.traceAggregator.add(errorTrace)
-    }
-
-    if (this.config.error_collector.capture_events === true) {
-      const priority = (transaction && transaction.priority) || Math.random()
-      const event = createEvent(transaction, errorTrace, exception.timestamp, this.config)
-      this.eventAggregator.add(event, priority)
-    }
-
-    return true
   }
 
   // TODO: ideally, this becomes unnecessary

package/lib/errors/index.js

@@ -5,13 +5,17 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 22] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 const DESTINATIONS = require('../config/attribute-filter').DESTINATIONS
-const NAMES = require('../metrics/names')
 const props = require('../util/properties')
 const urltils = require('../util/urltils')
 const errorHelper = require('../errors/helper')
+const {
+  maybeAddQueueAttributes,
+  maybeAddExternalAttributes,
+  maybeAddDatabaseAttributes,
+  maybeAddSyntheticAttributes
+} = require('../util/attributes')
+const Transaction = require('../transaction')
 const ERROR_EXPECTED_PATH = 'error.expected'
 
 class Exception {
@@ -48,9 +52,19 @@ class Exception {
  * handler, which traps actual instances of Error, try to set sensible
  * defaults for everything.
  *
+ * NOTE: this function returns an array, but also conditionally mutates the array
+ * to add a "transaction" property with the transaction id to the array, which works
+ * because everything's an object in JS. I'm not entirely sure why we do this, but
+ * weird enough to make note of
+ *
  * @param {Transaction} transaction  The agent transaction, coming from the instrumentatation
  * @param {Exception}   exception    An custom Exception object with the error and other information
  * @param {object}      config       The configuration to use when creating the object
+ * @returns {Array} an Array of Error information, [0] -> placeholder,
+ *                                                 [1] -> name extracted from error info,
+ *                                                 [2] -> extracted error message,
+ *                                                 [3] -> extracted error type,
+ *                                                 [4] -> attributes
  */
 function createError(transaction, exception, config) {
   const error = exception.error
@@ -70,60 +84,74 @@ function createError(transaction, exception, config) {
   if (transaction) {
     // Copy all of the parameters off of the transaction.
     params.intrinsics = transaction.getIntrinsicAttributes()
-    let transactionAgentAttributes = transaction.trace.attributes.get(DESTINATIONS.ERROR_EVENT)
-    transactionAgentAttributes = transactionAgentAttributes || {}
+    const transactionAgentAttributes =
+      transaction.trace.attributes.get(DESTINATIONS.ERROR_EVENT) || {}
 
     // Merge the agent attributes specific to this error event with the transaction attributes
-    const agentAttributes = Object.assign(exception.agentAttributes, transactionAgentAttributes)
-    params.agentAttributes = agentAttributes
+    params.agentAttributes = Object.assign(exception.agentAttributes, transactionAgentAttributes)
 
     // There should be no attributes to copy in HSM, but check status anyway
     if (!config.high_security) {
-      const custom = transaction.trace.custom.get(DESTINATIONS.ERROR_EVENT)
-      urltils.overwriteParameters(custom, params.userAttributes)
+      urltils.overwriteParameters(
+        transaction.trace.custom.get(DESTINATIONS.ERROR_EVENT),
+        params.userAttributes
+      )
     }
   }
 
+  maybeAddUserAttributes(params.userAttributes, exception, config)
+
+  params.stack_trace = maybeAddStackTrace(exception, config)
+
+  params.intrinsics[ERROR_EXPECTED_PATH] = errorHelper.isExpected(
+    type,
+    message,
+    transaction,
+    config,
+    urltils
+  )
+
+  return [0, name, message, type, params]
+}
+
+function maybeAddUserAttributes(userAttributes, exception, config) {
   const customAttributes = exception.customAttributes
   if (!config.high_security && config.api.custom_attributes_enabled && customAttributes) {
     for (const key in customAttributes) {
       if (props.hasOwn(customAttributes, key)) {
         const dest = config.attributeFilter.filterTransaction(DESTINATIONS.ERROR_EVENT, key)
         if (dest & DESTINATIONS.ERROR_EVENT) {
-          params.userAttributes[key] = customAttributes[key]
+          userAttributes[key] = customAttributes[key]
         }
       }
     }
   }
+}
+
+function maybeAddStackTrace(exception, config) {
+  const stack = exception.error?.stack
+  let parsedStack
 
-  const stack = exception.error && exception.error.stack
   if (stack) {
-    params.stack_trace = ('' + stack).split(/[\n\r]/g)
+    parsedStack = ('' + stack).split(/[\n\r]/g)
+
     if (config.high_security || config.strip_exception_messages.enabled) {
-      params.stack_trace[0] = exception.error.name + ': <redacted>'
+      parsedStack[0] = exception.error.name + ': <redacted>'
     }
   }
 
-  params.intrinsics[ERROR_EXPECTED_PATH] = false
-  if (errorHelper.isExpected(type, message, transaction, config, urltils)) {
-    params.intrinsics[ERROR_EXPECTED_PATH] = true
-  }
-
-  const res = [0, name, message, type, params]
-  if (transaction) {
-    res.transaction = transaction.id
-  }
-  return res
+  return parsedStack
 }
 
 /**
  * Creates a structure for error event that is sent to the collector.
  * The error parameter is an output of the createError() function for a given exception.
  *
- * @param transaction
- * @param error
- * @param timestamp
- * @param config
+ * @param {Transaction} transaction the current transaction
+ * @param {Array} error createError() output
+ * @param {string} timestamp the timestamp of the error event
+ * @param {object} config agent configuration object
+ * @returns {Array} an Array of different types of attributes [0] -> intrinsic, [1] -> user/custom, [2] -> agent
  */
 function createEvent(transaction, error, timestamp, config) {
   const message = error[2]
@@ -166,28 +194,10 @@ function _getErrorEventIntrinsicAttrs(transaction, errorClass, message, expected
     attributes.transactionName = transaction.getFullName()
     attributes.duration = transaction.timer.getDurationInMillis() / 1000
 
-    let metric = transaction.metrics.getMetric(NAMES.QUEUETIME)
-    if (metric) {
-      attributes.queueDuration = metric.total
-    }
-
-    metric = transaction.metrics.getMetric(NAMES.EXTERNAL.ALL)
-    if (metric) {
-      attributes.externalDuration = metric.total
-      attributes.externalCallCount = metric.callCount
-    }
-
-    metric = transaction.metrics.getMetric(NAMES.DB.ALL)
-    if (metric) {
-      attributes.databaseDuration = metric.total
-      attributes.databaseCallCount = metric.callCount
-    }
-
-    if (transaction.syntheticsData) {
-      attributes['nr.syntheticsResourceId'] = transaction.syntheticsData.resourceId
-      attributes['nr.syntheticsJobId'] = transaction.syntheticsData.jobId
-      attributes['nr.syntheticsMonitorId'] = transaction.syntheticsData.monitorId
-    }
+    maybeAddQueueAttributes(transaction, attributes)
+    maybeAddExternalAttributes(transaction, attributes)
+    maybeAddDatabaseAttributes(transaction, attributes)
+    maybeAddSyntheticAttributes(transaction, attributes)
 
     if (transaction.agent.config.distributed_tracing.enabled) {
       transaction.addDistributedTraceIntrinsics(attributes)

package/lib/instrumentation/@hapi/hapi.js

@@ -5,8 +5,6 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 68] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 const record = require('../../metrics/recorders/generic')
 // This object defines all the events that we want to wrap extensions
 // for, as they are the only ones associated with requests.
@@ -66,6 +64,12 @@ function serverPostConstructor(shim) {
     return
   }
 
+  wrapProtoDecorate(shim, proto)
+  wrapProtoRoute(shim, proto)
+  wrapProtoExt(shim, proto)
+}
+
+function wrapProtoDecorate(shim, proto) {
   shim.wrap(proto, 'decorate', function wrapDecorate(shim, original) {
     return function wrappedDecorate(type) {
       // server.decorate also accepts 'request', 'toolkit', 'server' types,
@@ -99,7 +103,9 @@ function serverPostConstructor(shim) {
       return original.apply(this, args)
     }
   })
+}
 
+function wrapProtoRoute(shim, proto) {
   shim.wrap(proto, 'route', function wrapRoute(shim, original) {
     return function wrappedRoute() {
       const args = shim.argsToArray.apply(shim, arguments)
@@ -116,51 +122,53 @@ function serverPostConstructor(shim) {
           this.realm.modifiers.route.prefix) ||
         ''
 
-      _wrapRoute(shim, args[0])
+      _wrapRoute(shim, args[0], prefix)
 
       return original.apply(this, args)
+    }
+  })
+}
 
-      function _wrapRoute(shim, route) {
-        const routePath = prefix + route.path
-        if (shim.isArray(route)) {
-          for (let i = 0; i < route.length; ++i) {
-            _wrapRoute(shim, route[i])
-          }
-          return
-        } else if (route.options) {
-          // v17 now prefers `options` property...
-          if (route.options.pre) {
-            // config objects can also contain multiple OTHER handlers in a `pre` array
-            route.options.pre = wrapPreHandlers(shim, route.options.pre, routePath)
-          }
-          if (route.options.handler) {
-            _wrapRouteHandler(shim, route.options, routePath)
-            return
-          }
-        } else if (route.config) {
-          // ... but `config` still works
-          if (route.config.pre) {
-            route.config.pre = wrapPreHandlers(shim, route.config.pre, routePath)
-          }
-          if (route.config.handler) {
-            _wrapRouteHandler(shim, route.config, routePath)
-            return
-          }
-        }
-        _wrapRouteHandler(shim, route, routePath)
-      }
-
-      function _wrapRouteHandler(shim, container, path) {
-        if (typeof container.handler !== 'function') {
-          return
-        }
-        shim.wrap(container, 'handler', function wrapHandler(shim, handler) {
-          return wrapRouteHandler(shim, handler, path)
-        })
-      }
+function _wrapRoute(shim, route, prefix) {
+  const routePath = prefix + route.path
+  if (shim.isArray(route)) {
+    for (let i = 0; i < route.length; ++i) {
+      _wrapRoute(shim, route[i], prefix)
     }
+    return
+  } else if (route.options) {
+    // v17 now prefers `options` property...
+    if (route.options.pre) {
+      // config objects can also contain multiple OTHER handlers in a `pre` array
+      route.options.pre = wrapPreHandlers(shim, route.options.pre, routePath)
+    }
+    if (route.options.handler) {
+      _wrapRouteHandler(shim, route.options, routePath)
+      return
+    }
+  } else if (route.config) {
+    // ... but `config` still works
+    if (route.config.pre) {
+      route.config.pre = wrapPreHandlers(shim, route.config.pre, routePath)
+    }
+    if (route.config.handler) {
+      _wrapRouteHandler(shim, route.config, routePath)
+      return
+    }
+  }
+  _wrapRouteHandler(shim, route, routePath)
+}
+
+function _wrapRouteHandler(shim, container, path) {
+  if (typeof container.handler !== 'function') {
+    return
+  }
+  shim.wrap(container, 'handler', function wrapHandler(shim, handler) {
+    return wrapRouteHandler(shim, handler, path)
   })
+}
 
+function wrapProtoExt(shim, proto) {
   shim.wrap(proto, 'ext', function wrapExt(shim, original) {
     return function wrappedExt(event, method) {
       const args = shim.argsToArray.apply(shim, arguments)
@@ -208,15 +216,13 @@ function wrapRouteHandler(shim, handler, path) {
   return shim.recordMiddleware(handler, {
     route: path,
     req: function getReq(shim, fn, fnName, args) {
-      const request = args[0]
-      if (request && request.raw) {
-        return request.raw.req
-      }
+      const [request] = args
+      return request?.raw?.req
     },
     promise: true,
     params: function getParams(shim, fn, fnName, args) {
-      const req = args[0]
-      return req && req.params
+      const [req] = args
+      return req?.params
     }
   })
 }
@@ -230,9 +236,9 @@ function wrapMiddleware(shim, middleware, event) {
     route: event,
     type: event === 'onPreResponse' ? shim.ERRORWARE : shim.MIDDLEWARE,
     promise: true,
-    req: function getReq(shim, fn, fnName, args) {
-      const req = args[0]
-      return req && req.raw && req.raw.req
+    req: function getReq(_shim, _fn, _fnName, args) {
+      const [req] = args
+      return req?.raw?.req
     }
   })
 }