newrelic 6.3.0 → 6.5.0

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/feature_flags.js

@@ -6,8 +6,7 @@ exports.prerelease = {
   await_support: true,
   serverless_mode: true,
   promise_segments: false,
-  reverse_naming_rules: false,
-  dt_format_w3c: false
+  reverse_naming_rules: false
 }
 
 // flags that are no longer used for released features
@@ -20,7 +19,8 @@ exports.released = [
   'native_metrics',
   'protocol_17',
   'send_request_uri_attribute',
-  'synthetics'
+  'synthetics',
+  'dt_format_w3c'
 ]
 
 // flags that are no longer used for unreleased features

package/lib/header-processing.js

@@ -0,0 +1,75 @@
+'use strict'
+
+const REQUEST_START_HEADER = 'x-request-start'
+const QUEUE_HEADER = 'x-queue-start'
+const CONTENT_LENGTH_REGEX = /^Content-Length$/i
+
+/**
+ * Extracts queue time from the incoming request headers.
+ *
+ * Queue time is provided by certain providers by stamping the request
+ * header with the time the request arrived at the router.
+ * @param {*} logger
+ * @param {*} requestHeaders
+ */
+function getQueueTime(logger, requestHeaders) {
+  const headerValue = requestHeaders[REQUEST_START_HEADER] || requestHeaders[QUEUE_HEADER]
+  if (!headerValue) {
+    return null
+  }
+
+  const split = headerValue.split('=')
+  const rawQueueTime = split.length > 1 ? split[1] : headerValue
+
+  const parsedQueueTime = parseFloat(rawQueueTime)
+  if (isNaN(parsedQueueTime)) {
+    logger.warn('Queue time header parsed as NaN. See trace level log for value.')
+
+    // This header can hold up to 4096 bytes which could quickly fill up logs.
+    // Do not log a level higher than debug.
+    logger.trace('Queue time: %s', rawQueueTime)
+
+    return null
+  }
+
+  const convertedQueueTime = convertUnit(parsedQueueTime)
+  return convertedQueueTime
+}
+
+function convertUnit(time) {
+  let convertedTime = time
+  if (convertedTime > 1e18) {
+    // nano seconds
+    convertedTime = convertedTime / 1e6
+  } else if (convertedTime > 1e15) {
+    // micro seconds
+    convertedTime = convertedTime / 1e3
+  } else if (convertedTime < 1e12) {
+    // seconds
+    convertedTime = convertedTime * 1e3
+  }
+
+  return convertedTime
+}
+
+/**
+ * Returns the value of the Content-Length header
+ *
+ * If no header is found, returns -1
+ *
+ * @param {*} headers
+ */
+function getContentLengthFromHeaders(headers) {
+  let contentLength = -1
+  for (const [headerName, headerValue] of Object.entries(headers)) {
+    if (CONTENT_LENGTH_REGEX.test(headerName)) {
+      return headerValue
+    }
+  }
+  return contentLength
+}
+
+module.exports = {
+  getQueueTime,
+  getContentLengthFromHeaders
+}

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

@@ -17,7 +17,6 @@ const DEFAULT_PORT = 80
 const DEFAULT_SSL_PORT = 443
 
 const NEWRELIC_ID_HEADER = 'x-newrelic-id'
-const NEWRELIC_TRACE_HEADER = 'newrelic'
 const NEWRELIC_TRANSACTION_HEADER = 'x-newrelic-transaction'
 const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
 
@@ -92,11 +91,9 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
     // TODO: abstract header logic shared with TransactionShim#insertCATRequestHeaders
     if (agent.config.distributed_tracing.enabled) {
       if (opts.headers && opts.headers[SHIM_SYMBOLS.DISABLE_DT]) {
-        logger.trace('DT disabled by instrumentation.')
-      } else if (agent.config.feature_flag.dt_format_w3c) {
-        _addTraceContextHeaders(transaction, outboundHeaders)
+        logger.trace('Distributed tracing disabled by instrumentation.')
       } else {
-        _addDistributedHeaders(transaction, outboundHeaders)
+        transaction.insertDistributedTraceHeaders(outboundHeaders)
       }
     } else if (agent.config.cross_application_tracer.enabled) {
       if (agent.config.encoding_key) {
@@ -198,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 (
@@ -276,29 +277,6 @@ function _makeNonEnumerable(obj, prop) {
   }
 }
 
-function _addDistributedHeaders(tx, outboundHeaders) {
-  try {
-    const txData = tx.createDistributedTracePayload().httpSafe()
-    outboundHeaders[NEWRELIC_TRACE_HEADER] = txData
-
-    logger.trace(
-      'Added outbound request distributed tracing headers in transaction %s',
-      tx.id
-    )
-  } catch (err) {
-    logger.trace(err, 'Failed to create distributed trace payload')
-  }
-}
-
-function _addTraceContextHeaders(tx, outboundHeaders) {
-  tx.traceContext.addTraceContextHeaders(outboundHeaders)
-
-  logger.trace(
-    'Added outbound request w3c trace context headers in transaction %s',
-    tx.id
-  )
-}
-
 function _addCATHeaders(agent, tx, outboundHeaders) {
   if (agent.config.obfuscatedId) {
     outboundHeaders[NEWRELIC_ID_HEADER] = agent.config.obfuscatedId