newrelic 8.3.0 → 8.5.2

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/instrumentation/vision.js

@@ -5,10 +5,10 @@
 
 'use strict'
 
-var semver = require('semver')
+const semver = require('semver')
 
 module.exports = function initialize(agent, vision, moduleName, shim) {
-  var plugin = vision.plugin
+  const plugin = vision.plugin
 
   if (!plugin || !plugin.pkg || semver.lt(plugin.pkg.version, '5.0.0')) {
     shim.logger.debug('Vision instrumentation requires v5 or greater, not instrumenting')
@@ -22,7 +22,7 @@ module.exports = function initialize(agent, vision, moduleName, shim) {
     return function wrappedRegister(server) {
       shim.wrap(server, 'decorate', wrapDecorate)
 
-      var ret = register.apply(this, arguments)
+      const ret = register.apply(this, arguments)
 
       shim.unwrapOnce(server, 'decorate')
 
@@ -37,7 +37,7 @@ function wrapDecorate(shim, decorate) {
       return decorate.apply(this, arguments)
     }
 
-    var args = shim.argsToArray.apply(shim, arguments)
+    const args = shim.argsToArray.apply(shim, arguments)
     args[2] = shim.recordRender(handler, { promise: true })
 
     return decorate.apply(this, args)

package/lib/instrumentation/when.js

@@ -5,9 +5,9 @@
 
 'use strict'
 
-var promInit = require('./promise')
+const promInit = require('./promise')
 
-var STATIC_PROMISE_METHODS = [
+const STATIC_PROMISE_METHODS = [
   'reject',
   'resolve',
   'all',
@@ -19,7 +19,7 @@ var STATIC_PROMISE_METHODS = [
   'reduceRight'
 ]
 
-var WHEN_SPEC = {
+const WHEN_SPEC = {
   name: 'when',
   constructor: 'Promise',
   executor: true,

package/lib/instrumentations.js

@@ -5,7 +5,7 @@
 
 'use strict'
 
-var MODULE_TYPE = require('./shim/constants').MODULE_TYPE
+const MODULE_TYPE = require('./shim/constants').MODULE_TYPE
 
 // Return a new copy of this array every time we're called
 module.exports = function instrumentations() {
@@ -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/logger.js

@@ -5,8 +5,8 @@
 
 'use strict'
 
-var Logger = require('./util/logger')
-var fs = require('./util/unwrapped-core').fs
+const Logger = require('./util/logger')
+const fs = require('./util/unwrapped-core').fs
 
 // create bootstrapping logger
 module.exports = new Logger({
@@ -20,9 +20,9 @@ module.exports = new Logger({
  * module, and if it gets loaded too early, module.exports will have no
  * value.
  */
-var config = require('./config').getOrCreateInstance()
+const config = require('./config').getOrCreateInstance()
 if (config) {
-  var options = {
+  const options = {
     name: 'newrelic',
     level: config.logging.level,
     enabled: config.logging.enabled
@@ -32,7 +32,7 @@ if (config) {
   module.exports = new Logger(options)
 
   if (config.logging.enabled) {
-    var stream
+    let stream
     switch (config.logging.filepath) {
       case 'stdout':
         stream = process.stdout

package/lib/metrics/index.js

@@ -82,7 +82,7 @@ function Metrics(apdexT, mapper, normalizer) {
 Metrics.prototype.measureMilliseconds = measureMilliseconds
 
 function measureMilliseconds(name, scope, duration, exclusive) {
-  var stats = this.getOrCreateMetric(name, scope)
+  const stats = this.getOrCreateMetric(name, scope)
   stats.recordValueInMillis(duration, exclusive)
   return stats
 }
@@ -96,7 +96,7 @@ function measureMilliseconds(name, scope, duration, exclusive) {
  * @return {Stats} The aggregated data related to this metric.
  */
 Metrics.prototype.measureBytes = function measureBytes(name, size) {
-  var stats = this.getOrCreateMetric(name)
+  const stats = this.getOrCreateMetric(name)
   stats.recordValueInBytes(size)
   return stats
 }
@@ -110,8 +110,8 @@ Metrics.prototype.measureBytes = function measureBytes(name, size) {
  * @return {Stats} The aggregated data for that name.
  */
 Metrics.prototype.getOrCreateMetric = function getOrCreateMetric(name, scope) {
-  var resolved = this._resolve(scope)
-  var stats = resolved[name]
+  const resolved = this._resolve(scope)
+  let stats = resolved[name]
   if (!stats) {
     this.empty = false
     stats = resolved[name] = new Stats()
@@ -141,14 +141,14 @@ function getOrCreateApdexMetric(name, scope, overrideApdex) {
     throw new Error('Metrics must be named')
   }
 
-  var resolved = this._resolve(scope)
+  const resolved = this._resolve(scope)
 
   if (!resolved[name]) {
     this.empty = false
 
     // Only use the given override to create the metric if this is not the
     // global apdex AND we have a valid value.
-    var apdexT =
+    const apdexT =
       name !== NAMES.APDEX && overrideApdex > 0 ? overrideApdex * FROM_MILLIS : this.apdexT
     resolved[name] = new ApdexStats(apdexT)
   }
@@ -209,12 +209,12 @@ Metrics.prototype.merge = function merge(other, adjustStartTime) {
   // Loop through all scopes and merge them. Since we know `.scoped` has a `null`
   // prototype we don't need to worry about own property checks.
   // eslint-disable-next-line guard-for-in
-  for (var scope in other.scoped) {
+  for (const scope in other.scoped) {
     _merge(this._resolve(scope), other.scoped[scope])
   }
 }
 function _merge(a, b) {
-  for (var name in b) {
+  for (const name in b) {
     if (a[name]) {
       a[name].merge(b[name])
     } else {
@@ -232,7 +232,7 @@ function _merge(a, b) {
  *                  un-scoped metrics if the scope isn't set.
  */
 Metrics.prototype._resolve = function _resolve(scope) {
-  var resolved = this.unscoped
+  let resolved = this.unscoped
 
   if (scope) {
     resolved = this.scoped[scope]
@@ -255,7 +255,7 @@ Metrics.prototype._getUnscopedData = function _getUnscopedData(name) {
     return
   }
 
-  var normalized = this.normalizer.normalize(name)
+  const normalized = this.normalizer.normalize(name)
   if (normalized.ignore || !normalized.value) {
     return
   }
@@ -274,7 +274,7 @@ Metrics.prototype._getScopedData = function _getScopedData(name, scope) {
     return
   }
 
-  var normalized = this.normalizer.normalize(name)
+  const normalized = this.normalizer.normalize(name)
   if (normalized.ignore || !normalized.value) {
     return
   }
@@ -287,10 +287,10 @@ Metrics.prototype._getScopedData = function _getScopedData(name, scope) {
  *                  for use by toJSON.
  */
 Metrics.prototype._toUnscopedData = function _toUnscopedData() {
-  var metricData = []
+  const metricData = []
 
   Object.keys(this.unscoped).forEach((name) => {
-    var data = this._getUnscopedData(name)
+    const data = this._getUnscopedData(name)
     if (data) {
       metricData.push(data)
     }
@@ -304,11 +304,11 @@ Metrics.prototype._toUnscopedData = function _toUnscopedData() {
  *                  use by toJSON.
  */
 Metrics.prototype._toScopedData = function _toScopedData() {
-  var metricData = []
+  const metricData = []
 
   Object.keys(this.scoped).forEach(function forEachScope(scope) {
     Object.keys(this.scoped[scope]).forEach(function forEachMetric(name) {
-      var data = this._getScopedData(name, scope)
+      const data = this._getScopedData(name, scope)
       if (data) {
         metricData.push(data)
       }

package/lib/metrics/mapper.js

@@ -5,7 +5,7 @@
 
 'use strict'
 
-var logger = require('../logger').child({ component: 'mapper' })
+const logger = require('../logger').child({ component: 'mapper' })
 
 /**
  * To tighten up the metrics JSON, the collector will maintain a list of
@@ -41,12 +41,12 @@ MetricMapper.prototype.load = function load(raw) {
     return
   }
 
-  for (var i = 0; i < raw.length; i++) {
-    var spec = raw[i][0]
-    var scope = spec.scope
-    var name = spec.name
-    var id = raw[i][1]
-    var resolved
+  for (let i = 0; i < raw.length; i++) {
+    const spec = raw[i][0]
+    const scope = spec.scope
+    const name = spec.name
+    const id = raw[i][1]
+    let resolved
 
     if (scope) {
       if (!this.scoped[scope]) {

package/lib/metrics/normalizer/rule.js

@@ -5,12 +5,12 @@
 
 'use strict'
 
-var logger = require('../../logger').child({ component: 'normalizer_rule' })
+const logger = require('../../logger').child({ component: 'normalizer_rule' })
 
 /**
  * JavaScript just has to do things slightly differently.
  */
-var replaceReplacer = function replaceReplacer(input) {
+const replaceReplacer = function replaceReplacer(input) {
   return input.replace(/\\/g, '$')
 }
 
@@ -37,7 +37,7 @@ function NormalizerRule(json) {
   this.ignore = json.ignore || false
   this.matched = false
 
-  var modifiers = 'i'
+  let modifiers = 'i'
   if (this.replaceAll) {
     modifiers += 'g'
   }
@@ -78,9 +78,9 @@ NormalizerRule.prototype.getSegments = function getSegments(input) {
  * @return {bool} - True if this rule matches the given input, otherwise false.
  */
 NormalizerRule.prototype.matches = function matches(input) {
-  var segments = this.getSegments(input)
+  const segments = this.getSegments(input)
 
-  for (var i = 0; i < segments.length; ++i) {
+  for (let i = 0; i < segments.length; ++i) {
     if (this.pattern.test(segments[i])) {
       return true
     }
@@ -118,7 +118,7 @@ NormalizerRule.prototype.apply = function apply(input) {
   }
 
   this.matched = false
-  var result = this.getSegments(input)
+  const result = this.getSegments(input)
     .map(function applyMap(segment) {
       // Discussion of why we use `lastIndex` in function documentation to
       // prevent de-opt due to long function.
@@ -154,9 +154,9 @@ NormalizerRule.prototype.toJSON = function toJSON() {
  * @return {RegExp} - A regular expression with all the given flags added.
  */
 function _addRegExpFlags(re, flags) {
-  var foundMissing = false
-  var reFlags = re.flags
-  for (var i = 0; i < flags.length; ++i) {
+  let foundMissing = false
+  let reFlags = re.flags
+  for (let i = 0; i < flags.length; ++i) {
     if (reFlags.indexOf(flags[i]) === -1) {
       foundMissing = true
       reFlags += flags[i]

package/lib/metrics/normalizer/tx_segment.js

@@ -5,7 +5,7 @@
 
 'use strict'
 
-var logger = require('../../logger').child({ component: 'tx_segment_normalizer' })
+const logger = require('../../logger').child({ component: 'tx_segment_normalizer' })
 
 module.exports = TxSegmentNormalizer
 
@@ -33,21 +33,21 @@ function TxSegmentNormalizer() {
  * @return {NormalizationResults} - The results of normalizing the given path.
  */
 TxSegmentNormalizer.prototype.normalize = function normalize(path) {
-  var currentTerm
-  var prefix
-  for (var i = 0; i < this.terms.length; i++) {
+  let currentTerm
+  let prefix
+  for (let i = 0; i < this.terms.length; i++) {
     currentTerm = this.terms[i]
     prefix = currentTerm.prefix
     if (path.lastIndexOf(prefix, 0) === -1) {
       continue
     }
-    var fragment = path.slice(prefix.length)
-    var parts = fragment.split('/')
-    var result = []
-    var prev
+    const fragment = path.slice(prefix.length)
+    const parts = fragment.split('/')
+    const result = []
+    let prev
+    let segment
 
-    var segment
-    for (var j = 0; j < parts.length; j++) {
+    for (let j = 0; j < parts.length; j++) {
       segment = parts[j]
 
       if (segment === '' && j + 1 === parts.length) {
@@ -87,10 +87,10 @@ TxSegmentNormalizer.prototype.load = function load(json) {
 }
 
 function filterRules(rules) {
-  var map = Object.create(null)
+  const map = Object.create(null)
 
-  for (var i = 0, l = rules.length; i < l; ++i) {
-    var prefix = rules[i].prefix
+  for (let i = 0, l = rules.length; i < l; ++i) {
+    let prefix = rules[i].prefix
 
     if (!prefix || typeof prefix !== 'string') {
       continue
@@ -101,7 +101,7 @@ function filterRules(rules) {
       rules[i].prefix = prefix
     }
 
-    var segments = prefix.split('/')
+    const segments = prefix.split('/')
     if (segments.length !== 3 || !segments[0] || !segments[1] || segments[3]) {
       continue
     }
@@ -111,10 +111,10 @@ function filterRules(rules) {
     }
   }
 
-  var keys = Object.keys(map)
-  var filtered = new Array(keys.length)
+  const keys = Object.keys(map)
+  const filtered = new Array(keys.length)
 
-  for (i = 0, l = keys.length; i < l; ++i) {
+  for (let i = 0, l = keys.length; i < l; ++i) {
     filtered[i] = map[keys[i]]
   }