newrelic 6.4.2 → 6.5.0

package/{.eslintrc → .eslintrc.js}

@@ -1,4 +1,4 @@
-{
+module.exports = {
   "env": {
     "es6": true,
     "node": true,
@@ -7,9 +7,7 @@
   "parserOptions": {
     "ecmaVersion": 6
   },
-  "plugins": [
-    "mocha-no-only"
-  ],
+  "ignorePatterns": ["invalid-json/"],
   "rules": {
     "indent": ["warn", 2, {"SwitchCase": 1}],
     "brace-style": "error",
@@ -27,7 +25,6 @@
     "max-len": ["error", 100, { "ignoreUrls": true }],
     "max-nested-callbacks": ["error", 3],
     "max-params": ["error", 5],
-    "mocha-no-only/mocha-no-only": ["error"],
     "new-cap": "error",
     "no-console": "warn",
     "no-debugger": "error",

package/.travis.yml

@@ -18,7 +18,6 @@ env:
     - NR_NODE_VERSION=12 SUITE=unit
     - NR_NODE_VERSION=12 SUITE=integration
     - NR_NODE_VERSION=12 SUITE=lint
-    - NR_NODE_VERSION=12 SUITE=security
     - NR_NODE_VERSION=12 SUITE=versioned
 services:
   - memcached

package/NEWS.md

@@ -1,3 +1,27 @@
+### 6.5.0 (2020-03-18):
+
+* Added error attributes to spans.
+  * The public api method `noticeError()` now attaches exception details to the currently executing
+    span. Spans with error details are now highlighted red in the Distributed Tracing UI. Also, the
+    attributes `error.class` and `error.message` are added to the span. If multiple errors are
+    recorded for a single span, only the final error's attributes will be added to the span.
+
+  * Added ID of the span in which an error occurred to the corresponding transaction error event.
+
+* Added new public API methods `addCustomSpanAttribute` and `addCustomSpanAttributes` to add
+  attributes to the currently executing span.
+
+* Added new attributes to http outbound spans: `http.statusCode` and `http.statusText`.
+
+* Updated W3C Trace Context "Known Issues and Workaround" notes with latest accurate consideration.
+
+* Converted unit tests to run via `tap`. Removes `mocha` dependency.
+
+* Fixed route naming when hapi's `pre` route handlers share functions.
+
+* Fixed `child_process` instrumentation so that handlers can be effectively removed
+  when attached via `.once()` or manually removed via `removeListener()`.
+
 ### 6.4.2 (2020-02-27):
 
 * Support new http[s] get/request function signature in Node v10+
@@ -92,7 +116,9 @@
 
   Known Issues and Workarounds
 
-  * If a .NET agent is initiating traces as the root service, do not upgrade your downstream Node New Relic agents to this agent release.
+  * If a .NET agent is initiating distributed traces as the root service, you must update
+    that .NET agent to version `8.24` or later before upgrading your downstream Node
+    New Relic agents to this agent release.
 
 * Pins Node 12 version to `v12.15` to avoid breakages with `v12.16.0` until cause(s)
   resolved.

package/api.js

@@ -340,6 +340,77 @@ API.prototype.addCustomAttributes = function addCustomAttributes(atts) {
   }
 }
 
+/**
+ * Add custom span attributes in an object to the current segment/span.
+ * 
+ * See documentation for newrelic.addCustomSpanAttribute for more information.
+ * 
+ * An example of setting a custom span attribute:
+ * 
+ *    newrelic.addCustomSpanAttribute({test: 'value', test2: 'value2'})
+ * 
+ * @param {object} [atts]
+ * @param {string} [atts.KEY] The name you want displayed in the RPM UI.API.
+ * @param {string} [atts.KEY.VALUE] The value you want displayed.  Must be serializable.
+ */
+API.prototype.addCustomSpanAttributes = function addCustomSpanAttributes(atts) {
+  const metric = this.agent.metrics.getOrCreateMetric(
+    NAMES.SUPPORTABILITY.API + '/addCustomSpanAttributes'
+  )
+  metric.incrementCallCount()
+
+  for (let key in atts) {
+    if (properties.hasOwn(atts, key)) {
+      this.addCustomSpanAttribute(key, atts[key])
+    }
+  }
+}
+
+/**
+ * Add a custom span attribute to the current transaction. Some attributes
+ * are reserved (see CUSTOM_DENYLIST for the current, very short list), and
+ * as with most API methods, this must be called in the context of an
+ * active segment/span. Most recently set value wins.
+ *
+ * @param {string} key  The key you want displayed in the RPM UI.
+ * @param {string} value The value you want displayed. Must be serializable.
+ */
+API.prototype.addCustomSpanAttribute = function addCustomSpanAttribute(key, value) {
+  const metric = this.agent.metrics.getOrCreateMetric(
+    NAMES.SUPPORTABILITY.API + '/addCustomSpanAttribute'
+  )
+  metric.incrementCallCount()
+
+  // If high security mode is on, custom attributes are disabled.
+  if (this.agent.config.high_security) {
+    logger.warnOnce(
+      'Custom span attributes',
+      'Custom span attributes are disabled by high security mode.'
+    )
+    return false
+  } else if (!this.agent.config.api.custom_attributes_enabled) {
+    logger.debug(
+      'Config.api.custom_attributes_enabled set to false, not collecting value'
+    )
+    return false
+  }
+
+  const segment = this.agent.tracer.getSegment()
+  
+  if (!segment) {
+    return logger.debug(
+      'Could not add attribute %s. No available span/segment.',
+      key
+    )
+  }
+
+  if (CUSTOM_DENYLIST.has(key)) {
+    return logger.warn('Not overwriting value of NR-only attribute %s.', key)
+  }
+
+  segment.addCustomSpanAttribute(key, value)
+}
+
 API.prototype.setIgnoreTransaction = util.deprecate(
   setIgnoreTransaction, [
     'API#setIgnoreTransaction is being deprecated!',
@@ -415,7 +486,6 @@ API.prototype.noticeError = function noticeError(error, customAttributes) {
   if (typeof error === 'string') {
     error = new Error(error)
   }
-  const transaction = this.agent.tracer.getTransaction()
 
   // Filter all object type valued attributes out
   let filteredAttributes = customAttributes
@@ -423,6 +493,7 @@ API.prototype.noticeError = function noticeError(error, customAttributes) {
     filteredAttributes = _filterAttributes(customAttributes, 'noticeError')
   }
 
+  const transaction = this.agent.tracer.getTransaction()
   this.agent.errors.addUserError(transaction, error, filteredAttributes)
 }
 

package/lib/attributes.js

@@ -6,6 +6,8 @@ const isValidType = require('./util/attribute-types')
 const byteUtils = require('./util/byte-limit')
 const properties = require('./util/properties')
 
+const MAXIMUM_CUSTOM_ATTRIBUTES = 64
+
 /**
  * @class
  * @private
@@ -23,6 +25,7 @@ class Attributes {
     this.filter = makeFilter(scope)
     this.limit = limit
     this.attributes = Object.create(null)
+    this.attributeCount = 0
   }
 
   /**
@@ -57,7 +60,6 @@ class Attributes {
    */
   get(dest) {
     const attrs = Object.create(null)
-    let attrCount = 0
     for (let key in this.attributes) { // eslint-disable-line guard-for-in
       const attr = this.attributes[key]
       if (!(attr.destinations & dest)) {
@@ -67,10 +69,6 @@ class Attributes {
       attrs[key] = typeof attr.value === 'string' && !attr.truncateExempt
         ? byteUtils.truncate(attr.value, 255)
         : attr.value
-
-      if (++attrCount >= this.limit) {
-        break
-      }
     }
 
     return attrs
@@ -103,6 +101,13 @@ class Attributes {
    * @param {boolean} [truncateExempt=false] - Flag marking value exempt from truncation
    */
   addAttribute(destinations, key, value, truncateExempt = false) {
+    if (this.attributeCount + 1 > this.limit) {
+      return logger.debug(
+        `Maximum number of custom attributes have been added.  
+        Dropping attribute ${key} with ${value} type.`
+      )
+    }
+
     if (!isValidType(value)) {
       return logger.debug(
         'Not adding attribute %s with %s value type. This is expected for undefined' +
@@ -123,6 +128,7 @@ class Attributes {
     // Only set the attribute if at least one destination passed
     const validDestinations = this.filter(destinations, key)
     if (validDestinations) {
+      this.attributeCount = this.attributeCount + 1
       this._set(validDestinations, key, value, truncateExempt)
     }
   }
@@ -159,4 +165,7 @@ function makeFilter(scope) {
   }
 }
 
-module.exports = Attributes
+module.exports = {
+  Attributes: Attributes,
+  MAXIMUM_CUSTOM_ATTRIBUTES: MAXIMUM_CUSTOM_ATTRIBUTES
+}

package/lib/config/index.js

@@ -1458,8 +1458,12 @@ Config.prototype.applyLasp = function applyLasp(agent, policies) {
       }
       var valueName = splitConfigName[splitConfigName.length - 1]
       var localVal = settingBlock[valueName]
+
+      // Indexes into "allowed values" based on "enabled" setting
+      // to retreive proper mapping.
       var policyValues = localMapping.allowedValues
       var policyValue = policyValues[policy.enabled ? 1 : 0]
+
       // get the most secure setting between local config and the policy
       var finalValue = settingBlock[valueName] = config._getMostSecure(
         name,

package/lib/config/lasp.js

@@ -1,12 +1,25 @@
 'use strict'
 
+// TODO: would likely be easier to understand if the allowedValues mapping
+// just took the raw enabled/disabled and translated. This is not a hot path.
+
+/**
+ * path: Full nested path for the local configuration item.
+ * allowedValues:
+ *   Array of valid config values to map for incoming enabled/disabled.
+ *   policy.enabled: false uses index 0, policy.enabled: true uses index 1.
+ * filter: Allows for calculating most secure setting to use
+ * applyAdditionalSettings: Applies additional settings that are required
+ *   when the policy is disabled.
+ * clearData: Clears the relevant agent collection.
+ */
 const LASP_MAP = {
   // LASP key
   record_sql: {
     // full path to corresponding config key
     path: 'transaction_tracer.record_sql',
     // Mapping from policy enabled status to usable config value
-    // first element is policy is off, second is policy is on
+    // policy.enabled: false === off, policy.enabled: true === 'obfuscated'
     allowedValues: ['off', 'obfuscated'],
     // Tracks the precedent of settings controlled by LASP.
     filter: function mostSecureRecordSQL(first, second) {
@@ -45,6 +58,8 @@ const LASP_MAP = {
   // TODO: rename config key, because the names contradict each other's behavior
   allow_raw_exception_messages: {
     path: 'strip_exception_messages.enabled',
+    // if raw messages are allowed, then we should not strip them
+    // policy.enabled: false === true, policy.enabled: true === false
     allowedValues: [true, false],
     filter: function mostSecureStripException(first, second) {
       return first || second

package/lib/errors/error-collector.js

@@ -4,6 +4,7 @@ const errorsModule = require('./index')
 
 const logger = require('../logger').child({component: 'error_tracer'})
 const urltils = require('../util/urltils')
+const Exception = require('../errors').Exception
 const errorHelper = require('./helper')
 const createError = errorsModule.createError
 const createEvent = errorsModule.createEvent
@@ -129,7 +130,7 @@ class ErrorCollector {
     if (transaction.userErrors.length) {
       for (let i = 0; i < transaction.userErrors.length; i++) {
         const exception = transaction.userErrors[i]
-        if (this._collect(transaction, exception[0], exception[1], exception[2])) {
+        if (this.collect(transaction, exception)) {
           ++collectedErrors
         }
       }
@@ -145,13 +146,13 @@ class ErrorCollector {
     if (transaction.exceptions.length) {
       for (let i = 0; i < transaction.exceptions.length; i++) {
         const exception = transaction.exceptions[i]
-        if (this.collect(transaction, exception[0], exception[1], exception[2])) {
+        if (this.collect(transaction, exception)) {
           ++collectedErrors
           // if we could collect it, then check if expected
           if (isExpectedErrorStatusCode ||
             errorHelper.isExpectedException(
               transaction,
-              exception[0],
+              exception.error,
               this.config,
               urltils
             )
@@ -178,31 +179,32 @@ class ErrorCollector {
   }
 
   /**
-   * This function collects the error right away when transaction is not supplied.
-   * Otherwise it delays collecting the error until the transaction ends.
+   * This function collects the error right away when transaction is not supplied. Otherwise it
+   * delays collecting the error until the transaction ends.
    *
    * NOTE: this interface is unofficial and may change in future.
    *
-   * @param {?Transaction} transaction
-   *  Transaction associated with the error.
-   *
-   * @param {Error} exception
-   *  The error to be traced.
-   *
-   * @param {object} customAttributes
-   *  Any custom attributes associated with the request (optional).
+   * @param {?Transaction}  transaction  Transaction associated with the error.
+   * @param {Error}  error  The error to be traced.
+   * @param {?object}  customAttributes  Custom attributes associated with the request (optional).
    */
-  add(transaction, exception, customAttributes) {
-    if (!exception) {
+  add(transaction, error, customAttributes) {
+    if (!error) {
+      return
+    }
+
+    if (errorHelper.shouldIgnoreError(transaction, error, this.config)) {
+      logger.trace('Ignoring error')
       return
     }
 
     const timestamp = Date.now()
+    const exception = new Exception({error, timestamp, customAttributes})
 
     if (transaction) {
-      transaction.addException(exception, customAttributes, timestamp)
+      transaction.addException(exception)
     } else {
-      this.collect(transaction, exception, customAttributes, timestamp)
+      this.collect(transaction, exception)
     }
   }
 
@@ -217,95 +219,54 @@ class ErrorCollector {
    *
    * NOTE: this interface is unofficial and may change in future.
    *
-   * @param {?Transaction} transaction
-   *  Transaction associated with the error.
-   *
-   * @param {Error} exception
-   *  The error to be traced.
-   *
-   * @param {object} [customAttributes=null]
-   *  Any custom attributes associated with the request (optional).
+   * @param {?Transaction}  transaction  Transaction associated with the error.
+   * @param {Exception}  exception The Exception to be traced.
    */
-  addUserError(transaction, exception, customAttributes) {
-    if (!exception) return
+  addUserError(transaction, error, customAttributes) {
+    if (!error) return
 
-    var timestamp = Date.now()
+    const timestamp = Date.now()
+    const exception = new Exception({error, timestamp, customAttributes})
 
     if (transaction) {
-      transaction.addUserError(exception, customAttributes, timestamp)
+      transaction.addUserError(exception)
     } else {
-      this._collect(transaction, exception, customAttributes, timestamp)
-    }
-  }
-
-  /**
-   * Wrapper for _collect, include logic for whether an error should
-   * be ignored or not.  Exists to allow userErrors to bypass ignore
-   * logic.
-   *
-   * NOTE: this interface is unofficial and may change in future.
-   *
-   * @param {?Transaction} transaction
-   *  Transaction associated with the error.
-   *
-   * @param {?Error} exception
-   *  The error to be traced.
-   *
-   * @param {?object} customAttributes
-   *  Any custom attributes associated with the request.
-   *
-   * @param {number} timestamp
-   *
-   * @return {bool} True if the error was collected.
-   */
-  collect(transaction, exception, customAttributes, timestamp) {
-    if (errorHelper.shouldIgnoreError(transaction, exception, this.config)) {
-      logger.trace("Ignoring error")
-      return
+      this.collect(transaction, exception)
     }
-    return this._collect(transaction, exception, customAttributes, timestamp)
   }
 
   /**
    * Collects the error and also creates the error event.
    *
-   * @private
-   *
-   * This function uses an array of seen exceptions to ensure errors don't get
-   * double-counted. It can also be used as an unofficial means of marking that
-   * user errors shouldn't be traced.
+   * This function uses an array of seen exceptions to ensure errors don't get double-counted. It
+   * can also be used as an unofficial means of marking that user errors shouldn't be traced.
    *
-   * For an error to be traced, at least one of the transaction or the error
-   * must be present.
+   * For an error to be traced, at least one of the transaction or the error must be present.
    *
    * NOTE: this interface is unofficial and may change in future.
    *
-   * @param {?Transaction} transaction
-   *  Transaction associated with the error.
-   *
-   * @param {?Error} exception
-   *  The error to be traced.
-   *
-   * @param {?object} customAttributes
-   *  Any custom attributes associated with the request.
-   *
-   * @param {number} timestamp
-   *
-   * @return {bool} True if the error was collected.
+   * @param  {?Transaction}  transaction  Transaction associated with the error.
+   * @param  {?Exception}  exception  The Exception object to be traced.
+   * @return  {bool}  True if the error was collected.
    */
-  _collect(transaction, exception, customAttributes, timestamp) {
-    if (exception) {
-      if (this._haveSeen(transaction, exception)) {
+  collect(transaction, exception) {
+    if (!exception) {
+      exception = new Exception({})
+    }
+
+    if (exception.error) {
+      if (this._haveSeen(transaction, exception.error)) {
         return false
       }
 
-      if (typeof exception !== 'string' && !exception.message && !exception.stack) {
-        logger.trace(exception, 'Got error that is not an instance of Error or string.')
-        exception = null
+      const error = exception.error
+      if (typeof error !== 'string' && !error.message && !error.stack) {
+        logger.trace(error, 'Got error that is not an instance of Error or string.')
+        exception.error = null
       }
     }
 
-    if (!exception && (!transaction || !transaction.statusCode || transaction.error)) {
+    if (!exception.error && (!transaction || !transaction.statusCode || transaction.error)) {
       return false
     }
 
@@ -321,13 +282,13 @@ class ErrorCollector {
       return false
     }
 
-    if (exception) {
-      logger.trace(exception, 'Got exception to trace:')
+    if (exception.error) {
+      logger.trace(exception.error, 'Got exception to trace:')
     }
 
-    const error = createError(transaction, exception, customAttributes, this.config)
+    const errorTrace = createError(transaction, exception, this.config)
 
-    const isExpectedError = true === error[4].intrinsics['error.expected']
+    const isExpectedError = true === errorTrace[4].intrinsics['error.expected']
 
     if (isExpectedError) {
       this.metrics.getOrCreateMetric(NAMES.ERRORS.EXPECTED).incrementCallCount()
@@ -343,11 +304,11 @@ class ErrorCollector {
       }
     }
 
-    this.traceAggregator.add(error)
+    this.traceAggregator.add(errorTrace)
 
     if (this.config.error_collector.capture_events === true) {
       const priority = transaction && transaction.priority || Math.random()
-      const event = createEvent(transaction, error, timestamp, this.config)
+      const event = createEvent(transaction, errorTrace, exception.timestamp, this.config)
       this.eventAggregator.add(event, priority)
     }
 

package/lib/errors/helper.js

@@ -48,7 +48,7 @@ module.exports = {
 
   extractErrorInformation: function extractErrorInformation(
     transaction,
-    exception,
+    error,
     config,
     urltils
   ) {
@@ -58,21 +58,21 @@ module.exports = {
 
     // String errors do not provide us with as much information to provide to the
     // user, but it is a common pattern.
-    if (typeof exception === 'string') {
-      message = exception
+    if (typeof error === 'string') {
+      message = error
     } else if (
-      exception !== null &&
-      typeof exception === 'object' &&
-      exception.message &&
+      error !== null &&
+      typeof error === 'object' &&
+      error.message &&
       !config.high_security &&
       !config.strip_exception_messages.enabled
     ) {
-      message = exception.message
+      message = error.message
 
-      if (exception.name) {
-        type = exception.name
-      } else if (exception.constructor && exception.constructor.name) {
-        type = exception.constructor.name
+      if (error.name) {
+        type = error.name
+      } else if (error.constructor && error.constructor.name) {
+        type = error.constructor.name
       }
     } else if (transaction && transaction.statusCode &&
                urltils.isError(config, transaction.statusCode)) {
@@ -95,9 +95,9 @@ module.exports = {
     }
   },
 
-  shouldIgnoreError: function shouldIgnoreError(transaction, exception, config) {
+  shouldIgnoreError: function shouldIgnoreError(transaction, error, config) {
     // extract _just_ the error information, not transaction stuff
-    let errorInfo = this.extractErrorInformation(null, exception, config, null)
+    let errorInfo = this.extractErrorInformation(null, error, config, null)
 
     return this.shouldIgnoreErrorClass(errorInfo, config) ||
       this.shouldIgnoreErrorMessage(errorInfo, config) ||

package/lib/errors/index.js

@@ -6,8 +6,18 @@ var props = require('../util/properties')
 var urltils = require('../util/urltils')
 const errorHelper = require('../errors/helper')
 
-module.exports.createError = createError
-module.exports.createEvent = createEvent
+class Exception {
+  constructor({error, timestamp, customAttributes, agentAttributes}) {
+    this.error = error
+    this.timestamp = timestamp || 0
+    this.customAttributes = customAttributes || {}
+    this.agentAttributes = agentAttributes || {}
+  }
+
+  getErrorDetails(config) {
+    return errorHelper.extractErrorInformation(null, this.error, config)
+  }
+}
 
 /**
  * Given either or both of a transaction and an exception, generate an error
@@ -17,21 +27,20 @@ module.exports.createEvent = createEvent
  * handler, which traps actual instances of Error, try to set sensible
  * defaults for everything.
  *
- * @param {Transaction} transaction      The agent transaction, presumably
- *                                       coming out of the instrumentation.
- * @param {Error}       exception        Something trapped by an error listener.
- * @param {object}      customAttributes Any custom attributes associated with
- *                                       the request (optional).
+ * @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
  */
-function createError(transaction, exception, customAttributes, config) {
+function createError(transaction, exception, config) {
+  const error = exception.error
   let {name, message, type} = errorHelper.extractErrorInformation(
     transaction,
-    exception,
+    error,
     config,
     urltils
   )
 
-  var params = {
+  let params = {
     userAttributes: Object.create(null),
     agentAttributes: Object.create(null),
     intrinsics: Object.create(null)
@@ -39,20 +48,26 @@ function createError(transaction, exception, customAttributes, config) {
 
   if (transaction) {
     // Copy all of the parameters off of the transaction.
-    params.agentAttributes = transaction.trace.attributes.get(DESTINATIONS.ERROR_EVENT)
     params.intrinsics = transaction.getIntrinsicAttributes()
+    let transactionAgentAttributes = transaction.trace.attributes.get(DESTINATIONS.ERROR_EVENT)
+    transactionAgentAttributes = transactionAgentAttributes || {}
+
+    // Merge the agent attributes specific to this error event with the transaction attributes
+    const agentAttributes = Object.assign(exception.agentAttributes, transactionAgentAttributes)
+    params.agentAttributes = agentAttributes
 
     // There should be no attributes to copy in HSM, but check status anyway
     if (!config.high_security) {
-      var custom = transaction.trace.custom.get(DESTINATIONS.ERROR_EVENT)
+      const custom = transaction.trace.custom.get(DESTINATIONS.ERROR_EVENT)
       urltils.overwriteParameters(custom, params.userAttributes)
     }
   }
 
+  const customAttributes = exception.customAttributes
   if (!config.high_security && config.api.custom_attributes_enabled && customAttributes) {
-    for (var key in customAttributes) {
+    for (let key in customAttributes) {
       if (props.hasOwn(customAttributes, key)) {
-        var dest = config.attributeFilter.filterTransaction(
+        const dest = config.attributeFilter.filterTransaction(
           DESTINATIONS.ERROR_EVENT,
           key
         )
@@ -63,12 +78,11 @@ function createError(transaction, exception, customAttributes, config) {
     }
   }
 
-
-  var stack = exception && exception.stack
+  const stack = exception.error && exception.error.stack
   if (stack) {
     params.stack_trace = ('' + stack).split(/[\n\r]/g)
     if (config.high_security || config.strip_exception_messages.enabled) {
-      params.stack_trace[0] = exception.name + ': <redacted>'
+      params.stack_trace[0] = exception.error.name + ': <redacted>'
     }
   }
 
@@ -77,7 +91,7 @@ function createError(transaction, exception, customAttributes, config) {
     params.intrinsics['error.expected'] = true
   }
 
-  var res = [0, name, message, type, params]
+  let res = [0, name, message, type, params]
   if (transaction) {
     res.transaction = transaction.id
   }
@@ -180,3 +194,7 @@ function _getErrorEventIntrinsicAttrs(
 
   return attributes
 }
+
+module.exports.createError = createError
+module.exports.createEvent = createEvent
+module.exports.Exception = Exception

package/lib/instrumentation/core/child_process.js

@@ -33,8 +33,20 @@ function initialize(agent, childProcess, moduleName, shim) {
           const args = shim.argsToArray.apply(shim, arguments)
           const cbIndex = args.length - 1
 
+          const originalListener = args[cbIndex]
+          if (!shim.isFunction(originalListener)) {
+            return fn.apply(this, arguments)
+          }
+
           shim.bindSegment(args, cbIndex)
 
+          // Leverage events.removeListener() mechanism that checks listener
+          // property to allow our wrapped listeners to match and remove appropriately.
+          // Avoids having to instrument removeListener() and potentially doubling
+          // lookup. Since our wrapping will only be referenced by the events
+          // collection, we should not need to unwrap.
+          args[cbIndex].listener = originalListener
+
           return fn.apply(this, args)
         }
       }

package/lib/instrumentation/core/http-outbound.js

@@ -195,6 +195,10 @@ function handleError(segment, req, error) {
  * @param {http.IncomingMessage} res
  */
 function handleResponse(segment, hostname, req, res) {
+  // Add response attributes for spans
+  segment.addAttribute('http.statusCode', res.statusCode)
+  segment.addAttribute('http.statusText', res.statusMessage)
+  
   // If CAT is enabled, grab those headers!
   const agent = segment.transaction.agent
   if (

package/lib/instrumentation/hapi/hapi-17.js

@@ -1,6 +1,7 @@
 'use strict'
 
-var shared = require('./shared')
+const shared = require('./shared')
+const record = require('../../metrics/recorders/generic')
 
 // TODO: abstract and consolidate mostly-shared hapi functionality
 module.exports = function initialize(agent, hapi, moduleName, shim) {
@@ -154,14 +155,20 @@ function wrapPreHandlers(shim, container, path) {
     }
     return container
   } else if (shim.isFunction(container)) {
-    return wrapRouteHandler(shim, container, path)
+    return wrapPreHandler(shim, container, path)
   } else if (container.method && shim.isFunction(container.method)) {
     return shim.wrap(container, 'method', function wrapHandler(shim, handler) {
-      return wrapRouteHandler(shim, handler, path)
+      return wrapPreHandler(shim, handler, path)
     })
   }
 }
 
+function wrapPreHandler(shim, container, path) {
+  return shim.record(container, (shim) => {
+    return {name: [shim.HAPI, ' pre handler: ','(',path,')'].join(''), recorder: record}
+  })
+}
+
 function wrapRouteHandler(shim, handler, path) {
   return shim.recordMiddleware(handler, {
     route: path,

package/lib/spans/span-event.js

@@ -12,6 +12,7 @@ const CATEGORIES = {
   DATASTORE: 'datastore',
   GENERIC: 'generic'
 }
+
 const EMPTY_USER_ATTRS = Object.freeze(Object.create(null))
 
 /**
@@ -48,7 +49,8 @@ class SpanIntrinsics {
  * @class
  */
 class SpanEvent {
-  constructor(attributes) {
+  constructor(attributes, customAttributes) {
+    this.customAttributes = customAttributes
     this.attributes = attributes
     this.intrinsics = new SpanIntrinsics()
   }
@@ -78,14 +80,15 @@ class SpanEvent {
    */
   static fromSegment(segment, parentId = null, isRoot = false) {
     const attributes = segment.attributes.get(DESTINATIONS.SPAN_EVENT)
+    const customAttributes = segment.customAttributes.get(DESTINATIONS.SPAN_EVENT)
 
     let span = null
     if (HttpSpanEvent.testSegment(segment)) {
-      span = new HttpSpanEvent(attributes)
+      span = new HttpSpanEvent(attributes, customAttributes)
     } else if (DatastoreSpanEvent.testSegment(segment)) {
-      span = new DatastoreSpanEvent(attributes)
+      span = new DatastoreSpanEvent(attributes, customAttributes)
     } else {
-      span = new SpanEvent(attributes)
+      span = new SpanEvent(attributes, customAttributes)
     }
 
     const tx = segment.transaction
@@ -120,11 +123,21 @@ class SpanEvent {
   toJSON() {
     return [
       _filterNulls(this.intrinsics),
-      EMPTY_USER_ATTRS,
+      this.customAttributes ?
+        _filterNulls(this.customAttributes) :
+        EMPTY_USER_ATTRS,
       _filterNulls(this.attributes)
     ]
   }
 
+  addCustomAttribute(key, value, truncateExempt = false) {
+    const {attributeFilter} = Config.getInstance()
+    const dest = attributeFilter.filterSegment(DESTINATIONS.SPAN_EVENT, key)
+    if (dest & DESTINATIONS.SPAN_EVENT) {
+      this.customAttributes[key] = truncateExempt ? value : _truncate(value)
+    }
+  }
+
   addAttribute(key, value, truncateExempt = false) {
     const {attributeFilter} = Config.getInstance()
     const dest = attributeFilter.filterSegment(DESTINATIONS.SPAN_EVENT, key)
@@ -141,8 +154,8 @@ class SpanEvent {
  * @class
  */
 class HttpSpanEvent extends SpanEvent {
-  constructor(attributes) {
-    super(attributes)
+  constructor(attributes, customAttributes) {
+    super(attributes, customAttributes)
 
     this.intrinsics.category = CATEGORIES.HTTP
     this.intrinsics.component = attributes.library || HTTP_LIBRARY
@@ -175,8 +188,8 @@ class HttpSpanEvent extends SpanEvent {
  * @class.
  */
 class DatastoreSpanEvent extends SpanEvent {
-  constructor(attributes) {
-    super(attributes)
+  constructor(attributes, customAttributes) {
+    super(attributes, customAttributes)
 
     this.intrinsics.category = CATEGORIES.DATASTORE
     this.intrinsics['span.kind'] = CLIENT_KIND

package/lib/transaction/index.js

@@ -678,19 +678,40 @@ Transaction.prototype.alternatePathHashes = function alternatePathHashes() {
   return altHashes.length === 0 ? null : altHashes.sort().join(',')
 }
 
+/**
+ * Add the error information to the current segment and add the segment ID as
+ * an attribute onto the exception.
+ *
+ * @param {Exception}   exception  The exception object to be collected.
+ */
+Transaction.prototype._linkExceptionToSegment = _linkExceptionToSegment
+
+function _linkExceptionToSegment(exception) {
+  const segment = this.agent.tracer.getSegment()
+  if (!segment) {
+    return
+  }
+
+  // Add error attributes to the span
+  const details = exception.getErrorDetails(this.agent.config)
+  segment.addAttribute('error.message', details.message)
+  segment.addAttribute('error.class', details.type)
+
+  // Add the span/segment ID to the exception as agent attributes
+  exception.agentAttributes.spanId = segment.id
+}
+
 /**
  * Associate an exception with the transaction.  When the transaction ends,
  * the exception will be collected along with the transaction details.
  *
- * @param {Error}   exception         The exception to be collected.
- * @param {object}  customAttributes  Any custom attributes associated with
- *                                    the request (optional).
- * @param {number}  timestamp         The timestamp for when the exception occurred.
+ * @param {Exception}   exception  The exception object to be collected.
  */
 Transaction.prototype.addException = _addException
 
-function _addException(exception, customAttributes, timestamp) {
-  this.exceptions.push([exception, customAttributes, timestamp])
+function _addException(exception) {
+  this._linkExceptionToSegment(exception)
+  this.exceptions.push(exception)
 }
 
 /**
@@ -698,20 +719,18 @@ function _addException(exception, customAttributes, timestamp) {
  * When the transaction ends, the exception will be collected along with the transaction
  * details.
  *
- * @param {Error}   exception         The exception to be collected.
- * @param {object}  customAttributes  Any custom attributes associated with
- *                                    the request (optional).
- * @param {number}  timestamp         The timestamp for when the exception occurred.
+ * @param {Exception}   exception  The exception object to be collected.
  */
 Transaction.prototype.addUserError = _addUserError
 
-function _addUserError(exception, customAttributes, timestamp) {
-  this.userErrors.push([exception, customAttributes, timestamp])
+function _addUserError(exception) {
+  this._linkExceptionToSegment(exception)
+  this.userErrors.push(exception)
 }
 
 /**
- * Returns true if an error happened during the transaction or if the transaction itself
- * is considered to be an error.
+ * Returns true if an error happened during the transaction or if the transaction itself is
+ * considered to be an error.
  */
 Transaction.prototype.hasErrors = function _hasErrors() {
   var isErroredTransaction = urltils.isError(this.agent.config, this.statusCode)
@@ -720,10 +739,7 @@ Transaction.prototype.hasErrors = function _hasErrors() {
   return (transactionHasExceptions || transactionHasuserErrors || isErroredTransaction)
 }
 
-/**
- * Returns true if all the errors/exceptions collected so far
- * are expected errors.
- */
+// Returns true if all the errors/exceptions collected so far are expected errors
 Transaction.prototype.hasOnlyExpectedErrors = function hasOnlyExpectedErrors() {
   if (0 === this.exceptions.length) {
     return false
@@ -735,13 +751,13 @@ Transaction.prototype.hasOnlyExpectedErrors = function hasOnlyExpectedErrors() {
     const isUnexpected = !(
       errorHelper.isExpectedException(
         this,
-        exception[0],
+        exception.error,
         this.agent.config,
         urltils
       ) ||
       errorHelper.shouldIgnoreError(
         this,
-        exception[0],
+        exception.error,
         this.agent.config
       )
     )

package/lib/transaction/trace/index.js

@@ -2,7 +2,7 @@
 
 var codec = require('../../util/codec')
 var Segment = require('./segment')
-var Attributes = require('../../attributes')
+var {Attributes, MAXIMUM_CUSTOM_ATTRIBUTES} = require('../../attributes')
 var logger = require('../../logger').child({component: 'trace'})
 
 
@@ -29,7 +29,7 @@ function Trace(transaction) {
   this.segmentsSeen = 0
   this.totalTimeCache = null
 
-  this.custom = new Attributes(ATTRIBUTE_SCOPE, 64)
+  this.custom = new Attributes(ATTRIBUTE_SCOPE, MAXIMUM_CUSTOM_ATTRIBUTES)
   this.attributes = new Attributes(ATTRIBUTE_SCOPE)
 
   // sending displayName if set by user

package/lib/transaction/trace/segment.js

@@ -6,7 +6,7 @@ const Timer = require('../../timer')
 const urltils = require('../../util/urltils')
 const hashes = require('../../util/hashes')
 
-const Attributes = require('../../attributes')
+const {Attributes, MAXIMUM_CUSTOM_ATTRIBUTES} = require('../../attributes')
 const ExclusiveCalculator = require('./exclusive-time-calculator')
 
 const NAMES = require('../../metrics/names')
@@ -52,6 +52,7 @@ function TraceSegment(transaction, name, recorder) {
   }
 
   this.attributes = new Attributes(ATTRIBUTE_SCOPE)
+  this.customAttributes = new Attributes(ATTRIBUTE_SCOPE, MAXIMUM_CUSTOM_ATTRIBUTES)
 
   this.children = []
 
@@ -90,6 +91,16 @@ TraceSegment.prototype.getAttributes = function getAttributes() {
   return this.attributes.get(DESTINATIONS.TRANS_SEGMENT)
 }
 
+TraceSegment.prototype.addCustomSpanAttribute = 
+function addCustomSpanAttribute(key, value, truncateExempt = false) {
+  this.customAttributes.addAttribute(
+    DESTINATIONS.SPAN_EVENT,
+    key,
+    value,
+    truncateExempt
+  )
+}
+
 TraceSegment.prototype.getSpanId = function getSpanId() {
   const conf = this.transaction.agent.config
   const enabled = conf.span_events.enabled && conf.distributed_tracing.enabled

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "6.4.2",
+  "version": "6.5.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "SEE LICENSE IN LICENSE",
   "contributors": [
@@ -113,13 +113,12 @@
     "lint": "eslint ./*.js lib test",
     "public-docs": "npm ci && jsdoc -c ./jsdoc-conf.json --tutorials examples/shim api.js lib/shim/ lib/transaction/handle.js && cp examples/shim/*.png out/",
     "publish-docs": "./bin/publish-docs.sh",
-    "security": "npm audit",
     "services": "./bin/docker-services.sh",
     "smoke": "npm run clean && ./bin/smoke.sh",
     "ssl": "./bin/ssl.sh",
     "sub-install": "node test/bin/install_sub_deps",
     "test": "npm run integration && npm run unit",
-    "unit": "rm -f newrelic_agent.log && mocha -r nock -c test/unit --recursive --exit",
+    "unit": "rm -f newrelic_agent.log && time tap --test-regex='(\\/|^test\\/unit\\/.*\\.test\\.js)$' --timeout=120 --no-coverage",
     "update-cross-agent-tests": "./bin/update-cats.sh",
     "versioned-tests": "./bin/run-versioned-tests.sh",
     "versioned": "npm run prepare-test && time ./bin/run-versioned-tests.sh"
@@ -152,8 +151,7 @@
     "benchmark": "^2.1.4",
     "bluebird": "^3.4.7",
     "chai": "^4.1.2",
-    "eslint": "^5.13.0",
-    "eslint-plugin-mocha-no-only": "^1.1.0",
+    "eslint": "^6.8.0",
     "express": "*",
     "generic-pool": "^3.6.1",
     "glob": "^7.1.2",
@@ -162,7 +160,6 @@
     "lodash": "^4.17.14",
     "memcached": ">=0.2.8",
     "minami": "^1.1.1",
-    "mocha": "^6.2.1",
     "mongodb": "^3.3.3",
     "mysql": "*",
     "nock": "11.8.0",