newrelic 8.2.0 → 8.5.1

package/lib/instrumentation/core/http.js

@@ -26,9 +26,6 @@ const DESTS = require('../../config/attribute-filter').DESTINATIONS
  *
  */
 const NR_CONNECTION_PROP = '__NR__connection'
-const NEWRELIC_ID_HEADER = 'x-newrelic-id'
-const NEWRELIC_APP_DATA_HEADER = 'x-newrelic-app-data'
-const NEWRELIC_TRANSACTION_HEADER = 'x-newrelic-transaction'
 const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
 const TRANSACTION_INFO_KEY = '__NR_transactionInfo'
 
@@ -47,7 +44,7 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
   let serverPort = null
 
   return tracer.transactionProxy(function wrappedHandler(evnt, request, response) {
-    var transaction = tracer.getTransaction()
+    const transaction = tracer.getTransaction()
     if (!transaction) {
       return emit.apply(this, arguments)
     }
@@ -108,7 +105,7 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
 
     // store the port on which this transaction runs
     if (this.address instanceof Function) {
-      var address = this.address()
+      const address = this.address()
       if (address) {
         serverPort = address.port
       }
@@ -142,15 +139,13 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
       // Node http headers are automatically lowercase
       transaction.acceptDistributedTraceHeaders(transport, request.headers)
     } else if (agent.config.cross_application_tracer.enabled) {
-      const incomingCatId = request.headers[NEWRELIC_ID_HEADER]
-      const obfTransaction = request.headers[NEWRELIC_TRANSACTION_HEADER]
-
-      if (agent.config.encoding_key) {
-        cat.handleCatHeaders(incomingCatId, obfTransaction, agent.config.encoding_key, transaction)
-        if (transaction.incomingCatId) {
-          logger.trace('Got inbound request CAT headers in transaction %s', transaction.id)
-        }
-      }
+      const { id, transactionId } = cat.extractCatHeaders(request.headers)
+      const { externalId, externalTransaction } = cat.parseCatData(
+        id,
+        transactionId,
+        agent.config.encoding_key
+      )
+      cat.assignCatToTransaction(externalId, externalTransaction, transaction)
     }
 
     function instrumentedFinish() {
@@ -164,7 +159,7 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
 
       if (response) {
         if (response.statusCode != null) {
-          var responseCode = String(response.statusCode)
+          const responseCode = String(response.statusCode)
 
           if (/^\d+$/.test(responseCode)) {
             transaction.trace.attributes.addAttribute(
@@ -187,7 +182,7 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
           segment.addSpanAttribute('http.statusText', response.statusMessage)
         }
 
-        var headers = response.getHeaders()
+        const headers = response.getHeaders()
         if (headers) {
           headerAttributes.collectResponseHeaders(headers, transaction)
         }
@@ -209,9 +204,9 @@ function storeTxInfo(transaction, request, response) {
     logger.debug('Missing request or response object! Not storing transaction info.')
     return
   }
-  var hideInternal = transaction.agent.config.transaction_tracer.hide_internals
+  const hideInternal = transaction.agent.config.transaction_tracer.hide_internals
 
-  var txInfo = {
+  const txInfo = {
     transaction: transaction,
     segmentStack: [],
     errorHandled: false,
@@ -239,7 +234,7 @@ function initializeRequest(transaction, request) {
 }
 
 function wrapResponseEnd(agent, proto) {
-  var tracer = agent.tracer
+  const tracer = agent.tracer
 
   // On end, we must freeze the current name state to maintain the route that
   // responded and also end the current segment (otherwise it may become truncated).
@@ -250,7 +245,7 @@ function wrapResponseEnd(agent, proto) {
     }
 
     return function wrappedResEnd() {
-      var txInfo = this && this[TRANSACTION_INFO_KEY]
+      const txInfo = this && this[TRANSACTION_INFO_KEY]
       if (!txInfo) {
         return end.apply(this, arguments)
       }
@@ -268,10 +263,10 @@ function wrapResponseEnd(agent, proto) {
       }
 
       // End all the segments leading up to and including this one.
-      for (var i = txInfo.segmentStack.length - 1; i >= 0; --i) {
+      for (let i = txInfo.segmentStack.length - 1; i >= 0; --i) {
         txInfo.segmentStack[i].end()
       }
-      var segment = tracer.getSegment()
+      const segment = tracer.getSegment()
       if (segment) {
         segment.end()
       }
@@ -288,7 +283,7 @@ function wrapResponseEnd(agent, proto) {
 // the shimmer stuff if you'd like to verify.
 function wrapWriteHead(agent, writeHead) {
   return function wrappedWriteHead() {
-    var transaction = agent.tracer.getTransaction()
+    const transaction = agent.tracer.getTransaction()
     if (!transaction) {
       logger.trace('No transaction - not adding response CAT headers')
       return writeHead.apply(this, arguments)
@@ -307,13 +302,7 @@ function wrapWriteHead(agent, writeHead) {
       return writeHead.apply(this, arguments)
     }
 
-    var accountId = transaction.incomingCatId.split('#')[0]
-    accountId = parseInt(accountId, 10)
-    if (agent.config.trusted_account_ids.indexOf(accountId) === -1) {
-      logger.trace(
-        'Request from untrusted account id: %s - not adding response CAT headers',
-        accountId
-      )
+    if (!cat.isTrustedAccountId(transaction.incomingCatId, agent.config.trusted_account_ids)) {
       return writeHead.apply(this, arguments)
     }
 
@@ -332,8 +321,8 @@ function wrapWriteHead(agent, writeHead) {
 
     // -1 means no content length header was sent. We should only send this
     // value in the appData if the header is set.
-    var contentLength = -1
-    var newHeaders = arguments[arguments.length - 1]
+    let contentLength = -1
+    const newHeaders = arguments[arguments.length - 1]
 
     if (typeof newHeaders === 'object') {
       contentLength = headerProcessing.getContentLengthFromHeaders(newHeaders)
@@ -347,33 +336,11 @@ function wrapWriteHead(agent, writeHead) {
     // actual duration.
     transaction.catResponseTime = transaction.timer.getDurationInMillis()
 
-    var appData = null
-    var txName = transaction.getFullName() || ''
-
-    try {
-      appData = JSON.stringify([
-        agent.config.cross_process_id, // cross_process_id
-        txName, // transaction name
-        transaction.queueTime / 1000, // queue time (s)
-        transaction.catResponseTime / 1000, // response time (s)
-        contentLength, // content length (if content-length header is also being sent)
-        transaction.id, // TransactionGuid
-        false // force a transaction trace to be recorded
-      ])
-    } catch (err) {
-      logger.trace(
-        err,
-        'Failed to serialize transaction: %s - not adding CAT response headers',
-        txName
-      )
-      return writeHead.apply(this, arguments)
+    const { key, data } = cat.encodeAppData(agent.config, transaction, contentLength)
+    if (key && data) {
+      this.setHeader(key, data)
+      logger.trace('Added outbound response CAT headers in transaction %s', transaction.id)
     }
-
-    var encKey = agent.config.encoding_key
-    var obfAppData = hashes.obfuscateNameUsingKey(appData, encKey)
-    this.setHeader(NEWRELIC_APP_DATA_HEADER, obfAppData)
-    logger.trace('Added outbound response CAT headers in transaction %s', transaction.id)
-
     return writeHead.apply(this, arguments)
   }
 }
@@ -423,7 +390,7 @@ function wrapRequest(agent, request) {
       options = Object.assign(input || {}, options)
     }
 
-    let reqArgs = [options, cb]
+    const reqArgs = [options, cb]
 
     // Don't pollute metrics and calls with NR connections
     const internalOnly = options && options[NR_CONNECTION_PROP]
@@ -480,7 +447,7 @@ module.exports = function initialize(agent, http, moduleName) {
     'http.Server.prototype',
     'emit',
     function wrapEmit(emit) {
-      var txStarter = wrapEmitWithTransaction(agent, emit, IS_HTTPS)
+      const txStarter = wrapEmitWithTransaction(agent, emit, IS_HTTPS)
       return function wrappedEmit(evnt) {
         if (evnt === 'request') {
           return txStarter.apply(this, arguments)
@@ -502,7 +469,7 @@ module.exports = function initialize(agent, http, moduleName) {
     )
   }
 
-  var agentProto = http && http.Agent && http.Agent.prototype
+  const agentProto = http && http.Agent && http.Agent.prototype
 
   shimmer.wrapMethod(http, 'http', 'request', wrapRequest.bind(null, agent))
 
@@ -518,14 +485,14 @@ module.exports = function initialize(agent, http, moduleName) {
           return original.apply(this, arguments)
         }
 
-        var segment = agent.tracer.createSegment('http.Agent#createConnection')
+        const segment = agent.tracer.createSegment('http.Agent#createConnection')
 
-        var args = agent.tracer.slice(arguments)
+        const args = agent.tracer.slice(arguments)
         if (typeof args[1] === 'function') {
           args[1] = agent.tracer.bindFunction(args[1], segment, true)
         }
 
-        var sock = agent.tracer.bindFunction(original, segment, true).apply(this, args)
+        const sock = agent.tracer.bindFunction(original, segment, true).apply(this, args)
         return sock
       }
     }
@@ -543,7 +510,7 @@ module.exports = function initialize(agent, http, moduleName) {
  * @param {Transaction} transaction - Where the synthetics data is attached to.
  */
 function handleSyntheticsHeader(header, encKey, trustedIds, transaction) {
-  var synthData = parseSyntheticsHeader(header, encKey, trustedIds)
+  const synthData = parseSyntheticsHeader(header, encKey, trustedIds)
   if (!synthData) {
     return
   }
@@ -565,14 +532,14 @@ function handleSyntheticsHeader(header, encKey, trustedIds, transaction) {
 function parseSyntheticsHeader(header, encKey, trustedIds) {
   // Eagerly declare this object because we know what it should look like and
   // can use that for header verification.
-  var parsedData = {
+  const parsedData = {
     version: null,
     accountId: null,
     resourceId: null,
     jobId: null,
     monitorId: null
   }
-  var synthData = null
+  let synthData = null
   try {
     synthData = JSON.parse(hashes.deobfuscateNameUsingKey(header, encKey))
   } catch (e) {

package/lib/instrumentation/core/inspector.js

@@ -8,14 +8,14 @@
 module.exports = initialize
 
 function initialize(agent, inspector, name, shim) {
-  var sessionProto = inspector && inspector.Session && inspector.Session.prototype
+  const sessionProto = inspector && inspector.Session && inspector.Session.prototype
   if (!sessionProto) {
     return false
   }
 
   shim.wrap(sessionProto, 'post', function wrapPost(shim, fn) {
     return function wrappedPost() {
-      var args = shim.argsToArray.apply(shim, arguments)
+      const args = shim.argsToArray.apply(shim, arguments)
       shim.bindCallbackSegment(args, shim.LAST)
       return fn.apply(this, args)
     }

package/lib/instrumentation/core/timers.js

@@ -18,9 +18,9 @@ function initialize(agent, timers, moduleName, shim) {
       }
 
       // Manual copy because helper methods add significant overhead in some usages
-      var len = arguments.length
-      var args = new Array(len)
-      for (var i = 0; i < len; ++i) {
+      const len = arguments.length
+      const args = new Array(len)
+      for (let i = 0; i < len; ++i) {
         args[i] = arguments[i]
       }
 
@@ -70,7 +70,7 @@ function initialize(agent, timers, moduleName, shim) {
     return function wrappedClearTimeout(timer) {
       if (timer && timer._onTimeout) {
         const segment = timer._onTimeout.__NR_segment
-        if (segment) {
+        if (segment && !segment.opaque) {
           segment.ignore = true
         }
       }
@@ -85,9 +85,9 @@ function initialize(agent, timers, moduleName, shim) {
 }
 
 function makeWrappedPromisifyCompatible(shim, timers) {
-  const originalSetTimout = shim.getOriginal(timers.setTimeout)
-  Object.getOwnPropertySymbols(originalSetTimout).forEach((symbol) => {
-    timers.setTimeout[symbol] = originalSetTimout[symbol]
+  const originalSetTimeout = shim.getOriginal(timers.setTimeout)
+  Object.getOwnPropertySymbols(originalSetTimeout).forEach((symbol) => {
+    timers.setTimeout[symbol] = originalSetTimeout[symbol]
   })
 
   const originalSetInterval = shim.getOriginal(timers.setInterval)

package/lib/instrumentation/core/zlib.js

@@ -9,13 +9,13 @@ const recorder = require('../../metrics/recorders/generic')
 
 module.exports = initialize
 
-var methods = ['deflate', 'deflateRaw', 'gzip', 'gunzip', 'inflate', 'inflateRaw', 'unzip']
+const methods = ['deflate', 'deflateRaw', 'gzip', 'gunzip', 'inflate', 'inflateRaw', 'unzip']
 
 function initialize(agent, zlib, moduleName, shim) {
   shim.record(zlib, methods, recordZLib)
 
   if (zlib.Deflate && zlib.Deflate.prototype) {
-    var proto = Object.getPrototypeOf(zlib.Deflate.prototype)
+    const proto = Object.getPrototypeOf(zlib.Deflate.prototype)
     if (proto._transform) {
       // streams2
       shim.wrap(proto, '_transform', wrapNoSegment)

package/lib/instrumentation/director.js

@@ -12,8 +12,8 @@ module.exports = function initialize(agent, director, moduleName, shim) {
     return route instanceof Array ? route.join('/') : route
   })
 
-  var methods = ['on', 'route']
-  var proto = director.Router.prototype
+  const methods = ['on', 'route']
+  const proto = director.Router.prototype
   shim.wrapMiddlewareMounter(proto, methods, {
     route: shim.SECOND,
     wrapper: function wrapMiddleware(shim, middleware, name, path) {
@@ -32,7 +32,7 @@ module.exports = function initialize(agent, director, moduleName, shim) {
 
   shim.wrap(proto, 'mount', function wrapMount(shim, mount) {
     return function wrappedMount(routes, path) {
-      var isAsync = this.async
+      const isAsync = this.async
       shim.wrap(routes, director.http.methods, function wrapRoute(shim, route) {
         return shim.recordMiddleware(route, {
           route: path.join('/'),
@@ -45,7 +45,7 @@ module.exports = function initialize(agent, director, moduleName, shim) {
           next: isAsync ? shim.LAST : null
         })
       })
-      var args = [routes, path]
+      const args = [routes, path]
       return mount.apply(this, args)
     }
   })

package/lib/instrumentation/express.js

@@ -48,7 +48,7 @@ function wrapExpress4(shim, express) {
     }
 
     return function wrappedRoute() {
-      var route = fn.apply(this, arguments)
+      const route = fn.apply(this, arguments)
 
       // Express should create a new route and layer every time Router#route is
       // called, but just to be on the safe side, make sure we haven't wrapped
@@ -56,7 +56,7 @@ function wrapExpress4(shim, express) {
       if (!shim.isWrapped(route, 'get')) {
         wrapRouteMethods(shim, route, '')
 
-        var layer = this.stack[this.stack.length - 1]
+        const layer = this.stack[this.stack.length - 1]
 
         // This wraps a 'done' function but not a traditional 'next' function. This allows
         // the route to stay on the stack for middleware nesting after the router.
@@ -120,7 +120,7 @@ function wrapExpress3(shim, express) {
 }
 
 function wrapRouteMethods(shim, route, path) {
-  var methods = ['all', 'delete', 'get', 'head', 'opts', 'post', 'put', 'patch']
+  const methods = ['all', 'delete', 'get', 'head', 'opts', 'post', 'put', 'patch']
   shim.wrapMiddlewareMounter(route, methods, { route: path, wrapper: wrapMiddleware })
 }
 
@@ -128,13 +128,13 @@ function wrapResponse(shim, response) {
   shim.recordRender(response, 'render', {
     view: shim.FIRST,
     callback: function bindCallback(shim, render, name, segment, args) {
-      var cbIdx = shim.normalizeIndex(args.length, shim.LAST)
+      let cbIdx = shim.normalizeIndex(args.length, shim.LAST)
       if (cbIdx === null) {
         return
       }
 
-      var res = this
-      var cb = args[cbIdx]
+      const res = this
+      let cb = args[cbIdx]
       if (!shim.isFunction(cb)) {
         ++cbIdx
         cb = function defaultRenderCB(err, str) {
@@ -152,8 +152,8 @@ function wrapResponse(shim, response) {
 }
 
 function wrapMiddleware(shim, middleware, name, route) {
-  var method = null
-  var spec = {
+  let method = null
+  const spec = {
     route: route,
     type: shim.MIDDLEWARE,
     matchArity: true,

package/lib/instrumentation/fastify/spec-builders.js

@@ -1,19 +1,43 @@
 /*
- * Copyright 2020 New Relic Corporation. All rights reserved.
+ * Copyright 2021 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
 'use strict'
 
-const getRawRequestFromFastifyRequest = (shim, fn, fnName, args) => {
-  const request = args[0]
+/**
+ * Retrieves the IncomingMessage from a Fastify request.  Depending on the
+ * context of this function it either exists on `request.raw` or just `request`
+ *
+ * @param {WebFrameworkShim} shim
+ * @param {Function} fn middleware function executing
+ * @param {string} fnName name of middleware executing
+ * @param {args} args that are passed to middleware
+ * @returns {IncomingMessage}
+ */
+const getRequestFromFastify = (shim, fn, fnName, args) => {
+  const [request] = args
+
+  // request is Fastify request
+  // object, get IncomingMessage from .raw
   if (request && request.raw) {
     return request.raw
   }
+
+  return request
 }
 
+/**
+ * Retrieves the params from the Fastify request.
+ *
+ * @param {WebFrameworkShim} shim
+ * @param {Function} fn middleware function executing
+ * @param {string} fnName name of middleware executing
+ * @param {args} args that are passed to middleware
+ * @returns {object} URL params on a Fastify request
+ */
 const getParamsFromFastifyRequest = (shim, fn, fnName, args) => {
-  const req = args[0]
+  const [req] = args
   return req && req.params
 }
 
@@ -21,32 +45,17 @@ const getParamsFromFastifyRequest = (shim, fn, fnName, args) => {
  * Builds the recordMiddleware Spec for the route handler
  *
  * A spec is basically a specification -- or a list
- * of insrtuctions to the recordMiddleware function
+ * of instructions to the recordMiddleware function
  * that provide it with the information it needs to
  * do its job.  You could also think of it as a
  * mini-DSL
+ *
+ * @param {WebFrameworkShim} shim
+ * @param {string} path URL route being executed
+ * @returns {object} spec for Fastify route handler
  */
 function buildMiddlewareSpecForRouteHandler(shim, path) {
   return {
-    /**
-     * The path to use for transaction naming
-     */
-    route: path,
-
-    /**
-     * A function the returns the NodeJS Request Object
-     *
-     * The job of the `req` callback is to return the current NodeJS
-     * IncomingMessage object for this particular handler.  Most NodeJS
-     * frameworks will pass the request to each handler -- sometimes (as
-     * is the case here) wrapped by another object.
-     *
-     * @param {any} shim the Webframework Shim
-     * @param {any} fn the handler function passed to buildMiddlewareSpec
-     * @param {any} fnName the handler function's name
-     * @param {any} args the arguments passed to the handler function
-     */
-    req: getRawRequestFromFastifyRequest,
     /**
      * A function where we can wrap next, reply send, etc. methods
      *
@@ -66,6 +75,12 @@ function buildMiddlewareSpecForRouteHandler(shim, path) {
      * The isFinal param determines whether or not a path is appended for
      * this particular piece of middleware. (i.e. if this is the final handler
      * that is actually handling the request, the path is actually left on)
+     *
+     * @param shim
+     * @param fn
+     * @param fnName
+     * @param args
+     * @param bindSegment
      */
     next: function wrapNext(shim, fn, fnName, args, bindSegment) {
       const reply = args[1]
@@ -75,33 +90,28 @@ function buildMiddlewareSpecForRouteHandler(shim, path) {
       const isFinal = true
       bindSegment(reply, 'send', isFinal)
     },
-
-    /**
-     * A function that returns the request paramates
-     *
-     * @param {any} shim the Webframework Shim
-     * @param {any} fn the handler function passed to buildMiddlewareSpec
-     * @param {any} fnName the handler function's name
-     * @param {any} args the arguments passed to the handler function
-     */
-    params: getParamsFromFastifyRequest
+    params: getParamsFromFastifyRequest,
+    req: getRequestFromFastify,
+    route: path
   }
 }
 
-function buildMiddlewareSpecForMiddlewareFunction() {
+/**
+ * Spec for all Fastify middleware(excluding route handlers)
+ *
+ * @param {WebFrameworkShim} shim
+ * @param {string} name metric name for middleware being executed
+ * @param route
+ * @returns {object} spec for Fastify middleware
+ */
+function buildMiddlewareSpecForMiddlewareFunction(shim, name, route) {
   return {
-    req: getRawRequestFromFastifyRequest,
-
-    next: function wrapNext(shim, fn, fnName, args, bindSegment) {
-      const next = args[2]
-      if (!shim.isFunction(next)) {
-        return
-      }
-      const isFinal = false
-      bindSegment(next, null, isFinal)
-    },
-
-    params: getParamsFromFastifyRequest
+    name,
+    route,
+    next: shim.LAST,
+    params: getParamsFromFastifyRequest,
+    req: getRequestFromFastify,
+    type: shim.MIDDLEWARE
   }
 }