newrelic 10.6.2 → 11.1.0

package/lib/instrumentation/pino/pino.js

@@ -15,7 +15,7 @@ const {
 } = require('../../util/application-logging')
 const semver = require('semver')
 
-module.exports = function instrument(shim) {
+module.exports = function instrument(shim, tools) {
   const pinoVersion = shim.require('./package.json').version
 
   if (semver.lt(pinoVersion, '7.0.0')) {
@@ -23,7 +23,6 @@ module.exports = function instrument(shim) {
     return
   }
 
-  const tools = shim.require('./lib/tools')
   const agent = shim.agent
   const config = agent.config
 
@@ -35,18 +34,6 @@ module.exports = function instrument(shim) {
   const metrics = agent.metrics
   createModuleUsageMetric('pino', metrics)
 
-  const levelUtils = shim.require('./lib/levels')
-
-  /**
-   * Creates an object where the keys are the level labels and values are the level number.
-   * Pino passes in level as number but our spec needs it to be the label
-   */
-  const levelMap = Object.entries(levelUtils.levels).reduce((levels, level) => {
-    const [label, number] = level
-    levels[number] = label
-    return levels
-  }, {})
-
   const symbols = shim.require('./lib/symbols')
 
   shim.wrap(tools, 'asJson', function wrapJson(shim, asJson) {
@@ -62,10 +49,10 @@ module.exports = function instrument(shim) {
      */
     return function wrappedAsJson() {
       const args = shim.argsToArray.apply(shim, arguments)
+      const level = this?.levels?.labels?.[args[2]]
 
       if (isMetricsEnabled(config)) {
-        const level = args[2]
-        incrementLoggingLinesMetrics(levelMap[level], metrics)
+        incrementLoggingLinesMetrics(level, metrics)
       }
 
       if (isLocalDecoratingEnabled(config)) {
@@ -86,7 +73,7 @@ module.exports = function instrument(shim) {
           logLine,
           agent,
           chindings,
-          levelMap,
+          level,
           logger: shim.logger
         })
 
@@ -110,10 +97,10 @@ module.exports = function instrument(shim) {
  * @param logLine.agent
  * @param logLine.chindings
  * @param logLine.msg
- * @param logLine.levelMap
+ * @param logLine.level
  * @param logLine.logger
  */
-function reformatLogLine({ logLine, msg, agent, chindings = '', levelMap, logger }) {
+function reformatLogLine({ logLine, msg, agent, chindings = '', level, logger }) {
   const metadata = agent.getLinkingMetadata()
 
   /**
@@ -145,7 +132,7 @@ function reformatLogLine({ logLine, msg, agent, chindings = '', levelMap, logger
       reformatError(formattedLog)
     }
     Object.assign(formattedLog, agentMeta)
-    formattedLog.level = levelMap[formattedLog.level]
+    formattedLog.level = level
     delete formattedLog.time
     delete formattedLog.msg
     return formattedLog

package/lib/instrumentation/undici.js

@@ -12,48 +12,38 @@ const NAMES = require('../metrics/names')
 const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
 const symbols = require('../symbols')
 const { executionAsyncResource } = require('async_hooks')
-const tls = require('tls')
-const net = require('net')
-
-let diagnosticsChannel = null
-try {
-  diagnosticsChannel = require('diagnostics_channel')
-} catch (e) {
-  // quick check to see if module exists
-  // module was not added until v15.x
-}
+const diagnosticsChannel = require('diagnostics_channel')
 
-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
-  }
-
-  registerHookPoints(shim)
-}
+const channels = [
+  { channel: diagnosticsChannel.channel('undici:request:create'), hook: requestCreateHook },
+  { channel: diagnosticsChannel.channel('undici:request:headers'), hook: requestHeadersHook },
+  { channel: diagnosticsChannel.channel('undici:request:trailers'), hook: endAndRestoreSegment },
+  { channel: diagnosticsChannel.channel('undici:request:error'), hook: endAndRestoreSegment }
+]
 
 /**
  * Subscribes to all relevant undici hook points
  * See: https://github.com/nodejs/undici/blob/main/docs/api/DiagnosticsChannel.md
  *
- * @param {Shim} shim instance of shim
+ * @param agent
+ * @param _undici
+ * @param _modName
+ * @param shim
  */
-function registerHookPoints(shim) {
-  diagnosticsChannel.channel('undici:request:create').subscribe(requestCreateHook.bind(null, shim))
-  diagnosticsChannel
-    .channel('undici:client:sendHeaders')
-    .subscribe(responseHeadersHook.bind(null, shim))
-  diagnosticsChannel
-    .channel('undici:request:headers')
-    .subscribe(requestHeadersHook.bind(null, shim))
-  diagnosticsChannel
-    .channel('undici:request:trailers')
-    .subscribe(endAndRestoreSegment.bind(null, shim))
-  diagnosticsChannel
-    .channel('undici:request:error')
-    .subscribe(endAndRestoreSegment.bind(null, shim))
+module.exports = function addUndiciChannels(agent, _undici, _modName, shim) {
+  channels.forEach(({ channel, hook }) => {
+    if (!channel.hasSubscribers) {
+      channel.subscribe(hook.bind(null, shim))
+    }
+  })
+}
+
+module.exports.unsubscribe = function unsubscribe() {
+  channels.forEach(({ channel, hook }) => {
+    if (channel.hasSubscribers) {
+      channel.unsubscribe(hook)
+    }
+  })
 }
 
 /**
@@ -90,29 +80,14 @@ function getParentSegment(shim) {
 }
 
 /**
- * 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
+ * Injects relevant DT headers for the external request
  *
- * @param {Shim} shim instance of shim
- * @param {object} params object from undici hook
+ * @param {object} params object to fn
+ * @param {Shim} params.transaction current transaction
  * @param {object} params.request undici request object
+ * @param {object} params.config agent config
  */
-function requestCreateHook(shim, { request }) {
-  const { config } = shim.agent
-  const parent = getParentSegment(shim)
-  request[symbols.parentSegment] = 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
+function addDTHeaders({ transaction, config, request }) {
   const outboundHeaders = Object.create(null)
   if (config.encoding_key && transaction.syntheticsHeader) {
     outboundHeaders[NEWRELIC_SYNTHETICS_HEADER] = transaction.syntheticsHeader
@@ -133,37 +108,19 @@ function requestCreateHook(shim, { request }) {
 }
 
 /**
- * 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
+ * Creates the external segment with url, procedure and request.parameters attributes
  *
- * @param {Shim} shim instance of shim
- * @param {object} params object from undici hook
+ * @param {object} params object to fn
+ * @param {Shim} params.shim instance of shim
  * @param {object} params.request undici request object
- * @param {tls.TLSSocket | net.Socket} params.socket active socket connection
+ * @param {object} params.parentSegment current active, about to be parent of external segment
  */
-function responseHeadersHook(shim, { request, socket }) {
-  const parentSegment = request[symbols.parentSegment]
-  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)
-
+function createExternalSegment({ shim, request, parentSegment }) {
+  const url = new URL(request.origin + request.path)
   const name = NAMES.EXTERNAL.PREFIX + url.host + url.pathname
+  // Metrics for `External/<host>` will have a suffix of undici
+  // We will have to see if this matters for people only using fetch
+  // It's undici under the hood so ¯\_(ツ)_/¯
   const segment = shim.createSegment(name, recordExternal(url.host, 'undici'), parentSegment)
   if (segment) {
     segment.start()
@@ -178,6 +135,38 @@ function responseHeadersHook(shim, { request, socket }) {
   }
 }
 
+/**
+ * This event occurs after the Undici Request is created.
+ * We will check current segment for opaque before creating the
+ * external segment with the standard url/procedure/request.parameters
+ * attributes.  We will also attach relevant DT headers to outgoing http request.
+ *
+ * @param {Shim} shim instance of shim
+ * @param {object} params object from undici hook
+ * @param {object} params.request undici request object
+ */
+function requestCreateHook(shim, { request }) {
+  const { config } = shim.agent
+  const parentSegment = getParentSegment(shim)
+  request[symbols.parentSegment] = parentSegment
+  if (!parentSegment || (parentSegment && parentSegment.opaque)) {
+    logger.trace(
+      'Not capturing data for outbound request (%s) because parent segment opaque (%s)',
+      request.path,
+      parentSegment && parentSegment.name
+    )
+
+    return
+  }
+
+  try {
+    addDTHeaders({ transaction: parentSegment.transaction, config, request })
+    createExternalSegment({ shim, request, parentSegment })
+  } catch (err) {
+    logger.warn(err, 'Unable to create external segment')
+  }
+}
+
 /**
  * This event occurs after the response headers have been received.
  * We will add the relevant http response attributes to active segment.

package/lib/instrumentations.js

@@ -11,7 +11,7 @@ const MODULE_TYPE = require('./shim/constants').MODULE_TYPE
 module.exports = function instrumentations() {
   return {
     'aws-sdk': { module: '@newrelic/aws-sdk' },
-    'amqplib': { type: MODULE_TYPE.MESSAGE },
+    'amqplib': { module: './instrumentation/amqplib' },
     'cassandra-driver': { type: MODULE_TYPE.DATASTORE },
     'connect': { type: MODULE_TYPE.WEB_FRAMEWORK },
     'bluebird': { type: MODULE_TYPE.PROMISE },
@@ -36,7 +36,6 @@ module.exports = function instrumentations() {
     '@redis/client': { type: MODULE_TYPE.DATASTORE },
     'restify': { type: MODULE_TYPE.WEB_FRAMEWORK },
     'superagent': { module: '@newrelic/superagent' },
-    'undici': { type: MODULE_TYPE.TRANSACTION },
     '@hapi/vision': { type: MODULE_TYPE.WEB_FRAMEWORK },
     'when': { module: './instrumentation/when' },
     'winston': { type: MODULE_TYPE.GENERIC },

package/lib/metrics/names.js

@@ -272,8 +272,7 @@ const INFINITE_TRACING = {
 const FEATURES = {
   ESM: {
     LOADER: `${SUPPORTABILITY.FEATURES}/ESM/Loader`,
-    UNSUPPORTED_LOADER: `${SUPPORTABILITY.FEATURES}/ESM/UnsupportedLoader`,
-    CUSTOM_INSTRUMENTATION: `${SUPPORTABILITY.FEATURES}/ESM/CustomInstrumentation`
+    UNSUPPORTED_LOADER: `${SUPPORTABILITY.FEATURES}/ESM/UnsupportedLoader`
   },
   CJS: {
     PRELOAD: `${SUPPORTABILITY.FEATURES}/CJS/Preload`,

package/lib/shim/message-shim.js

@@ -736,7 +736,7 @@ function recordSubscribedConsume(nodule, properties, spec) {
             }
           }
           if (msgDesc.headers) {
-            shim.handleCATHeaders(msgDesc.headers, tx.baseSegment, shim._transportType)
+            shim.handleMqTracingHeaders(msgDesc.headers, tx.baseSegment, shim._transportType)
           }
 
           shim.logger.trace('Started message transaction %s named %s', tx.id, txName)

package/lib/shim/transaction-shim.js

@@ -66,7 +66,7 @@ TransactionShim.prototype.bindCreateTransaction = bindCreateTransaction
 TransactionShim.prototype.pushTransactionName = pushTransactionName
 TransactionShim.prototype.popTransactionName = popTransactionName
 TransactionShim.prototype.setTransactionName = setTransactionName
-TransactionShim.prototype.handleCATHeaders = handleCATHeaders
+TransactionShim.prototype.handleMqTracingHeaders = handleMqTracingHeaders
 TransactionShim.prototype.insertCATReplyHeader = insertCATReplyHeader
 TransactionShim.prototype.insertCATRequestHeaders = insertCATRequestHeaders
 
@@ -204,7 +204,7 @@ function setTransactionName(name) {
 /**
  * Retrieves whatever CAT headers may be in the given headers.
  *
- * - `handleCATHeaders(headers [, segment [, transportType]])`
+ * - `handleMqTracingHeaders(headers [, segment [, transportType]])`
  *
  * @memberof TransactionShim.prototype
  *
@@ -218,8 +218,8 @@ function setTransactionName(name) {
  * @param {string} [transportType='Unknown']
  *  The transport type that brought the headers. Usually `HTTP` or `HTTPS`.
  */
-function handleCATHeaders(headers, segment, transportType) {
-  // TODO: rename function or replace functionality when CAT fully removed.
+function handleMqTracingHeaders(headers, segment, transportType) {
+  // TODO: replace functionality when CAT fully removed.
 
   if (!headers) {
     this.logger.debug('No headers for CAT or DT processing.')