newrelic 5.10.0 → 5.11.0

package/lib/errors/aggregator.js

@@ -3,9 +3,8 @@
 const errorsModule = require('./index')
 const EventAggregator = require('../event-aggregator')
 const logger = require('../logger').child({component: 'error_tracer'})
-const NAMES = require('../metrics/names')
 const urltils = require('../util/urltils')
-
+const errorHelper = require('../errors/helper')
 const createError = errorsModule.createError
 const createEvent = errorsModule.createEvent
 
@@ -37,6 +36,11 @@ class ErrorAggregator extends EventAggregator {
     this.errorCount = 0
     this.webTransactionErrorCount = 0
     this.otherTransactionErrorCount = 0
+
+    this.expectedErrorCount = 0
+    this.expectedWebTransactionErrorCount = 0
+    this.expectedOtherTransactionErrorCount = 0
+
     this.errors = []
     this.seenObjectsByTransaction = Object.create(null)
     this.seenStringsByTransaction = Object.create(null)
@@ -47,17 +51,21 @@ class ErrorAggregator extends EventAggregator {
    * possible.
    *
    * @param {Transaction} transaction
-   * @param {Metrics} metrics
+   *
+   * @return {number} The number of unexpected errors
    */
-  onTransactionFinished(transaction, metrics) {
+  onTransactionFinished(transaction) {
     if (!transaction) throw new Error('Error collector got a blank transaction.')
-    if (!metrics) throw new Error('Error collector requires metrics to count errors.')
     if (transaction.ignore) {
       return
     }
 
     // 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]
@@ -68,28 +76,38 @@ class ErrorAggregator extends EventAggregator {
     }
 
     const isErroredTransaction = urltils.isError(this.config, transaction.statusCode)
-    const isIgnoredErrorStatusCode = urltils.isIgnoredError(
+    const isExpectedErrorStatusCode = urltils.isExpectedError(
       this.config,
       transaction.statusCode
     )
 
     // collect other exceptions only if status code is not ignored
-    if (transaction.exceptions.length && !isIgnoredErrorStatusCode) {
+    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[0], exception[1], exception[2])) {
           ++collectedErrors
+          // if we could collect it, then check if expected
+          if (isExpectedErrorStatusCode ||
+            errorHelper.isExpectedException(
+              transaction,
+              exception[0],
+              this.config,
+              urltils
+            )
+          ) {
+            ++expectedErrors
+          }
         }
       }
-    } else if (isErroredTransaction && this._collect(transaction)) {
+    } else if (isErroredTransaction && this.collect(transaction)) {
       ++collectedErrors
+      if (isExpectedErrorStatusCode) {
+        ++expectedErrors
+      }
     }
 
-    // the metric should be incremented only if the error was actually collected
-    if (collectedErrors > 0) {
-      metrics.getOrCreateMetric(NAMES.ERRORS.PREFIX + transaction.getFullName())
-        .incrementCallCount(collectedErrors)
-    }
+    return collectedErrors - expectedErrors
   }
 
   /**
@@ -115,7 +133,7 @@ class ErrorAggregator extends EventAggregator {
     if (transaction) {
       transaction.addException(exception, customAttributes, timestamp)
     } else {
-      this._collect(transaction, exception, customAttributes, timestamp)
+      this.collect(transaction, exception, customAttributes, timestamp)
     }
   }
 
@@ -192,6 +210,34 @@ class ErrorAggregator extends EventAggregator {
     return false
   }
 
+  /**
+   * 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
+    }
+    return this._collect(transaction, exception, customAttributes, timestamp)
+  }
+
   /**
    * Collects the error and also creates the error event.
    *
@@ -235,16 +281,6 @@ class ErrorAggregator extends EventAggregator {
       return
     }
 
-    this.errorCount++
-
-    if (transaction) {
-      if (transaction.isWeb()) {
-        this.webTransactionErrorCount++
-      } else {
-        this.otherTransactionErrorCount++
-      }
-    }
-
     // allow enabling & disabling the error tracer at runtime
     // TODO: it would be better to check config in the public add() to prevents collecting
     // errors on the transaction unnecessarily
@@ -260,8 +296,29 @@ class ErrorAggregator extends EventAggregator {
       logger.trace(exception, 'Got exception to trace:')
     }
 
+    this.errorCount++
+
+    if (transaction) {
+      if (transaction.isWeb()) {
+        this.webTransactionErrorCount++
+      } else {
+        this.otherTransactionErrorCount++
+      }
+    }
+
     var error = createError(transaction, exception, customAttributes, this.config)
 
+    if (true === error[4].intrinsics['error.expected'] ) {
+      this.expectedErrorCount++
+      if (transaction) {
+        if (transaction.isWeb()) {
+          this.expectedWebTransactionErrorCount++
+        } else {
+          this.expectedOtherTransactionErrorCount++
+        }
+      }
+    }
+
     if (this.errors.length < MAX_ERRORS) {
       logger.debug(error, 'Error to be sent to collector.')
       this.errors.push(error)
@@ -288,24 +345,32 @@ class ErrorAggregator extends EventAggregator {
   }
 
   /**
-   * Returns total number of collected errors.
+   * Returns total number of errors that matched `expected_*` configuration.
+   * Expected errors do not impact standard error counts.
+   */
+  getTotalExpectedErrorCount() {
+    return this.expectedErrorCount
+  }
+
+  /**
+   * Returns total number of unexpected errors.
    */
-  getTotalErrorCount() {
-    return this.errorCount
+  getTotalUnexpectedErrorCount() {
+    return this.errorCount - this.expectedErrorCount
   }
 
   /**
-   * Returns total number of errors collected during web transactions.
+   * Returns total number of unexpected errors collected during web transactions.
    */
-  getWebTransactionsErrorCount() {
-    return this.webTransactionErrorCount
+  getUnexpectedWebTransactionsErrorCount() {
+    return this.webTransactionErrorCount - this.expectedWebTransactionErrorCount
   }
 
   /**
-   * Returns total number of errors collected during background transactions.
+   * Returns total number of unexpected errors collected during background transactions.
    */
-  getOtherTransactionsErrorCount() {
-    return this.otherTransactionErrorCount
+  getUnexpectedOtherTransactionsErrorCount() {
+    return this.otherTransactionErrorCount - this.expectedOtherTransactionErrorCount
   }
 
   /**

package/lib/errors/helper.js

@@ -0,0 +1,137 @@
+'use strict'
+
+module.exports = {
+  isExpected: function isExpected(type, message, transaction, config, urltils) {
+    let isExpectedTransactionCode = false
+    if (transaction && urltils.isExpectedError(config, transaction.statusCode)) {
+      isExpectedTransactionCode = true
+    }
+    return this.isExpectedErrorMessage(config, type, message) ||
+      this.isExpectedErrorClass(config, type) ||
+      isExpectedTransactionCode
+  },
+  isExpectedErrorMessage: function isExpectedErrorMessage(config, type, message) {
+    if (!config.error_collector.expected_messages[type]) {
+      return false
+    }
+    if (config.error_collector.expected_messages[type].length > 0) {
+      if (-1 !== config.error_collector.expected_messages[type].indexOf(message)) {
+        return true
+      }
+    }
+    return false
+  },
+  isExpectedErrorClass: function isExpectedErrorClass(config, className) {
+    if (config.error_collector.expected_classes.length > 0) {
+      if (-1 !== config.error_collector.expected_classes.indexOf(className)) {
+        return true
+      }
+    }
+    return false
+  },
+  isExpectedException: function isExpectedException(
+    transaction,
+    exception,
+    config,
+    urltils
+  ) {
+    let {type, message} = this.extractErrorInformation(
+      transaction,
+      exception,
+      config,
+      urltils
+    )
+
+    return this.isExpectedErrorClass(config, type) ||
+      this.isExpectedErrorMessage(config, type, message)
+  },
+
+  extractErrorInformation: function extractErrorInformation(
+    transaction,
+    exception,
+    config,
+    urltils
+  ) {
+    let name = 'Unknown'
+    let message = ''
+    let type = 'Error'
+
+    // 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
+    } else if (
+      exception !== null &&
+      typeof exception === 'object' &&
+      exception.message &&
+      !config.high_security &&
+      !config.strip_exception_messages.enabled
+    ) {
+      message = exception.message
+
+      if (exception.name) {
+        type = exception.name
+      } else if (exception.constructor && exception.constructor.name) {
+        type = exception.constructor.name
+      }
+    } else if (transaction && transaction.statusCode &&
+               urltils.isError(config, transaction.statusCode)) {
+      message = 'HttpError ' + transaction.statusCode
+    }
+
+    if (transaction) {
+      // transaction.getName is expensive due to running normalizers and ignore
+      // rules if a name hasn't been assigned yet.
+      const txName = transaction.getFullName()
+      if (txName) {
+        name = txName
+      }
+    }
+
+    return {
+      name:name,
+      message:message,
+      type:type,
+    }
+  },
+
+  shouldIgnoreError: function shouldIgnoreError(transaction, exception, config) {
+    // extract _just_ the error information, not transaction stuff
+    let errorInfo = this.extractErrorInformation(null, exception, config, null)
+
+    return this.shouldIgnoreErrorClass(errorInfo, config) ||
+      this.shouldIgnoreErrorMessage(errorInfo, config) ||
+      this.shouldIgnoreStatusCode(transaction, config)
+  },
+
+  shouldIgnoreStatusCode: function shouldIgnoreStatusCode(transaction, config) {
+    if (!transaction) {
+      return false
+    }
+    return config.error_collector.ignore_status_codes.indexOf(
+      transaction.statusCode
+    ) !== -1
+  },
+
+  shouldIgnoreErrorClass: function shouldIgnoreErrorClass(errorInfo, config) {
+    if (config.error_collector.ignore_classes.length < 1) {
+      return false
+    }
+
+    return -1 !== config.error_collector.ignore_classes.indexOf(errorInfo.type)
+  },
+
+  shouldIgnoreErrorMessage: function shouldIgnoreErrorMessage(errorInfo, config) {
+    let configIgnoreMessages = config.error_collector.ignore_messages[errorInfo.type]
+    if (!configIgnoreMessages) {
+      return false
+    }
+
+    if (configIgnoreMessages.length > 0) {
+      if (-1 !== configIgnoreMessages.indexOf(errorInfo.message)) {
+        return true
+      }
+    }
+    return false
+  }
+}

package/lib/errors/index.js

@@ -4,6 +4,7 @@ var DESTINATIONS = require('../config/attribute-filter').DESTINATIONS
 var NAMES = require('../metrics/names')
 var props = require('../util/properties')
 var urltils = require('../util/urltils')
+const errorHelper = require('../errors/helper')
 
 module.exports.createError = createError
 module.exports.createEvent = createEvent
@@ -23,46 +24,20 @@ module.exports.createEvent = createEvent
  *                                       the request (optional).
  */
 function createError(transaction, exception, customAttributes, config) {
-  var name = 'Unknown'
-  var message = ''
-  var type = 'Error'
+  let {name, message, type} = errorHelper.extractErrorInformation(
+    transaction,
+    exception,
+    config,
+    urltils
+  )
+
   var params = {
     userAttributes: Object.create(null),
     agentAttributes: Object.create(null),
     intrinsics: Object.create(null)
   }
 
-  // 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
-  } else if (
-    exception !== null &&
-    typeof exception === 'object' &&
-    exception.message &&
-    !config.high_security &&
-    !config.strip_exception_messages.enabled
-  ) {
-    message = exception.message
-
-    if (exception.name) {
-      type = exception.name
-    } else if (exception.constructor && exception.constructor.name) {
-      type = exception.constructor.name
-    }
-  } else if (transaction && transaction.statusCode &&
-             urltils.isError(config, transaction.statusCode)) {
-    message = 'HttpError ' + transaction.statusCode
-  }
-
   if (transaction) {
-    // transaction.getName is expensive due to running normalizers and ignore
-    // rules if a name hasn't been assigned yet.
-    var txName = transaction.getFullName()
-    if (txName) {
-      name = txName
-    }
-
     // Copy all of the parameters off of the transaction.
     params.agentAttributes = transaction.trace.attributes.get(DESTINATIONS.ERROR_EVENT)
     params.intrinsics = transaction.getIntrinsicAttributes()
@@ -97,6 +72,11 @@ function createError(transaction, exception, customAttributes, config) {
     }
   }
 
+  params.intrinsics['error.expected'] = false
+  if (errorHelper.isExpected(type, message, transaction, config, urltils)) {
+    params.intrinsics['error.expected'] = true
+  }
+
   var res = [0, name, message, type, params]
   if (transaction) {
     res.transaction = transaction.id
@@ -117,6 +97,7 @@ function createEvent(transaction, error, timestamp, config) {
     transaction,
     errorClass,
     message,
+    errorParams.intrinsics['error.expected'],
     timestamp,
     config
   )
@@ -135,7 +116,15 @@ function createEvent(transaction, error, timestamp, config) {
   return errorEvent
 }
 
-function _getErrorEventIntrinsicAttrs(transaction, errorClass, message, timestamp, conf) {
+// eslint-disable-next-line max-params
+function _getErrorEventIntrinsicAttrs(
+  transaction,
+  errorClass,
+  message,
+  expected,
+  timestamp,
+  conf
+) {
   // the server expects seconds instead of milliseconds
   if (timestamp) timestamp = timestamp / 1000
 
@@ -143,7 +132,8 @@ function _getErrorEventIntrinsicAttrs(transaction, errorClass, message, timestam
     type: "TransactionError",
     "error.class": errorClass,
     "error.message": conf.high_security ? '' : message,
-    timestamp: timestamp
+    timestamp: timestamp,
+    'error.expected': expected
   }
 
   if (transaction) {

package/lib/harvest.js

@@ -170,6 +170,9 @@ class HarvestStep {
       if (!err) {
         self.success = true
       }
+
+      logger.trace('Finished sending payloads for ' + self._endpoint)
+
       callback(err)
     })
   }
@@ -196,7 +199,7 @@ class HarvestStep {
       // Do we need to retry this endpoint right now?
       if (response.retryAfter) {
         const delay = response.retryAfter
-        logger.debug('Retrying sending to %s in %d ms', self._endpoint, delay)
+        logger.info('Retrying sending to %s in %d ms', self._endpoint, delay)
         setTimeout(() => self._doSend(payload, i, callback), delay)
         return
       }
@@ -288,18 +291,24 @@ class ErrorTraceHarvest extends HarvestStep {
     const errorAggr = harvest.agent.errors
     super(harvest, 'errorData', errorAggr.getErrors())
 
+    const metrics = harvest.agent.metrics
+
     // Generate metrics for collected errors.
-    if (errorAggr.getTotalErrorCount() > 0) {
-      const metrics = harvest.agent.metrics
-      let count = errorAggr.getTotalErrorCount()
+    if (errorAggr.getTotalUnexpectedErrorCount() > 0) {
+      let count = errorAggr.getTotalUnexpectedErrorCount()
       metrics.getOrCreateMetric(NAMES.ERRORS.ALL).incrementCallCount(count)
 
-      count = errorAggr.getWebTransactionsErrorCount()
+      count = errorAggr.getUnexpectedWebTransactionsErrorCount()
       metrics.getOrCreateMetric(NAMES.ERRORS.WEB).incrementCallCount(count)
 
-      count = errorAggr.getOtherTransactionsErrorCount()
+      count = errorAggr.getUnexpectedOtherTransactionsErrorCount()
       metrics.getOrCreateMetric(NAMES.ERRORS.OTHER).incrementCallCount(count)
     }
+
+    const expectedCount = errorAggr.getTotalExpectedErrorCount()
+    if (expectedCount > 0) {
+      metrics.getOrCreateMetric(NAMES.ERRORS.EXPECTED).incrementCallCount(expectedCount)
+    }
   }
 
   preparePayloadsSync(runId, errors) {
@@ -594,8 +603,9 @@ class Harvest {
     a.map(this._steps, function eachHarvestStep(step, cb) {
       logger.trace('Doing harvest step %s.', step.name)
       if (!self.agent.collector.isConnected()) {
-        logger.debug('Connection to New Relic lost during harvest.')
-        return setImmediate(callback, new Error('Not connected to New Relic!'))
+        const connectionLostMessage = 'Connection to New Relic lost during harvest.'
+        logger.warn(connectionLostMessage)
+        return setImmediate(callback, new Error(connectionLostMessage))
       }
       a.series([
         step.prepare.bind(step),

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

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('../hapi')

package/lib/instrumentations.js

@@ -13,6 +13,7 @@ module.exports = function instrumentations() {
     'director': {type: MODULE_TYPE.WEB_FRAMEWORK},
     'express': {type: MODULE_TYPE.WEB_FRAMEWORK},
     'generic-pool': {type: MODULE_TYPE.GENERIC},
+    '@hapi/hapi': {type: MODULE_TYPE.WEB_FRAMEWORK},
     'hapi': {type: MODULE_TYPE.WEB_FRAMEWORK},
     'ioredis': {type: MODULE_TYPE.DATASTORE},
     'koa': {module: '@newrelic/koa'},

package/lib/metrics/names.js

@@ -20,6 +20,7 @@ const SUPPORTABILITY = {
 const ERRORS = {
   PREFIX: 'Errors/',
   ALL: 'Errors/' + ALL,
+  EXPECTED: 'ErrorsExpected/' + ALL,
   WEB: 'Errors/allWeb',
   OTHER: 'Errors/allOther'
 }

package/lib/shimmer.js

@@ -340,14 +340,14 @@ var shimmer = module.exports = {
   patchModule: function patchModule(agent) {
     logger.trace("Wrapping module loader.")
     var Module = require('module')
-    var filepathStack = []
+    var filepathMap = {}
 
     shimmer.wrapMethod(Module, 'Module', '_resolveFilename', function wrapRes(resolve) {
-      return function wrappedResolveFilename() {
+      return function wrappedResolveFilename(file) {
         // This is triggered by the load call, so record the path that has been seen so
         // we can examine it after the load call has returned.
         const resolvedFilepath = resolve.apply(this, arguments)
-        filepathStack.push(resolvedFilepath)
+        filepathMap[file] = resolvedFilepath
         return resolvedFilepath
       }
     })
@@ -358,7 +358,7 @@ var shimmer = module.exports = {
         // load function calls resolve, we must mirror the recursive load calls with a
         // stack.
         const m = load.apply(this, arguments)
-        return _postLoad(agent, m, file, filepathStack.pop())
+        return _postLoad(agent, m, file, filepathMap[file])
       }
     })
   },

package/lib/transaction/index.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const errorHelper = require('../errors/helper')
 var hashes = require('../util/hashes')
 var logger = require('../logger').child({component: 'transaction'})
 var Metrics = require('../metrics')
@@ -603,7 +604,20 @@ Transaction.prototype.measure = function measure(name, scope, duration, exclusiv
  */
 Transaction.prototype._setApdex = function _setApdex(name, duration, keyApdexInMillis) {
   var apdexStats = this.metrics.getOrCreateApdexMetric(name, null, keyApdexInMillis)
-  if (urltils.isError(this.agent.config, this.statusCode)) {
+
+
+  // if we have an error-like status code, and all the errors are
+  // expected, we know the status code was caused by an expected
+  // error, so we will not report "frustrating".  Otherwise, we
+  // don't know which error triggered the error-like status code,
+  // and will still incrementing frustrating.  If this is an issue,
+  // users can either set a status code as expected, or ignore the
+  // specific error to avoid incrementing to frustrating
+  if (
+    urltils.isError(this.agent.config, this.statusCode) &&
+    !urltils.isExpectedError(this.agent.config, this.statusCode) &&
+    !this.hasOnlyExpectedErrors()
+  ) {
     apdexStats.incrementFrustrating()
   } else {
     apdexStats.recordValueInMillis(duration, keyApdexInMillis)
@@ -687,6 +701,29 @@ Transaction.prototype.hasErrors = function _hasErrors() {
   return (transactionHasExceptions || transactionHasuserErrors || isErroredTransaction)
 }
 
+/**
+ * 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
+  }
+
+  for (let i = 0;i < this.exceptions.length;i++) {
+    const exception = this.exceptions[i]
+    if (!errorHelper.isExpectedException(
+      this,
+      exception[0],
+      this.agent.config,
+      urltils
+    )) {
+      return false
+    }
+  }
+  return true
+}
+
 /**
  * Returns agent intrinsic attribute for this transaction.
  */

package/lib/util/urltils.js

@@ -61,6 +61,19 @@ module.exports = {
     return code >= 400 && isIgnoredStatusCodeForErrors(config, code)
   },
 
+  /**
+   * Returns true if the status code is configured to be expected
+   *
+   * @param {Config} config The configuration containing the error list.
+   * @param {string} code   The HTTP status code to check.
+   *
+   * @returns {bool} Whether the status code is expected.
+   *
+   */
+  isExpectedError: function isExpectedError(config, code) {
+    return isExpectedStatusCodeForErrors(config, code)
+  },
+
   /**
    * Get back the pieces of the URL that New Relic cares about. Apply these
    * restrictions, in order:
@@ -197,3 +210,13 @@ function isIgnoredStatusCodeForErrors(config, code) {
   }
   return codes.indexOf(parseInt(code, 10)) >= 0
 }
+
+function isExpectedStatusCodeForErrors(config, code) {
+  var codes = []
+  if (config &&
+      config.error_collector &&
+      config.error_collector.expected_status_codes) {
+    codes = config.error_collector.expected_status_codes
+  }
+  return codes.indexOf(parseInt(code, 10)) >= 0
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "5.10.0",
+  "version": "5.11.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "SEE LICENSE IN LICENSE",
   "contributors": [
@@ -154,8 +154,8 @@
     "generic-pool": "^3.6.1",
     "glob": "^7.1.2",
     "got": "^8.0.1",
-    "jsdoc": "^3.4.0",
-    "lodash": "^4.17.5",
+    "jsdoc": "^3.6.3",
+    "lodash": "^4.17.14",
     "memcached": ">=0.2.8",
     "minami": "^1.1.1",
     "mocha": "^5.2.0",