newrelic 9.7.0 → 9.7.2

package/lib/instrumentation/core/http-outbound.js

@@ -5,8 +5,6 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 40] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 const recordExternal = require('../../metrics/recorders/http_external')
 const cat = require('../../util/cat')
 const urltils = require('../../util/urltils')
@@ -15,6 +13,7 @@ const shimmer = require('../../shimmer')
 const url = require('url')
 const copy = require('../../util/copy')
 const symbols = require('../../symbols')
+const http = require('http')
 
 const NAMES = require('../../metrics/names')
 
@@ -25,27 +24,73 @@ const DEFAULT_SSL_PORT = 443
 const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
 
 /**
- * Instruments an outbound HTTP request.
+ * Determines the default port to 80 if protocol is undefined or http:
+ * Otherwise it assigns it as 443
  *
- * @param {object} agent instantiation of lib/agent.js
  * @param {object} opts HTTP request options
- * @param {Function} makeRequest function for issuing actual HTTP request
- * @returns {object} The instrumented outbound HTTP request.
+ * @returns {number} default port
  */
-module.exports = function instrumentOutbound(agent, opts, makeRequest) {
+function getDefaultPort(opts) {
+  return !opts.protocol || opts.protocol === 'http:' ? DEFAULT_HTTP_PORT : DEFAULT_SSL_PORT
+}
+
+/**
+ * Determines the port based on http opts
+ *
+ * @param {object} opts HTTP request options
+ * @param {number} defaultPort the default port
+ * @returns {number} port
+ */
+function getPort(opts, defaultPort) {
+  let port = opts.port || opts.defaultPort
+  if (!port) {
+    port = defaultPort
+  }
+
+  return port
+}
+
+/**
+ * Determines the default hostname based on http opts
+ *
+ * @param {object} opts HTTP request options
+ * @returns {string} default host
+ */
+function getDefaultHostName(opts) {
+  return opts.hostname || opts.host || DEFAULT_HOST
+}
+
+/**
+ * Parses http opts to an object
+ * If string will call url.parse, otherwise it will
+ * do a shallow copy
+ *
+ * @param {string|object} opts a url string or HTTP request options
+ * @returns {object} parsed http opts
+ */
+function parseOpts(opts) {
   if (typeof opts === 'string') {
     opts = url.parse(opts)
   } else {
     opts = copy.shallow(opts)
   }
 
-  const defaultPort =
-    !opts.protocol || opts.protocol === 'http:' ? DEFAULT_HTTP_PORT : DEFAULT_SSL_PORT
-  let hostname = opts.hostname || opts.host || DEFAULT_HOST
-  let port = opts.port || opts.defaultPort
-  if (!port) {
-    port = defaultPort
-  }
+  return opts
+}
+
+/**
+ * Instruments an outbound HTTP request.
+ *
+ * @param {Agent} agent instantiation of lib/agent.js
+ * @param {object} opts HTTP request options
+ * @param {Function} makeRequest function for issuing actual HTTP request
+ * @returns {object} The instrumented outbound HTTP request.
+ */
+module.exports = function instrumentOutbound(agent, opts, makeRequest) {
+  opts = parseOpts(opts)
+  const defaultPort = getDefaultPort(opts)
+  let hostname = getDefaultHostName(opts)
+  const port = getPort(opts, defaultPort)
 
   if (!hostname || port < 1) {
     logger.warn('Invalid host name (%s) or port (%s) for outbound request.', hostname, port)
@@ -74,79 +119,144 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
     recordExternal(hostname, 'http'),
     parent,
     false,
-    instrumentRequest
+    instrumentRequest.bind(null, agent, opts, makeRequest, hostname)
   )
+}
+
+/**
+ * Injects DT/CAT headers, creates segment for outbound http request.
+ * Instruments the request.emit to properly handle the response of the
+ * outbound http request
+ *
+ * @param {Agent} agent New Relic agent
+ * @param {string|object} opts a url string or HTTP request options
+ * @param {Function} makeRequest function to make request
+ * @param {string} hostname host of outbound request
+ * @param {TraceSegment} segment outbound http segment
+ * @returns {http.IncomingMessage} request actual http outbound request
+ */
+function instrumentRequest(agent, opts, makeRequest, hostname, segment) {
+  const transaction = segment.transaction
+  const outboundHeaders = Object.create(null)
 
-  function instrumentRequest(segment) {
-    const transaction = segment.transaction
-    const outboundHeaders = Object.create(null)
+  if (agent.config.encoding_key && transaction.syntheticsHeader) {
+    outboundHeaders[NEWRELIC_SYNTHETICS_HEADER] = transaction.syntheticsHeader
+  }
 
-    if (agent.config.encoding_key && transaction.syntheticsHeader) {
-      outboundHeaders[NEWRELIC_SYNTHETICS_HEADER] = transaction.syntheticsHeader
-    }
+  maybeAddDtCatHeaders(agent, transaction, outboundHeaders, !!opts?.headers?.[symbols.disableDT])
+  opts.headers = assignOutgoingHeaders(opts.headers, outboundHeaders)
 
-    // TODO: abstract header logic shared with TransactionShim#insertCATRequestHeaders
-    if (agent.config.distributed_tracing.enabled) {
-      if (opts.headers && opts.headers[symbols.disableDT]) {
-        logger.trace('Distributed tracing disabled by instrumentation.')
-      } else {
-        transaction.insertDistributedTraceHeaders(outboundHeaders)
-      }
-    } else if (agent.config.cross_application_tracer.enabled) {
-      cat.addCatHeaders(agent.config, transaction, outboundHeaders)
+  const request = applySegment(opts, makeRequest, hostname, segment)
+
+  instrumentRequestEmit(agent, hostname, segment, request)
+
+  return request
+}
+
+/**
+ * Depending on configuration it will either add DT or CAT headers to the
+ * outgoing headers
+ *
+ * @param {Agent} agent Node.js agent
+ * @param {Transaction} transaction active transaction
+ * @param {object} outboundHeaders headers that are getting attached to external http call
+ * @param {boolean} hasDtSym flag to tell if the disableDT header exists on headers
+ */
+// TODO: abstract header logic shared with TransactionShim#insertCATRequestHeaders
+function maybeAddDtCatHeaders(agent, transaction, outboundHeaders, hasDtSym = false) {
+  if (agent.config.distributed_tracing.enabled) {
+    if (hasDtSym) {
+      logger.trace('Distributed tracing disabled by instrumentation.')
     } else {
-      logger.trace('Both DT and CAT are disabled, not adding headers!')
+      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!')
+  }
+}
 
-    if (Array.isArray(opts.headers)) {
-      opts.headers = opts.headers.slice()
-      Array.prototype.push.apply(
-        opts.headers,
-        Object.keys(outboundHeaders).map(function getHeaderTuples(key) {
-          return [key, outboundHeaders[key]]
-        })
-      )
-    } else {
-      opts.headers = Object.assign(Object.create(null), opts.headers, outboundHeaders)
+/**
+ * Assigns new headers for outgoing request
+ *
+ * @param {object|Array} currentHeaders current headers from request options headers
+ * @param {object} outboundHeaders headers to assign to outgoing request
+ * @returns {object|Array} properly formatted headers
+ */
+function assignOutgoingHeaders(currentHeaders, outboundHeaders) {
+  let headers
+
+  if (Array.isArray(currentHeaders)) {
+    headers = currentHeaders.slice()
+    Array.prototype.push.apply(
+      headers,
+      Object.keys(outboundHeaders).map(function getHeaderTuples(key) {
+        return [key, outboundHeaders[key]]
+      })
+    )
+  } else {
+    headers = Object.assign(Object.create(null), currentHeaders, outboundHeaders)
+  }
+
+  return headers
+}
+
+/**
+ * Starts the http outbound segment and attaches relevant attributes to the segment/span.
+ *
+ * @param {string|object} opts a url string or HTTP request options
+ * @param {Function} makeRequest function to make request
+ * @param {string} hostname host of outbound request
+ * @param {TraceSegment} segment outbound http segment
+ * @returns {http.IncomingMessage} request actual http outbound request
+ */
+function applySegment(opts, makeRequest, hostname, segment) {
+  segment.start()
+  const request = makeRequest(opts)
+  const parsed = urltils.scrubAndParseParameters(request.path)
+  const proto = parsed.protocol || opts.protocol || 'http:'
+  segment.name += parsed.path
+  request[symbols.segment] = segment
+
+  if (parsed.parameters) {
+    // Scrub and parse returns on object with a null prototype.
+    // eslint-disable-next-line guard-for-in
+    for (const key in parsed.parameters) {
+      segment.addSpanAttribute(`request.parameters.${key}`, parsed.parameters[key])
     }
+  }
+  segment.addAttribute('url', `${proto}//${hostname}${parsed.path}`)
+  segment.addAttribute('procedure', opts.method || 'GET')
+  return request
+}
 
-    segment.start()
-    const request = makeRequest(opts)
-    const parsed = urltils.scrubAndParseParameters(request.path)
-    const proto = parsed.protocol || opts.protocol || 'http:'
-    segment.name += parsed.path
-    request[symbols.segment] = segment
-
-    if (parsed.parameters) {
-      // Scrub and parse returns on object with a null prototype.
-      // eslint-disable-next-line guard-for-in
-      for (const key in parsed.parameters) {
-        segment.addSpanAttribute(`request.parameters.${key}`, parsed.parameters[key])
+/**
+ * Wrap the emit method. We're doing a special wrapper instead of using
+ * `tracer.bindEmitter` because we want to do some logic based on certain
+ * events.
+ *
+ * @param {Agent} agent New Relic agent
+ * @param {string} hostname host of outbound request
+ * @param {TraceSegment} segment outbound http segment
+ * @param {http.IncomingMessage} request actual http outbound request
+ */
+function instrumentRequestEmit(agent, hostname, segment, request) {
+  shimmer.wrapMethod(request, 'request.emit', 'emit', function wrapEmit(emit) {
+    const boundEmit = agent.tracer.bindFunction(emit, segment)
+    return function wrappedRequestEmit(evnt, arg) {
+      if (evnt === 'error') {
+        segment.end()
+        handleError(segment, request, arg)
+      } else if (evnt === 'response') {
+        handleResponse(segment, hostname, arg)
       }
+
+      return boundEmit.apply(this, arguments)
     }
-    segment.addAttribute('url', `${proto}//${hostname}${parsed.path}`)
-    segment.addAttribute('procedure', opts.method || 'GET')
-
-    // Wrap the emit method. We're doing a special wrapper instead of using
-    // `tracer.bindEmitter` because we want to do some logic based on certain
-    // events.
-    shimmer.wrapMethod(request, 'request.emit', 'emit', function wrapEmit(emit) {
-      const boundEmit = agent.tracer.bindFunction(emit, segment)
-      return function wrappedRequestEmit(evnt, arg) {
-        if (evnt === 'error') {
-          segment.end()
-          handleError(segment, request, arg)
-        } else if (evnt === 'response') {
-          handleResponse(segment, hostname, request, arg)
-        }
-
-        return boundEmit.apply(this, arguments)
-      }
-    })
-    _makeNonEnumerable(request, 'emit')
+  })
 
-    return request
-  }
+  _makeNonEnumerable(request, 'emit')
 }
 
 /**
@@ -175,10 +285,9 @@ function handleError(segment, req, error) {
  *
  * @param {object} segment TraceSegment instance
  * @param {string} hostname host of the HTTP request
- * @param {object} req http.ClientRequest
- * @param {object} res http.IncomingMessage
+ * @param {object} res http.ServerResponse
  */
-function handleResponse(segment, hostname, req, res) {
+function handleResponse(segment, hostname, res) {
   // Add response attributes for spans
   segment.addSpanAttribute('http.statusCode', res.statusCode)
   segment.addSpanAttribute('http.statusText', res.statusMessage)
@@ -204,6 +313,12 @@ function handleResponse(segment, hostname, req, res) {
   _makeNonEnumerable(res, 'emit')
 }
 
+/**
+ * Makes a property non-enumerable
+ *
+ * @param {object} obj object that contains property that needs to be non-enumerable
+ * @param {string} prop property to make non-enumerable
+ */
 function _makeNonEnumerable(obj, prop) {
   try {
     const desc = Object.getOwnPropertyDescriptor(obj, prop)

package/lib/instrumentation/core/timers.js

@@ -5,73 +5,114 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 16] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 const symbols = require('../../symbols')
+const Timers = require('timers')
 
 module.exports = initialize
 
-function initialize(agent, timers, moduleName, shim) {
-  if (!agent.config.feature_flag.async_local_context) {
-    instrumentProcessMethods(shim, process)
-  }
-
-  instrumentTimerMethods(timers)
+function initialize(agent, timers, _moduleName, shim) {
+  const isAsyncLocalContext = agent.config.feature_flag.async_local_context
 
-  // If we need to instrument separate references to timers on the global object,
-  // do that now.
-  if (!shim.isWrapped(global.setTimeout)) {
-    instrumentTimerMethods(global)
+  if (!isAsyncLocalContext) {
+    instrumentProcessMethods(shim, process)
+    instrumentSetImmediate(shim, [timers, global])
   }
 
-  function instrumentTimerMethods(nodule) {
-    const asynchronizers = ['setTimeout', 'setInterval']
-
-    shim.record(nodule, asynchronizers, recordAsynchronizers)
+  instrumentTimerMethods(shim, [timers, global])
+}
 
-    if (!agent.config.feature_flag.async_local_context) {
-      // We don't want to create segments for setImmediate calls, as the
-      // object allocation may incur too much overhead in some situations
-      shim.wrap(nodule, 'setImmediate', wrapSetImmediate)
+/**
+ * Sets up instrumentation for setImmediate on both timers and global.
+ *
+ * We do not want to create segments for setImmediate calls,
+ * as the object allocation may incur too much overhead in some situations
+ *
+ * @param {Shim} shim instance of shim
+ * @param {Array<Timers,global>} pkgs array with references to timers and global
+ */
+function instrumentSetImmediate(shim, pkgs) {
+  pkgs.forEach((nodule) => {
+    if (shim.isWrapped(nodule.setImmediate)) {
+      return
     }
 
-    shim.wrap(nodule, 'clearTimeout', wrapClearTimeout)
+    shim.wrap(nodule, 'setImmediate', function wrapSetImmediate(shim, fn) {
+      return function wrappedSetImmediate() {
+        const segment = shim.getActiveSegment()
+        if (!segment) {
+          return fn.apply(this, arguments)
+        }
 
-    makeWrappedPromisifyCompatible(shim, nodule)
-  }
+        const args = shim.argsToArray.apply(shim, arguments, segment)
+        shim.bindSegment(args, shim.FIRST)
 
-  function wrapSetImmediate(shim, fn) {
-    return function wrappedSetImmediate() {
-      const segment = shim.getActiveSegment()
-      if (!segment) {
-        return fn.apply(this, arguments)
+        return fn.apply(this, args)
       }
+    })
 
-      const args = shim.argsToArray.apply(shim, arguments, segment)
-      shim.bindSegment(args, shim.FIRST)
+    copySymbols(shim, nodule, 'setImmediate')
+  })
+}
 
-      return fn.apply(this, args)
+/**
+ * Sets up instrumentation for setTimeout, setInterval and clearTimeout
+ * on timers and global.
+ *
+ * @param {Shim} shim instance of shim
+ * @param {Array<Timers,global>} pkgs array with references to timers and global
+ */
+function instrumentTimerMethods(shim, pkgs) {
+  pkgs.forEach((nodule) => {
+    if (shim.isWrapped(nodule.setTimeout)) {
+      return
     }
-  }
 
-  function wrapClearTimeout(shim, fn) {
-    return function wrappedClearTimeout(timer) {
-      if (timer && timer._onTimeout) {
-        const segment = timer._onTimeout[symbols.segment]
-        if (segment && !segment.opaque) {
-          segment.ignore = true
-        }
-      }
+    const asynchronizers = ['setTimeout', 'setInterval']
+    shim.record(nodule, asynchronizers, recordAsynchronizers)
+    shim.wrap(nodule, 'clearTimeout', wrapClearTimeout)
+    makeWrappedPromisifyCompatible(shim, nodule)
+  })
+}
 
-      return fn.apply(this, arguments)
+/**
+ * Ignores the segment when clearTimeout is called
+ *
+ * @param {Shim} _shim instance of shim
+ * @param {Function} fn clearTimeout
+ * @returns {Function} wrapped clearTimeout
+ */
+function wrapClearTimeout(_shim, fn) {
+  return function wrappedClearTimeout(timer) {
+    if (timer && timer._onTimeout) {
+      const segment = timer._onTimeout[symbols.segment]
+      if (segment && !segment.opaque) {
+        segment.ignore = true
+      }
     }
-  }
 
-  function recordAsynchronizers(shim, fn, name) {
-    return { name: 'timers.' + name, callback: shim.FIRST }
+    return fn.apply(this, arguments)
   }
 }
 
+/**
+ * Defines the spec for setTimeout and setInterval
+ *
+ * @param {Shim} shim instance of shim
+ * @param {Function} _fn original function
+ * @param {string} name name of function
+ * @returns {object} spec defining how to instrument
+ */
+function recordAsynchronizers(shim, _fn, name) {
+  return { name: 'timers.' + name, callback: shim.FIRST }
+}
+
+/**
+ * Instruments core process methods: nextTick, _nextDomainTick, _tickDomainCallback
+ * Note: This does not get registered when the context manager is async local
+ *
+ * @param {Shim} shim instance of shim
+ * @param {process} process global process object
+ */
 function instrumentProcessMethods(shim, process) {
   const processMethods = ['nextTick', '_nextDomainTick', '_tickDomainCallback']
 
@@ -96,21 +137,27 @@ function instrumentProcessMethods(shim, process) {
   })
 }
 
-function makeWrappedPromisifyCompatible(shim, timers) {
-  const originalSetTimeout = shim.getOriginal(timers.setTimeout)
-  Object.getOwnPropertySymbols(originalSetTimeout).forEach((symbol) => {
-    timers.setTimeout[symbol] = originalSetTimeout[symbol]
-  })
+/**
+ * Copies the symbols from original setTimeout and setInterval onto the wrapped functions
+ *
+ * @param {Shim} shim instance of shim
+ * @param {Timers} nodule Timers class
+ */
+function makeWrappedPromisifyCompatible(shim, nodule) {
+  copySymbols(shim, nodule, 'setTimeout')
+  copySymbols(shim, nodule, 'setInterval')
+}
 
-  const originalSetInterval = shim.getOriginal(timers.setInterval)
-  Object.getOwnPropertySymbols(originalSetInterval).forEach((symbol) => {
-    timers.setInterval[symbol] = originalSetInterval[symbol]
+/**
+ * Helper to copy symbols from original function to wrapped one
+ *
+ * @param {Shim} shim instance of shim
+ * @param {Timers} nodule Timers class
+ * @param {string} name name of function
+ */
+function copySymbols(shim, nodule, name) {
+  const originalFunction = shim.getOriginal(nodule[name])
+  Object.getOwnPropertySymbols(originalFunction).forEach((symbol) => {
+    nodule[name][symbol] = originalFunction[symbol]
   })
-
-  if (!shim.agent.config.feature_flag.async_local_context) {
-    const originalSetImmediate = shim.getOriginal(timers.setImmediate)
-    Object.getOwnPropertySymbols(originalSetImmediate).forEach((symbol) => {
-      timers.setImmediate[symbol] = originalSetImmediate[symbol]
-    })
-  }
 }

package/lib/instrumentation/grpc-js/grpc.js

@@ -12,11 +12,23 @@ const DESTINATION = DESTINATIONS.TRANS_EVENT | DESTINATIONS.ERROR_EVENT
 const semver = require('semver')
 
 module.exports = function instrument(shim) {
-  const genericShim = shim.makeSpecializedShim(shim.GENERIC, 'call-stream')
-  const callStream = genericShim.require('./build/src/call-stream')
-  genericShim.wrap(callStream.Http2CallStream.prototype, 'start', wrapStart)
+  const grpcVersion = shim.require('./package.json').version
+  const genericShim = shim.makeSpecializedShim(shim.GENERIC, 'grpc-client-interceptor')
+
+  if (semver.gte(grpcVersion, '1.8.0')) {
+    const resolvingCall = genericShim.require('./build/src/resolving-call')
+    genericShim.wrap(resolvingCall.ResolvingCall.prototype, 'start', wrapStart)
+  } else {
+    const callStream = genericShim.require('./build/src/call-stream')
+    genericShim.wrap(callStream.Http2CallStream.prototype, 'start', wrapStart)
+  }
 
   const webFrameworkShim = shim.makeSpecializedShim(shim.WEB_FRAMEWORK, 'server')
+  if (semver.lt(grpcVersion, '1.4.0')) {
+    shim.logger.debug('gRPC server-side instrumentation only supported on grpc-js >=1.4.0')
+    return
+  }
+
   const server = webFrameworkShim.require('./build/src/server')
   webFrameworkShim.setFramework('gRPC')
   webFrameworkShim.wrap(server.Server.prototype, 'register', wrapRegister)
@@ -41,9 +53,11 @@ function wrapStart(shim, original) {
 
     const channel = this.channel
     const authorityName = (channel.target && channel.target.path) || channel.getDefaultAuthority
+    // in 1.8.0 this changed from methodName to method
+    const method = this.methodName || this.method
 
     const segment = shim.createSegment({
-      name: `External/${authorityName}${this.methodName}`,
+      name: `External/${authorityName}${method}`,
       opaque: true,
       recorder: recordExternal(authorityName, 'gRPC')
     })
@@ -89,10 +103,10 @@ function wrapStart(shim, original) {
 
         const protocol = 'grpc'
 
-        const url = `${protocol}://${authorityName}${this.methodName}`
+        const url = `${protocol}://${authorityName}${method}`
 
         segment.addAttribute('http.url', url)
-        segment.addAttribute('http.method', this.methodName)
+        segment.addAttribute('http.method', method)
 
         if (originalListener && originalListener.onReceiveStatus) {
           const onReceiveStatuts = shim.bindSegment(originalListener.onReceiveStatus, segment)
@@ -212,20 +226,3 @@ function shouldTrackError(statusCode, config) {
     !config.grpc.ignore_status_codes.includes(statusCode)
   )
 }
-
-module.exports = function instrument(shim) {
-  const genericShim = shim.makeSpecializedShim(shim.GENERIC, 'call-stream')
-  const callStream = genericShim.require('./build/src/call-stream')
-  genericShim.wrap(callStream.Http2CallStream.prototype, 'start', wrapStart)
-
-  const webFrameworkShim = shim.makeSpecializedShim(shim.WEB_FRAMEWORK, 'server')
-  const grpcVersion = shim.require('./package.json').version
-  if (semver.lt(grpcVersion, '1.4.0')) {
-    shim.logger.debug('gRPC server-side instrumentation only supported on grpc-js >=1.4.0')
-    return
-  }
-
-  const server = webFrameworkShim.require('./build/src/server')
-  webFrameworkShim.setFramework('gRPC')
-  webFrameworkShim.wrap(server.Server.prototype, 'register', wrapRegister)
-}