newrelic 8.3.0 → 8.5.2

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
   }
 }
 

package/lib/instrumentation/fastify.js

@@ -4,11 +4,33 @@
  */
 
 'use strict'
+
 const semver = require('semver')
 const {
   buildMiddlewareSpecForRouteHandler,
   buildMiddlewareSpecForMiddlewareFunction
 } = require('./fastify/spec-builders')
+
+/**
+ * These are the events that occur during a fastify
+ * request
+ * see: https://www.fastify.io/docs/latest/Lifecycle/
+ *
+ * Note: preSerialization and onSend happen after the route handler
+ * executes.  `onResponse` does not execute until after the client
+ * sends the response so it'll never be in scope of the transaction
+ */
+const REQUEST_HOOKS = [
+  'onRequest',
+  'preParsing',
+  'preValidation',
+  'preHandler',
+  'preSerialization',
+  'onSend',
+  'onResponse',
+  'onError'
+]
+
 /**
  * Sets up fastify route handler
  *
@@ -20,6 +42,9 @@ const {
  * those private implementations from access, and getting
  * at them would require a lot of gymnastics and hard to
  * maintain code
+ *
+ * @param shim
+ * @param fastify
  */
 const setupRouteHandler = (shim, fastify) => {
   fastify.addHook('onRoute', (routeOptions) => {
@@ -27,10 +52,10 @@ const setupRouteHandler = (shim, fastify) => {
       return
     }
     /**
-     * recordMiddlware handler call
+     * recordMiddleware handler call
      *
      * The WebFramework shim treats the main route handler like any other
-     * i.e. dont be confused by the call to recordMiddlware -- we don't
+     * i.e. dont be confused by the call to recordMiddleware -- we don't
      * have a recordRouteHandler, everything goes through recordMiddleware
      */
     const newRouteHandler = shim.recordMiddleware(
@@ -40,29 +65,25 @@ const setupRouteHandler = (shim, fastify) => {
 
     routeOptions.handler = newRouteHandler
   })
-}
 
-const setupMiddlewareHandlers = (shim, fastify) => {
-  shim.wrap(fastify, 'use', function wrapFastifyUse(shim, fn) {
-    return function wrappedFastifyUser() {
+  shim.wrap(fastify, 'addHook', function addWrapHook(shim, fn) {
+    return function wrappedAddHook() {
       const args = shim.argsToArray.apply(shim, arguments)
-      const middlewareFunction = args[0]
-      const newMiddlewareFunction = shim.recordMiddleware(
-        middlewareFunction,
-        buildMiddlewareSpecForMiddlewareFunction(shim)
-      )
-      // replace original function with our function
-      args[0] = newMiddlewareFunction
+      const hookName = args[0]
+      if (REQUEST_HOOKS.includes(hookName)) {
+        const middlewareFunction = args[1]
+        const name = `${hookName}/${shim.getName(middlewareFunction)}`
+        const middlewareSpec = buildMiddlewareSpecForMiddlewareFunction(shim, name)
+        const newMiddlewareFunction = shim.recordMiddleware(middlewareFunction, middlewareSpec)
 
+        args[1] = newMiddlewareFunction
+      }
       return fn.apply(this, args)
     }
   })
 }
 
 module.exports = function initialize(agent, fastify, moduleName, shim) {
-  if (!agent.config.feature_flag.fastify_instrumentation) {
-    return
-  }
   shim.setFramework(shim.FASTIFY)
 
   const fastifyVersion = shim.require('./package.json').version
@@ -73,18 +94,12 @@ module.exports = function initialize(agent, fastify, moduleName, shim) {
    */
   const wrappedExport = shim.wrapExport(fastify, function wrapFastifyModule(shim, fn) {
     return function wrappedFastifyModule() {
-      // normalize arguments
-      const args = shim.argsToArray.apply(shim, arguments)
-
       // call original function get get fastify object (which is singleton-ish)
-      const fastifyForWrapping = fn.apply(this, args)
+      const fastifyForWrapping = fn.apply(this, arguments)
 
       setupRouteHandler(shim, fastifyForWrapping)
 
-      // Don't wrap use() in fastify v3+
-      if (!isv3Plus) {
-        setupMiddlewareHandlers(shim, fastifyForWrapping)
-      }
+      setupMiddlewareHandlers(shim, fastifyForWrapping, isv3Plus)
 
       return fastifyForWrapping
     }
@@ -95,10 +110,56 @@ module.exports = function initialize(agent, fastify, moduleName, shim) {
   }
 }
 
+function setupMiddlewareHandlers(shim, fastify, isv3Plus) {
+  const mounterSpec = {
+    route: shim.FIRST,
+    wrapper: wrapMiddleware
+  }
+
+  if (isv3Plus) {
+    // Fastify v3+ does not ship with traditional Node.js middleware mounting.
+    // This style is accomplished leveraging decorators. Both middie (which was built-in in v2)
+    // and fastify-express mount a 'use' function for mounting middleware.
+    shim.wrap(fastify, 'decorate', function wrapDecorate(shim, fn) {
+      return function wrappedDecorate() {
+        const name = arguments[0]
+        if (name !== 'use') {
+          return fn.apply(this, arguments)
+        }
+
+        const args = shim.argsToArray.apply(shim, arguments)
+        args[1] = shim.wrapMiddlewareMounter(args[1], mounterSpec)
+
+        return fn.apply(this, args)
+      }
+    })
+  } else {
+    shim.wrapMiddlewareMounter(fastify, 'use', mounterSpec)
+  }
+}
+
+function wrapMiddleware(shim, middleware, name, route) {
+  if (shim.isWrapped(middleware)) {
+    return middleware
+  }
+
+  // prefixing the segment name for middleware execution
+  // with the Fastify lifecycle hook
+  const segmentName = `onRequest/${name}`
+  const spec = buildMiddlewareSpecForMiddlewareFunction(shim, segmentName, route)
+
+  const newMiddlewareFunction = shim.recordMiddleware(middleware, spec)
+
+  return newMiddlewareFunction
+}
+
 /**
  * module.exports = fastify
  * module.exports.fastify = fastify
  * module.exports.default = fastify
+ *
+ * @param original
+ * @param wrappedExport
  */
 function setupExports(original, wrappedExport) {
   wrappedExport.fastify = original.fastify

package/lib/instrumentation/generic-pool.js

@@ -10,7 +10,7 @@ module.exports = function initialize(agent, generic, moduleName, shim) {
     return false
   }
 
-  var proto = generic.Pool.prototype
+  const proto = generic.Pool.prototype
   shim.wrap(proto, 'acquire', function wrapAcquire(shim, acquire) {
     if (!shim.isFunction(acquire)) {
       return acquire

package/lib/instrumentation/hapi/hapi-17.js

@@ -28,7 +28,7 @@ function serverFactoryWrapper(shim, fn, fnName, server) {
 }
 
 function serverPostConstructor(shim) {
-  var proto = Object.getPrototypeOf(this)
+  const proto = Object.getPrototypeOf(this)
 
   if (shim.isWrapped(proto.decorate)) {
     shim.logger.trace('Already wrapped Server proto, not wrapping again')
@@ -44,7 +44,7 @@ function serverPostConstructor(shim) {
       }
 
       // Convert arguments to usable array
-      var args = shim.argsToArray.apply(shim, arguments)
+      const args = shim.argsToArray.apply(shim, arguments)
 
       // Wrap the third server.decorate arg, the user-defined handler
       shim.wrap(args, shim.THIRD, function wrapHandler(shim, fn) {
@@ -59,7 +59,7 @@ function serverPostConstructor(shim) {
         return wrappedHandler
 
         function wrappedHandler(route) {
-          var ret = fn.apply(this, arguments)
+          const ret = fn.apply(this, arguments)
 
           return typeof ret === 'function' ? wrapRouteHandler(shim, ret, route && route.path) : ret
         }
@@ -71,7 +71,7 @@ function serverPostConstructor(shim) {
 
   shim.wrap(proto, 'route', function wrapRoute(shim, original) {
     return function wrappedRoute() {
-      var args = shim.argsToArray.apply(shim, arguments)
+      const args = shim.argsToArray.apply(shim, arguments)
 
       if (!shim.isObject(args[0])) {
         return original.apply(this, args)
@@ -92,7 +92,7 @@ function serverPostConstructor(shim) {
       function _wrapRoute(shim, route) {
         const routePath = prefix + route.path
         if (shim.isArray(route)) {
-          for (var i = 0; i < route.length; ++i) {
+          for (let i = 0; i < route.length; ++i) {
             _wrapRoute(shim, route[i])
           }
           return
@@ -132,10 +132,10 @@ function serverPostConstructor(shim) {
 
   shim.wrap(proto, 'ext', function wrapExt(shim, original) {
     return function wrappedExt(event, method) {
-      var args = shim.argsToArray.apply(shim, arguments)
+      const args = shim.argsToArray.apply(shim, arguments)
 
       if (shim.isArray(event)) {
-        for (var i = 0; i < event.length; i++) {
+        for (let i = 0; i < event.length; i++) {
           event[i].method = wrapMiddleware(shim, event[i].method, event[i].type)
         }
       } else if (shim.isObject(event)) {
@@ -154,7 +154,7 @@ function serverPostConstructor(shim) {
 
 function wrapPreHandlers(shim, container, path) {
   if (shim.isArray(container)) {
-    for (var i = 0; i < container.length; ++i) {
+    for (let i = 0; i < container.length; ++i) {
       container[i] = wrapPreHandlers(shim, container[i], path)
     }
     return container
@@ -177,14 +177,14 @@ function wrapRouteHandler(shim, handler, path) {
   return shim.recordMiddleware(handler, {
     route: path,
     req: function getReq(shim, fn, fnName, args) {
-      var request = args[0]
+      const request = args[0]
       if (request && request.raw) {
         return request.raw.req
       }
     },
     promise: true,
     params: function getParams(shim, fn, fnName, args) {
-      var req = args[0]
+      const req = args[0]
       return req && req.params
     }
   })
@@ -200,7 +200,7 @@ function wrapMiddleware(shim, middleware, event) {
     type: event === 'onPreResponse' ? shim.ERRORWARE : shim.MIDDLEWARE,
     promise: true,
     req: function getReq(shim, fn, fnName, args) {
-      var req = args[0]
+      const req = args[0]
       return req && req.raw && req.raw.req
     }
   })

package/lib/instrumentation/hapi/shared.js

@@ -7,7 +7,7 @@
 
 // This object defines all the events that we want to wrap extensions
 // for, as they are the only ones associated with requests.
-var ROUTE_EVENTS = {
+const ROUTE_EVENTS = {
   onRequest: true,
   onPreAuth: true,
   onCredentials: true,

package/lib/instrumentation/hapi.js

@@ -5,7 +5,7 @@
 
 'use strict'
 
-var shared = require('./hapi/shared')
+const shared = require('./hapi/shared')
 
 module.exports = function initialize(agent, hapi, moduleName, shim) {
   if (!agent || !hapi || !shim) {
@@ -32,7 +32,7 @@ module.exports = function initialize(agent, hapi, moduleName, shim) {
 
     // See if we can find the plugin class. This should be the super class of
     // Server and will cover more scenarios.
-    var Plugin = hapi.Server.super_
+    const Plugin = hapi.Server.super_
     if (_isPluginClass(Plugin)) {
       wrapServer(shim, Plugin)
     } else {
@@ -46,9 +46,9 @@ function wrapServer(shim, Server) {
   // the second argument is expected to be a function that generates the handler function
   shim.wrap(Server.prototype, 'handler', function wrapHandler(shim, original) {
     return function wrappedHandler() {
-      var args = shim.argsToArray.apply(shim, arguments)
+      const args = shim.argsToArray.apply(shim, arguments)
 
-      var handlerGenerator = args[1]
+      const handlerGenerator = args[1]
       if (typeof handlerGenerator === 'function') {
         args[1] = wrapGenerator(handlerGenerator)
       }
@@ -57,10 +57,10 @@ function wrapServer(shim, Server) {
 
       function wrapGenerator(generator) {
         function wrappedGenerator() {
-          var generatorArgs = shim.argsToArray.apply(shim, arguments)
-          var handler = generator.apply(this, generatorArgs)
+          const generatorArgs = shim.argsToArray.apply(shim, arguments)
+          const handler = generator.apply(this, generatorArgs)
           if (typeof handler === 'function') {
-            var route = generatorArgs[0]
+            const route = generatorArgs[0]
             return wrapRouteHandler(shim, handler, route && route.path)
           }
           return handler
@@ -75,7 +75,7 @@ function wrapServer(shim, Server) {
 
   shim.wrap(Server.prototype, 'route', function wrapRoute(shim, original) {
     return function wrappedRoute() {
-      var args = shim.argsToArray.apply(shim, arguments)
+      const args = shim.argsToArray.apply(shim, arguments)
 
       // first argument is expected to be the route configuration object
       if (!shim.isObject(args[0])) {
@@ -98,7 +98,7 @@ function wrapServer(shim, Server) {
         const routePath = prefix + route.path
         // handler function could be on the route object, or on a nested config object
         if (shim.isArray(route)) {
-          for (var i = 0; i < route.length; ++i) {
+          for (let i = 0; i < route.length; ++i) {
             _wrapRoute(shim, route[i])
           }
           return
@@ -119,10 +119,10 @@ function wrapServer(shim, Server) {
 
   shim.wrap(Server.prototype, 'ext', function wrapExt(shim, original) {
     return function wrappedExt(event, method) {
-      var args = shim.argsToArray.apply(shim, arguments)
+      const args = shim.argsToArray.apply(shim, arguments)
 
       if (shim.isArray(event)) {
-        for (var i = 0; i < event.length; i++) {
+        for (let i = 0; i < event.length; i++) {
           event[i].method = wrapMiddleware(shim, event[i].method, event[i].type)
         }
       } else if (shim.isObject(event)) {
@@ -142,7 +142,7 @@ function wrapServer(shim, Server) {
 function wrapCreateServer(shim, hapi) {
   shim.wrap(hapi, 'createServer', function getWrapper(shim, createServer) {
     return function createServerWrapper() {
-      var server = createServer.apply(this, arguments)
+      const server = createServer.apply(this, arguments)
       wrapServer(shim, server.constructor)
       shim.unwrap(hapi, 'createServer')
       return server
@@ -152,7 +152,7 @@ function wrapCreateServer(shim, hapi) {
 
 function wrapPreHandlers(shim, container, path) {
   if (shim.isArray(container)) {
-    for (var i = 0; i < container.length; ++i) {
+    for (let i = 0; i < container.length; ++i) {
       container[i] = wrapPreHandlers(shim, container[i], path)
     }
     return container
@@ -194,20 +194,20 @@ function buildMiddlewareSpec(shim, path, isPreHandler) {
   return {
     route: path,
     req: function getReq(shim, fn, fnName, args) {
-      var request = args[0]
+      const request = args[0]
       if (request && request.raw) {
         return request.raw.req
       }
     },
     next: function wrapNext(shim, fn, fnName, args, wrap) {
-      var reply = args[1]
+      const reply = args[1]
       if (!shim.isFunction(reply)) {
         return
       }
       wrapReply(wrap, reply, isPreHandler)
     },
     params: function getParams(shim, fn, fnName, args) {
-      var req = args[0]
+      const req = args[0]
       return req && req.params
     }
   }
@@ -216,7 +216,7 @@ function buildMiddlewareSpec(shim, path, isPreHandler) {
 function wrapHapiHandler(shim, handler) {
   return shim.wrap(handler, function wrapHandler(shim, original) {
     return function wrapped() {
-      var reply = arguments[1]
+      const reply = arguments[1]
       if (reply) {
         shim.recordRender(reply, 'view')
       }
@@ -230,18 +230,18 @@ function wrapMiddleware(shim, middleware, event) {
     return middleware
   }
 
-  var spec = {
+  const spec = {
     route: event,
     type: event === 'onPreResponse' ? shim.ERRORWARE : shim.MIDDLEWARE,
     next: function wrapNext(shim, fn, fnName, args, wrap) {
-      var reply = args[1]
+      const reply = args[1]
       if (!reply || !shim.isFunction(reply.continue)) {
         return
       }
       wrap(reply, 'continue')
     },
     req: function getReq(shim, fn, fnName, args) {
-      var request = args[0]
+      const request = args[0]
       if (request && request.raw) {
         return request.raw.req
       }
@@ -256,7 +256,7 @@ function _isPluginClass(Plugin) {
     return false
   }
 
-  var proto = Plugin.prototype
+  const proto = Plugin.prototype
   return (
     typeof proto.handler === 'function' &&
     typeof proto.route === 'function' &&
@@ -265,7 +265,7 @@ function _isPluginClass(Plugin) {
 }
 
 function wrapReply(wrap, reply, isPreHandler) {
-  var isFinal = !isPreHandler
+  const isFinal = !isPreHandler
   // The only reply method that is actually used by pre-handlers is `response`. All
   // other methods still exist, but don't function as they do in normal route handlers.
   // Since they can still be referenced by users, they still need to be wrapped.

package/lib/instrumentation/ioredis.js

@@ -5,11 +5,11 @@
 
 'use strict'
 
-var stringify = require('json-stringify-safe')
-var urltils = require('../util/urltils.js')
+const stringify = require('json-stringify-safe')
+const urltils = require('../util/urltils.js')
 
 module.exports = function initialize(agent, redis, moduleName, shim) {
-  var proto = redis && redis.prototype
+  const proto = redis && redis.prototype
   if (!proto) {
     return false
   }
@@ -18,17 +18,17 @@ module.exports = function initialize(agent, redis, moduleName, shim) {
   shim.recordOperation(proto, 'sendCommand', wrapSendCommand)
 
   function wrapSendCommand(shim, original, name, args) {
-    var command = args[0]
+    const command = args[0]
 
     // TODO: Instance attributes for ioredis
-    var parameters = {
+    const parameters = {
       host: this.connector.options.host,
       port_path_or_id: this.connector.options.port
     }
 
-    var keys = command.args
+    const keys = command.args
     if (keys && typeof keys !== 'function') {
-      var src = Object.create(null)
+      const src = Object.create(null)
       try {
         src.key = stringify(keys[0])
       } catch (err) {

package/lib/instrumentation/memcached.js

@@ -5,7 +5,7 @@
 
 'use strict'
 
-var stringify = require('json-stringify-safe')
+const stringify = require('json-stringify-safe')
 
 function wrapKeys(metacall) {
   if (metacall.key) {
@@ -23,7 +23,7 @@ function wrapKeys(metacall) {
  * instrument the memcached driver to intercept calls and keep stats on them.
  */
 module.exports = function initialize(agent, memcached, moduleName, shim) {
-  var proto = memcached && memcached.prototype
+  const proto = memcached && memcached.prototype
   if (!proto) {
     return false
   }
@@ -34,10 +34,10 @@ module.exports = function initialize(agent, memcached, moduleName, shim) {
     // address. The query generator returns a simple object describing the
     // memcached call. The server parameter is only provided for multi-calls.
     // When not provided, it can be derived from the key being interacted with.
-    var metacall = args[0]()
-    var server = args[1]
-    var keys = wrapKeys(metacall)
-    var parameters = Object.create(null)
+    const metacall = args[0]()
+    const server = args[1]
+    const keys = wrapKeys(metacall)
+    const parameters = Object.create(null)
     try {
       parameters.key = stringify(keys[0])
     } catch (err) {
@@ -46,7 +46,7 @@ module.exports = function initialize(agent, memcached, moduleName, shim) {
     }
 
     // Capture connection info for datastore instance metric.
-    var location = null
+    let location = null
     if (typeof server === 'string') {
       location = server
     } else if (this.HashRing && this.HashRing.get && metacall.key) {