newrelic 8.4.0 → 8.6.0

package/lib/instrumentation/undici.js

@@ -0,0 +1,242 @@
+/*
+ * Copyright 2021 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const cat = require('../util/cat')
+const recordExternal = require('../metrics/recorders/http_external')
+const logger = require('../logger').child({ component: 'undici' })
+const NAMES = require('../metrics/names')
+const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
+const SYMBOLS = {
+  SEGMENT: Symbol('__NR_segment'),
+  PARENT_SEGMENT: Symbol('__NR_parent_segment')
+}
+const { executionAsyncResource } = require('async_hooks')
+
+let diagnosticsChannel = null
+try {
+  diagnosticsChannel = require('diagnostics_channel')
+} catch (e) {
+  // quick check to see if module exists
+  // module was not added until v15.x
+}
+
+module.exports = function addUndiciChannels(agent, undici, modName, shim) {
+  if (!diagnosticsChannel || !agent.config.feature_flag.undici_instrumentation) {
+    logger.warn(
+      'diagnostics_channel or feature_flag.undici_instrumentation = false. Skipping undici instrumentation.'
+    )
+    return
+  }
+
+  /**
+   * Retrieves the current segment in transaction(parent in our context) from executionAsyncResource
+   * or from `shim.getSegment()` then adds to the executionAsyncResource for future
+   * undici requests within same async context.
+   *
+   * It was found that when running concurrent undici requests
+   * within a transaction that the parent segment would get out of sync
+   * depending on the async context of the transaction.  By using
+   * `async_hooks.executionResource` it is more reliable.
+   *
+   * Note: However, if you have concurrent undici requests in a transaction
+   * and the request to the transaction is using a keep alive there is a chance the
+   * executionAsyncResource may be incorrect because of shared connections.  To revert to a more
+   * naive tracking of parent set `config.feature_flag.undici_async_tracking: false` and
+   * it will just call `shim.getSegment()`
+   */
+  function getParentSegment() {
+    if (agent.config.feature_flag.undici_async_tracking) {
+      const resource = executionAsyncResource()
+
+      if (!resource[SYMBOLS.PARENT_SEGMENT]) {
+        const parent = shim.getSegment()
+        resource[SYMBOLS.PARENT_SEGMENT] = parent
+      }
+      return resource[SYMBOLS.PARENT_SEGMENT]
+    }
+    return shim.getSegment()
+  }
+
+  /**
+   * This event occurs after the Undici Request is created
+   * We will check current segment for opaque and also attach
+   * relevant headers to outgoing http request
+   *
+   * @param {object} params
+   * @param {object} params.request undici request object
+   */
+  diagnosticsChannel.channel('undici:request:create').subscribe(({ request }) => {
+    const parent = getParentSegment()
+    request[SYMBOLS.PARENT_SEGMENT] = parent
+    if (!parent || (parent && parent.opaque)) {
+      logger.trace(
+        'Not capturing data for outbound request (%s) because parent segment opaque (%s)',
+        request.path,
+        parent && parent.name
+      )
+
+      return
+    }
+
+    const transaction = parent.transaction
+    const outboundHeaders = Object.create(null)
+    if (agent.config.encoding_key && transaction.syntheticsHeader) {
+      outboundHeaders[NEWRELIC_SYNTHETICS_HEADER] = transaction.syntheticsHeader
+    }
+
+    if (agent.config.distributed_tracing.enabled) {
+      transaction.insertDistributedTraceHeaders(outboundHeaders)
+    } else if (agent.config.cross_application_tracer.enabled) {
+      cat.addCatHeaders(agent.config, transaction, outboundHeaders)
+    } else {
+      logger.trace('Both DT and CAT are disabled, not adding headers!')
+    }
+
+    // eslint-disable-next-line guard-for-in
+    for (const key in outboundHeaders) {
+      request.addHeader(key, outboundHeaders[key])
+    }
+  })
+
+  /**
+   * This event occurs right before the data is written to the socket.
+   * Undici has some abstracted headers that are only created at this time, one
+   * is the `host` header which we need to name the Undici segment. So in this
+   * handler we create, start and set the segment active, name it, and
+   * attach the url/procedure/request.parameters
+   *
+   * @param {object} params
+   * @param {object} params.request undicie request object
+   * @param {TLSSocket | net.Socket} socket active socket connection
+   */
+  diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(({ request, socket }) => {
+    const parentSegment = request[SYMBOLS.PARENT_SEGMENT]
+    if (!parentSegment || (parentSegment && parentSegment.opaque)) {
+      return
+    }
+
+    const port = socket.remotePort
+    const isHttps = socket.servername
+    let urlString
+    if (isHttps) {
+      urlString = `https://${socket.servername}`
+      urlString += port === 443 ? request.path : `:${port}${request.path}`
+    } else {
+      urlString = `http://${socket._host}`
+      urlString += port === 80 ? request.path : `:${port}${request.path}`
+    }
+
+    const url = new URL(urlString)
+
+    const name = NAMES.EXTERNAL.PREFIX + url.host + url.pathname
+    const segment = shim.createSegment(name, recordExternal(url.host, 'undici'), parentSegment)
+    if (segment) {
+      segment.start()
+      shim.setActiveSegment(segment)
+      segment.addAttribute('url', `${url.protocol}//${url.host}${url.pathname}`)
+
+      url.searchParams.forEach((value, key) => {
+        segment.addSpanAttribute(`request.parameters.${key}`, value)
+      })
+      segment.addAttribute('procedure', request.method || 'GET')
+      request[SYMBOLS.SEGMENT] = segment
+    }
+  })
+
+  /**
+   * This event occurs after the response headers have been received.
+   * We will add the relevant http response attributes to active segment.
+   * Also add CAT specific keys to active segment.
+   *
+   * @param {object} params
+   * @param {object} params.request undici request object
+   * @param {object} params.response { statusCode, headers, statusText }
+   */
+  diagnosticsChannel.channel('undici:request:headers').subscribe(({ request, response }) => {
+    const activeSegment = request[SYMBOLS.SEGMENT]
+    if (!activeSegment) {
+      return
+    }
+
+    activeSegment.addSpanAttribute('http.statusCode', response.statusCode)
+    activeSegment.addSpanAttribute('http.statusText', response.statusText)
+
+    if (
+      agent.config.cross_application_tracer.enabled &&
+      !agent.config.distributed_tracing.enabled
+    ) {
+      try {
+        const { appData } = cat.extractCatHeaders(response.headers)
+        const decodedAppData = cat.parseAppData(agent.config, appData)
+        const attrs = activeSegment.getAttributes()
+        const url = new URL(attrs.url)
+        cat.assignCatToSegment(decodedAppData, activeSegment, url.host)
+      } catch (err) {
+        logger.warn(err, 'Cannot add CAT data to segment')
+      }
+    }
+  })
+
+  /**
+   * This event occurs after the response body has been received.
+   * We will end the active segment and set the active back to parent before request
+   *
+   * @param {object} params.request undici request object
+   */
+  diagnosticsChannel.channel('undici:request:trailers').subscribe(({ request }) => {
+    endAndRestoreSegment(request)
+  })
+
+  /**
+   * This event occurs right before the request emits an error.
+   * We will end the active segment and set the active back to parent before request.
+   * We will also log errors to NR
+   *
+   * Note: This event occurs before the error handler so we will always log it for now.
+   */
+  diagnosticsChannel.channel('undici:request:error').subscribe(({ request, error }) => {
+    endAndRestoreSegment(request, error)
+  })
+
+  /**
+   * Gets the active and parent from given ctx(request, client connector)
+   * and ends active and restores parent to active.  If an error exists
+   * it will add the error to the transaction
+   *
+   * @param {object} ctx request or client connector
+   * @param {Error} error
+   */
+  function endAndRestoreSegment(ctx, error) {
+    const activeSegment = ctx[SYMBOLS.SEGMENT]
+    const parentSegment = ctx[SYMBOLS.PARENT_SEGMENT]
+    if (activeSegment) {
+      activeSegment.end()
+
+      if (error) {
+        handleError(activeSegment, error)
+      }
+
+      if (parentSegment) {
+        shim.setActiveSegment(parentSegment)
+      }
+    }
+  }
+
+  /**
+   * Adds the error to the active transaction
+   *
+   * @param {TraceSegment} activeSegment
+   * @param {Error} error
+   */
+  function handleError(activeSegment, error) {
+    logger.trace(error, 'Captured outbound error on behalf of the user.')
+    const tx = activeSegment.transaction
+    shim.agent.errors.add(tx, error)
+  }
+}
+
+module.exports.SYMBOLS = SYMBOLS

package/lib/instrumentations.js

@@ -31,6 +31,7 @@ module.exports = function instrumentations() {
     'redis': { type: MODULE_TYPE.DATASTORE },
     'restify': { type: MODULE_TYPE.WEB_FRAMEWORK },
     'superagent': { module: '@newrelic/superagent' },
+    'undici': { type: MODULE_TYPE.TRANSACTION },
     'oracle': { type: null },
     'vision': { type: MODULE_TYPE.WEB_FRAMEWORK },
     'when': { type: null }

package/lib/parse-proc-cpuinfo.js

@@ -17,6 +17,12 @@ function parseProcCPUInfo(data) {
     packages: null
   }
 
+  // In some rare cases the OS may be locked down so that you cannot retrieve this info.
+  if (!data) {
+    logger.debug('No CPU data to parse, returning empty stats.')
+    return processorStats
+  }
+
   // separate the processors
   let splitData = data.split('\n').map(function formatAttribute(attr) {
     return attr.split(':').map(function eliminateExtraWhitespace(s) {
@@ -34,7 +40,7 @@ function parseProcCPUInfo(data) {
 
   splitData = collapseMultilineValues(splitData)
 
-  const processors = seperateProcessors(splitData)
+  const processors = separateProcessors(splitData)
 
   processorStats = countProcessorStats(processors)
   if (!processorStats.cores) {
@@ -73,7 +79,7 @@ function collapseMultilineValues(li) {
 
 // walk through the processed list of key, value pairs and populate
 // objects till you find a collision
-function seperateProcessors(processorData) {
+function separateProcessors(processorData) {
   const processors = []
   let processor = Object.create(null)
   for (let i = 0; i < processorData.length; ++i) {

package/lib/parse-proc-meminfo.js

@@ -10,6 +10,12 @@ const logger = require('./logger.js').child({ component: 'proc-meminfo' })
 module.exports = parseProcMeminfo
 
 function parseProcMeminfo(data) {
+  // In some rare cases the OS may be locked down so that you cannot retrieve this info.
+  if (!data) {
+    logger.debug('No memory data to parse.')
+    return null
+  }
+
   const memTotal = parseInt(data.replace(/MemTotal:\s*(\d*)\skB/, '$1'), 10)
 
   if (memTotal) {

package/lib/serverless/aws-lambda.js

@@ -82,8 +82,14 @@ class AwsLambda {
       // NOTE: This may be converted to holding onto a single ender function if only
       // one invocation is executing at a time.
       shim.wrap(process, 'emit', function wrapEmit(shim, emit) {
-        return function wrappedEmit(ev) {
-          if (ev === 'beforeExit') {
+        return function wrappedEmit(ev, error) {
+          // need to add error as uncaughtException to be used
+          // later to add to transaction errors
+          if (ev === 'unhandledRejection') {
+            uncaughtException = error
+          }
+
+          if (['beforeExit', 'unhandledRejection'].includes(ev)) {
             transactionEnders.forEach((ender) => {
               ender()
             })

package/lib/shim/message-shim.js

@@ -62,20 +62,16 @@ const DESTINATION_TYPES = {
 /**
  * Constructs a shim specialized for instrumenting message brokers.
  *
- * @constructor
- * @extends TransactionShim
+ * @class
+ * @augments TransactionShim
  * @classdesc
  *  Used for instrumenting message broker client libraries.
- *
  * @param {Agent} agent
  *  The agent this shim will use.
- *
  * @param {string} moduleName
  *  The name of the module being instrumented.
- *
  * @param {string} resolvedName
  *  The full path to the loaded module.
- *
  * @see Shim
  * @see TransactionShim
  */
@@ -112,124 +108,93 @@ MessageShim.prototype.recordSubscribedConsume = recordSubscribedConsume
 
 /**
  * @callback MessageFunction
- *
  * @summary
  *  Used for determining information about a message either being produced or
  *  consumed.
- *
  * @param {MessageShim} shim
  *  The shim this function was handed to.
- *
  * @param {Function} func
  *  The produce method or message consumer.
- *
  * @param {string} name
  *  The name of the producer or consumer.
- *
  * @param {Array.<*>} args
  *  The arguments being passed into the produce method or consumer.
- *
- * @return {MessageSpec} The specification for the message being produced or
+ * @returns {MessageSpec} The specification for the message being produced or
  *  consumed.
- *
  * @see MessageShim#recordProduce
  * @see MessageShim#recordConsume
  */
 
 /**
  * @callback MessageHandlerFunction
- *
  * @summary
  *  A function that is used to extract properties from a consumed message. This
  *  method is handed the results of a consume call. If the consume used a
  *  callback, then this method will receive the arguments to the callback. If
  *  the consume used a promise, then this method will receive the resolved
  *  value.
- *
  * @param {MessageShim} shim
  *  The shim this function was handed to.
- *
  * @param {Function} func
  *  The produce method or message consumer.
- *
  * @param {string} name
  *  The name of the producer or consumer.
- *
  * @param {Array|*} args
  *  Either the arguments for the consumer callback function or the result of
  *  the resolved consume promise, depending on the mode of the instrumented
  *  method.
- *
- * @return {MessageSpec} The extracted properties of the consumed message.
- *
+ * @returns {MessageSpec} The extracted properties of the consumed message.
  * @see MessageShim#recordConsume
  */
 
 /**
  * @callback MessageConsumerWrapperFunction
- *
  * @summary
  *  Function that is used to wrap message consumer functions. Used along side
  *  the MessageShim#recordSubscribedConsume API method.
- *
  * @param {MessageShim} shim
  *  The shim this function was handed to.
- *
  * @param {Function} consumer
  *  The message consumer to wrap.
- *
  * @param {string} name
  *  The name of the consumer method.
- *
  * @param {string} queue
  *  The name of the queue this consumer is being subscribed to.
- *
- * @return {Function} The consumer method, possibly wrapped.
- *
+ * @returns {Function} The consumer method, possibly wrapped.
  * @see MessageShim#recordSubscribedConsume
  * @see MessageShim#recordConsume
  */
 
 /**
  * @interface MessageSpec
- * @extends RecorderSpec
- *
+ * @augments RecorderSpec
  * @description
  *  The specification for a message being produced or consumed.
- *
  * @property {string} destinationName
  *  The name of the exchange or queue the message is being produced to or
  *  consumed from.
- *
  * @property {MessageShim.DESTINATION_TYPES} [destinationType=null]
  *  The type of the destination. Defaults to `shim.EXCHANGE`.
- *
- * @property {Object} [headers=null]
+ * @property {object} [headers=null]
  *  A reference to the message headers. On produce, more headers will be added
  *  to this object which should be sent along with the message. On consume,
  *  cross-application headers will be read from this object.
- *
  * @property {string} [routingKey=null]
  *  The routing key for the message. If provided on consume, the routing key
  *  will be added to the transaction attributes as `message.routingKey`.
- *
  * @property {string} [queue=null]
  *  The name of the queue the message was consumed from. If provided on
  *  consume, the queue name will be added to the transaction attributes as
  *  `message.queueName`.
- *
  * @property {string} [parameters.correlation_id]
  *  In AMQP, this should be the correlation Id of the message, if it has one.
- *
  * @property {string} [parameters.reply_to]
  *  In AMQP, this should be the name of the queue to reply to, if the message
  *  has one.
- *
  * @property {MessageHandlerFunction} [messageHandler]
  *  An optional function to extract message properties from a consumed message.
  *  This method is only used in the consume case to pull data from the
  *  retrieved message.
- *
  * @see RecorderSpec
  * @see MessageShim#recordProduce
  * @see MessageShim#recordConsume
@@ -238,23 +203,19 @@ MessageShim.prototype.recordSubscribedConsume = recordSubscribedConsume
 
 /**
  * @interface MessageSubscribeSpec
- * @extends MessageSpec
- *
+ * @augments MessageSpec
  * @description
  *  Specification for message subscriber methods. That is, methods which
  *  register a consumer to start receiving messages.
- *
  * @property {number} consumer
  *  The index of the consumer in the method's arguments. Note that if the
  *  consumer and callback indexes point to the same argument, the argument will
  *  be wrapped as a consumer.
- *
  * @property {MessageHandlerFunction} messageHandler
  *  A function to extract message properties from a consumed message.
  *  This method is only used in the consume case to pull data from the
  *  retrieved message. Its return value is combined with the `MessageSubscribeSpec`
  *  to fully describe the consumed message.
- *
  * @see MessageSpec
  * @see MessageConsumerWrapperFunction
  * @see MessageShim#recordSubscribedConsume
@@ -269,11 +230,9 @@ MessageShim.prototype.recordSubscribedConsume = recordSubscribedConsume
  * passed, metric names will be generated using that.
  *
  * @memberof MessageShim.prototype
- *
  * @param {MessageShim.LIBRARY_NAMES|string} library
  *  The name of the message broker library. Use one of the well-known constants
  *  listed in {@link MessageShim.LIBRARY_NAMES} if available for the library.
- *
  * @see MessageShim.LIBRARY_NAMES
  */
 function setLibrary(library) {
@@ -305,20 +264,15 @@ function setLibrary(library) {
  * `PRODUCE` metric.
  *
  * @memberof MessageShim.prototype
- *
- * @param {Object|Function} nodule
+ * @param {object | Function} nodule
  *  The source for the properties to wrap, or a single function to wrap.
- *
  * @param {string|Array.<string>} [properties]
  *  One or more properties to wrap. If omitted, the `nodule` parameter is
  *  assumed to be the function to wrap.
- *
  * @param {MessageFunction} recordNamer
  *  A function which specifies details of the message.
- *
- * @return {Object|Function} The first parameter to this function, after
+ * @returns {object | Function} The first parameter to this function, after
  *  wrapping it or its properties.
- *
  * @see Shim#wrap
  * @see Shim#record
  * @see MessageSpec
@@ -374,21 +328,16 @@ function recordProduce(nodule, properties, recordNamer) {
  * consumers see {@link MessageShim#recordSubscribedConsume}
  *
  * @memberof MessageShim.prototype
- *
- * @param {Object|Function} nodule
+ * @param {object | Function} nodule
  *  The source for the properties to wrap, or a single function to wrap.
- *
  * @param {string|Array.<string>} [properties]
  *  One or more properties to wrap. If omitted, the `nodule` parameter is
  *  assumed to be the function to wrap.
- *
  * @param {MessageSpec|MessageFunction} spec
  *  The spec for the method or a function which returns the details of the
  *  method.
- *
- * @return {Object|Function} The first parameter to this function, after
+ * @returns {object | Function} The first parameter to this function, after
  *  wrapping it or its properties.
- *
  * @see Shim#wrap
  * @see Shim#record
  * @see MessageShim#recordSubscribedConsume
@@ -411,6 +360,10 @@ function recordConsume(nodule, properties, spec) {
     spec = this.setDefaults(spec, DEFAULT_SPEC)
   }
 
+  // This is using wrap instead of record because the spec allows for a messageHandler
+  // which is being used to handle the result of the callback or promise of the
+  // original wrapped consume function.
+  // TODO: https://github.com/newrelic/node-newrelic/issues/981
   return this.wrap(nodule, properties, function wrapConsume(shim, fn, fnName) {
     if (!shim.isFunction(fn)) {
       shim.logger.debug('Not wrapping %s (%s) as consume', fn, fnName)
@@ -487,15 +440,19 @@ function recordConsume(nodule, properties, spec) {
       // Call the method in the context of our segment.
       let ret = shim.applySegment(fn, segment, true, this, args)
 
-      // Intercept the promise to handle the result.
-      if (resHandler && ret && msgDesc.promise && shim.isPromise(ret)) {
-        ret = ret.then(function interceptValue(res) {
-          const msgProps = resHandler.call(this, shim, fn, fnName, res)
-          if (getParams && msgProps && msgProps.parameters) {
-            shim.copySegmentParameters(segment, msgProps.parameters)
-          }
-          return res
-        })
+      if (ret && msgDesc.promise && shim.isPromise(ret)) {
+        ret = shim.bindPromise(ret, segment)
+
+        // Intercept the promise to handle the result.
+        if (resHandler) {
+          ret = ret.then(function interceptValue(res) {
+            const msgProps = resHandler.call(this, shim, fn, fnName, res)
+            if (getParams && msgProps && msgProps.parameters) {
+              shim.copySegmentParameters(segment, msgProps.parameters)
+            }
+            return res
+          })
+        }
       }
 
       return ret
@@ -510,23 +467,17 @@ function recordConsume(nodule, properties, spec) {
  * - `recordPurgeQueue(func, spec)`
  *
  * @memberof MessageShim.prototype
- *
- * @param {Object|Function} nodule
+ * @param {object | Function} nodule
  *  The source for the properties to wrap, or a single function to wrap.
- *
  * @param {string|Array.<string>} [properties]
  *  One or more properties to wrap. If omitted, the `nodule` parameter is
  *  assumed to be the function to wrap.
- *
  * @param {RecorderSpec} spec
  *  The specification for this queue purge method's interface.
- *
  * @param {string} spec.queue
  *  The name of the queue being purged.
- *
- * @return {Object|Function} The first parameter to this function, after
+ * @returns {object | Function} The first parameter to this function, after
  *  wrapping it or its properties.
- *
  * @see Shim#wrap
  * @see Shim#record
  * @see RecorderSpec
@@ -598,20 +549,15 @@ function recordPurgeQueue(nodule, properties, spec) {
  * `spec.wrapper` method even if no transaction is active.
  *
  * @memberof MessageShim.prototype
- *
- * @param {Object|Function} nodule
+ * @param {object | Function} nodule
  *  The source for the properties to wrap, or a single function to wrap.
- *
  * @param {string|Array.<string>} [properties]
  *  One or more properties to wrap. If omitted, the `nodule` parameter is
  *  assumed to be the function to wrap.
- *
  * @param {MessageSubscribeSpec} spec
  *  The specification for this subscription method's interface.
- *
- * @return {Object|Function} The first parameter to this function, after
+ * @returns {object | Function} The first parameter to this function, after
  *  wrapping it or its properties.
- *
  * @see Shim#wrap
  * @see Shim#record
  * @see MessageShim#recordConsume
@@ -702,6 +648,10 @@ function recordSubscribedConsume(nodule, properties, spec) {
     }
   })
 
+  /**
+   * @param queue
+   * @param destinationName
+   */
   function makeWrapConsumer(queue, destinationName) {
     const msgDescDefaults = copy.shallow(spec)
     if (destNameIsArg && destinationName != null) {
@@ -810,6 +760,9 @@ function recordSubscribedConsume(nodule, properties, spec) {
 
           return ret
 
+          /**
+           *
+           */
           function endTransaction() {
             tx.finalizeName(null) // Use existing partial name.
             tx.end()
@@ -830,12 +783,10 @@ function recordSubscribedConsume(nodule, properties, spec) {
  * Constructs a message segment name from the given message descriptor.
  *
  * @private
- *
  * @param {MessageShim} shim    - The shim the segment will be constructed by.
  * @param {MessageSpec} msgDesc - The message descriptor.
  * @param {string}      action  - Produce or consume?
- *
- * @return {string} The generated name of the message segment.
+ * @returns {string} The generated name of the message segment.
  */
 function _nameMessageSegment(shim, msgDesc, action) {
   let name =
@@ -855,6 +806,10 @@ function _nameMessageSegment(shim, msgDesc, action) {
   return name
 }
 
+/**
+ * @param shim
+ * @param msgDesc
+ */
 function _nameMessageTransaction(shim, msgDesc) {
   let name = shim._metrics.LIBRARY + '/' + (msgDesc.destinationType || shim.EXCHANGE) + '/'