newrelic 7.5.2 → 8.3.0

package/lib/shim/webframework-shim.js

@@ -6,7 +6,7 @@
 'use strict'
 
 var genericRecorder = require('../metrics/recorders/generic')
-var logger = require('../logger.js').child({component: 'WebFrameworkShim'})
+var logger = require('../logger.js').child({ component: 'WebFrameworkShim' })
 var metrics = require('../metrics/names')
 var TransactionShim = require('./transaction-shim')
 var Shim = require('./shim')
@@ -14,7 +14,6 @@ var specs = require('./specs')
 var urltils = require('../util/urltils')
 var util = require('util')
 
-
 /**
  * An enumeration of well-known web frameworks so that new instrumentations can
  * use the same names we already use for first-party instrumentation.
@@ -37,12 +36,12 @@ var FRAMEWORK_NAMES = {
 }
 
 var MIDDLEWARE_TYPE_DETAILS = {
-  APPLICATION:  {name: 'Mounted App: ', path: true,   record: false},
-  ERRORWARE:    {name: '',              path: false,  record: true},
-  MIDDLEWARE:   {name: '',              path: false,  record: true},
-  PARAMWARE:    {name: '',              path: false,  record: true},
-  ROUTE:        {name: 'Route Path: ',  path: true,   record: false},
-  ROUTER:       {name: 'Router: ',      path: true,   record: false}
+  APPLICATION: { name: 'Mounted App: ', path: true, record: false },
+  ERRORWARE: { name: '', path: false, record: true },
+  MIDDLEWARE: { name: '', path: false, record: true },
+  PARAMWARE: { name: '', path: false, record: true },
+  ROUTE: { name: 'Route Path: ', path: true, record: false },
+  ROUTER: { name: 'Router: ', path: true, record: false }
 }
 
 var MIDDLEWARE_TYPE_NAMES = {
@@ -61,7 +60,6 @@ var MIDDLEWARE_TYPE_NAMES = {
  */
 var TRANSACTION_INFO_KEY = '__NR_transactionInfo'
 
-
 /**
  * Constructs a shim associated with the given agent instance, specialized for
  * instrumenting web frameworks.
@@ -89,7 +87,7 @@ var TRANSACTION_INFO_KEY = '__NR_transactionInfo'
  */
 function WebFrameworkShim(agent, moduleName, resolvedName, frameworkId) {
   TransactionShim.call(this, agent, moduleName, resolvedName)
-  this._logger = logger.child({module: moduleName})
+  this._logger = logger.child({ module: moduleName })
   if (frameworkId) {
     this.setFramework(frameworkId)
   }
@@ -326,8 +324,8 @@ function setFramework(framework) {
   }
   this.agent.environment.setFramework(framework)
 
-  this._logger = this._logger.child({framework: framework})
-  this.logger.trace({metrics: this._metrics}, 'Framework metric names set')
+  this._logger = this._logger.child({ framework: framework })
+  this.logger.trace({ metrics: this._metrics }, 'Framework metric names set')
 }
 
 /**
@@ -343,12 +341,7 @@ function setTransactionUri(uri) {
     return
   }
 
-  tx.nameState.setName(
-    this._metrics.FRAMEWORK,
-    tx.verb,
-    metrics.ACTION_DELIMITER,
-    uri
-  )
+  tx.nameState.setName(this._metrics.FRAMEWORK, tx.verb, metrics.ACTION_DELIMITER, uri)
 }
 
 /**
@@ -388,10 +381,7 @@ function recordRender(nodule, properties, spec) {
   return this.record(nodule, properties, function renderRecorder(shim, fn, name, args) {
     var viewIdx = shim.normalizeIndex(args.length, spec.view)
     if (viewIdx === null) {
-      shim.logger.debug(
-        'Invalid spec.view (%d vs %d), not recording.',
-        spec.view, args.length
-      )
+      shim.logger.debug('Invalid spec.view (%d vs %d), not recording.', spec.view, args.length)
       return null
     }
 
@@ -441,7 +431,7 @@ function wrapMiddlewareMounter(nodule, properties, spec) {
   }
   if (this.isFunction(spec)) {
     // wrapMiddlewareMounter(nodule [, properties], wrapper)
-    spec = {wrapper: spec}
+    spec = { wrapper: spec }
   }
 
   spec = this.setDefaults(spec, {
@@ -823,9 +813,7 @@ function _recordMiddleware(shim, middleware, spec) {
 
   return shim.record(
     middleware,
-    spec.promise
-      ? middlewareWithPromiseRecorder
-      : middlewareWithCallbackRecorder
+    spec.promise ? middlewareWithPromiseRecorder : middlewareWithCallbackRecorder
   )
 
   // TODO: let's please break these out
@@ -839,9 +827,10 @@ function _recordMiddleware(shim, middleware, spec) {
     var txInfo = _getTransactionInfo(shim, req)
     if (!txInfo || !txInfo.transaction) {
       shim.logger.debug(
-        {txInfo: txInfo},
+        { txInfo: txInfo },
         'Could not get transaction info in %s (%s)',
-        route, fnName
+        route,
+        fnName
       )
       return null
     }
@@ -850,7 +839,8 @@ function _recordMiddleware(shim, middleware, spec) {
 
     // Copy over route parameters onto the transaction root.
     var params = shim.agent.config.high_security
-      ? null : spec.params.call(this, shim, fn, fnName, args, req)
+      ? null
+      : spec.params.call(this, shim, fn, fnName, args, req)
 
     // Wrap up `next` and push on our name state if we find it. We only want to
     // push the name state if there is a next so that we can safely remove it
@@ -929,9 +919,10 @@ function _recordMiddleware(shim, middleware, spec) {
     var txInfo = _getTransactionInfo(shim, req)
     if (!txInfo || !txInfo.transaction) {
       shim.logger.debug(
-        {txInfo: txInfo},
+        { txInfo: txInfo },
         'Could not get transaction info in %s (%s)',
-        route, fnName
+        route,
+        fnName
       )
       return null
     }
@@ -940,7 +931,8 @@ function _recordMiddleware(shim, middleware, spec) {
 
     // Copy over route parameters onto the transaction root.
     var params = shim.agent.config.high_security
-      ? null : spec.params.call(this, shim, fn, fnName, args, req)
+      ? null
+      : spec.params.call(this, shim, fn, fnName, args, req)
 
     // Append this middleware's mount point and possibly construct a recorder.
     if (spec.appendPath) {
@@ -1171,9 +1163,7 @@ function _isError(shim, err) {
  *   The spec object the values are coming from
  */
 function _copyExpectedSpecParameters(destination, source) {
-  var keys = [
-    'matchArity'
-  ]
+  var keys = ['matchArity']
 
   for (var i = 0; i < keys.length; ++i) {
     var key = keys[i]

package/lib/shimmer.js

@@ -5,16 +5,16 @@
 
 'use strict'
 
-var path = require('path')
-var fs = require('./util/unwrapped-core').fs
-var logger = require('./logger').child({component: 'shimmer'})
-var INSTRUMENTATIONS = require('./instrumentations')()
-var properties = require('./util/properties')
-var shims = require('./shim')
+const path = require('path')
+const fs = require('./util/unwrapped-core').fs
+const logger = require('./logger').child({ component: 'shimmer' })
+const INSTRUMENTATIONS = require('./instrumentations')()
+const properties = require('./util/properties')
+const shims = require('./shim')
 
-var MODULE_TYPE = shims.constants.MODULE_TYPE
+const MODULE_TYPE = shims.constants.MODULE_TYPE
 
-var CORE_INSTRUMENTATION = {
+const CORE_INSTRUMENTATION = {
   child_process: {
     type: MODULE_TYPE.GENERIC,
     file: 'child_process.js'
@@ -73,114 +73,12 @@ const FORCE_MODULE_RESOLUTION_WARNING =
  * maneuver, but it should be pretty safe if there's a desire to reboot the
  * agent in flight.
  *
- * All of the wrapped methods are tracked in this variable and used by unwrapAll
+ * All of the wrapped methods are tracked in this constiable and used by unwrapAll
  * below.
  */
-var instrumented = []
+let instrumented = []
 
-function applyDebugState(shimmer, shim, nodule) {
-  if (shimmer.debug) {
-    shim.enableDebug()
-    instrumented.push(shim)
-    instrumented.push({__NR_unwrap: function unwrapNodule() {
-      delete nodule.__NR_instrumented_errored
-      delete nodule.__NR_instrumented
-      delete nodule.__NR_shim
-    }})
-    nodule.__NR_shim = shim
-  }
-}
-
-/**
- * All instrumentation files must export the same interface: a single
- * initialization function that takes the agent and the module to be
- * instrumented.
- */
-function instrument(agent, nodule, moduleName, resolvedName) {
-  var instrumentation = shimmer.registeredInstrumentations[moduleName]
-  if (properties.hasOwn(nodule, '__NR_instrumented')
-      || properties.hasOwn(nodule, '__NR_instrumented_errored')) {
-    logger.trace(
-      'Already instrumented or failed to instrument %s, skipping redundant instrumentation',
-      moduleName
-    )
-    return nodule
-  }
-
-
-  var shim = shims.createShimFromType(
-    instrumentation.type,
-    agent,
-    moduleName,
-    resolvedName
-  )
-
-  applyDebugState(shimmer, shim, nodule)
-
-  try {
-    if (instrumentation.onRequire(shim, nodule, moduleName) !== false) {
-      nodule = shim.getExport(nodule)
-      nodule.__NR_instrumented = true
-    }
-  } catch (instrumentationError) {
-    nodule.__NR_instrumented_errored = true
-    if (instrumentation.onError) {
-      try {
-        instrumentation.onError(instrumentationError)
-      } catch (e) {
-        logger.warn(
-          e, instrumentationError,
-          'Custom instrumentation for %s failed, then the onError handler threw an error',
-          moduleName
-        )
-      }
-    } else {
-      logger.warn(
-        instrumentationError,
-        'Custom instrumentation for %s failed. Please report this to the ' +
-        'maintainers of the custom instrumentation.',
-        moduleName
-      )
-    }
-  }
-
-  return nodule
-}
-
-function _firstPartyInstrumentation(agent, fileName, shim, nodule, moduleName) {
-  var fullPath = path.resolve(fileName)
-  if (!fs.existsSync(fileName)) {
-    return logger.warn(
-      'Tried to load instrumentation from %s, but file does not exist',
-      fullPath
-    )
-  }
-  try {
-    return require(fileName)(agent, nodule, moduleName, shim)
-  } catch (error) {
-    logger.warn(
-      error,
-      'Failed to instrument module %s using %s',
-      path.basename(fileName, '.js'),
-      fullPath
-    )
-  }
-}
-
-function _postLoad(agent, nodule, name, resolvedName) {
-  var instrumentation
-  instrumentation = shimmer.getInstrumentationNameFromModuleName(name)
-
-  // Check if this is a known instrumentation and then run it.
-  if (shimmer.registeredInstrumentations[instrumentation]) {
-    logger.trace('Instrumenting %s.', name)
-    return instrument(agent, nodule, instrumentation, resolvedName)
-  }
-
-  return nodule
-}
-
-var shimmer = module.exports = {
+const shimmer = (module.exports = {
   /**
    * If debug isn't false, the agent will retain references to wrapped methods
    * for the entire lifetime of the agent. Some instrumentation depends on
@@ -218,17 +116,18 @@ var shimmer = module.exports = {
    */
   wrapMethod: function wrapMethod(nodule, noduleName, methods, wrapper) {
     if (!methods) {
-      return logger.warn(
-        new Error(),
-        "Must include a method name to wrap. Called from:"
-      )
+      return logger.warn(new Error(), 'Must include a method name to wrap. Called from:')
     }
 
-    if (!noduleName) noduleName = '[unknown]'
-    if (!Array.isArray(methods)) methods = [methods]
+    if (!noduleName) {
+      noduleName = '[unknown]'
+    }
+    if (!Array.isArray(methods)) {
+      methods = [methods]
+    }
 
-    methods.forEach(function cb_forEach(method) {
-      var fqmn = noduleName + '.' + method
+    methods.forEach((method) => {
+      const fqmn = noduleName + '.' + method
 
       if (!nodule) {
         return logger.debug("Can't wrap %s from nonexistent object.", fqmn)
@@ -238,24 +137,31 @@ var shimmer = module.exports = {
         return logger.debug("Can't wrap %s without a wrapper generator.", fqmn)
       }
 
-      var original = nodule[method]
+      const original = nodule[method]
 
-      if (!original) return logger.trace("%s not defined, so not wrapping.", fqmn)
-      if (original.__NR_unwrap) return logger.debug("%s already wrapped by agent.", fqmn)
+      if (!original) {
+        return logger.trace('%s not defined, so not wrapping.', fqmn)
+      }
+      if (original.__NR_unwrap) {
+        return logger.debug('%s already wrapped by agent.', fqmn)
+      }
 
-      var wrapped = wrapper(original, method)
+      const wrapped = wrapper(original, method)
       Object.keys(original).forEach((key) => {
         wrapped[key] = original[key]
       })
       wrapped.__NR_original = original
+      // eslint-disable-next-line camelcase
       wrapped.__NR_unwrap = function __NR_unwrap() {
         nodule[method] = original
-        logger.trace("Removed instrumentation from %s.", fqmn)
+        logger.trace('Removed instrumentation from %s.', fqmn)
       }
 
       nodule[method] = wrapped
-      if (shimmer.debug) instrumented.push(wrapped)
-      logger.trace("Instrumented %s.", fqmn)
+      if (shimmer.debug) {
+        instrumented.push(wrapped)
+      }
+      logger.trace('Instrumented %s.', fqmn)
     })
   },
 
@@ -277,34 +183,40 @@ var shimmer = module.exports = {
    */
   wrapDeprecated: function wrapDeprecated(nodule, noduleName, property, options) {
     if (!property) {
-      logger.warn(new Error(), "Must include a function name to wrap. Called from:")
+      logger.warn(new Error(), 'Must include a function name to wrap. Called from:')
       return
     }
 
-    if (!noduleName) noduleName = '[unknown]'
+    if (!noduleName) {
+      noduleName = '[unknown]'
+    }
 
-    var fqmn = noduleName + '.' + property
+    const fqmn = noduleName + '.' + property
     if (!nodule) {
       logger.debug("Can't wrap %s from nonexistent object.", fqmn)
       return
     }
 
-    var original = nodule[property]
+    const original = nodule[property]
     if (!original) {
-      logger.trace("%s not defined, so not wrapping.", fqmn)
+      logger.trace('%s not defined, so not wrapping.', fqmn)
       return
     }
 
     delete nodule[property]
 
-    var descriptor = {
+    const descriptor = {
       configurable: true,
       enumerable: true
     }
-    if (options.get) descriptor.get = options.get
-    if (options.set) descriptor.set = options.set
+    if (options.get) {
+      descriptor.get = options.get
+    }
+    if (options.set) {
+      descriptor.set = options.set
+    }
     Object.defineProperty(nodule, property, descriptor)
-    logger.trace("Instrumented %s.", fqmn)
+    logger.trace('Instrumented %s.', fqmn)
 
     if (shimmer.debug) {
       instrumented.push({
@@ -319,30 +231,42 @@ var shimmer = module.exports = {
   },
 
   unwrapMethod: function unwrapMethod(nodule, noduleName, method) {
-    if (!noduleName) noduleName = '[unknown]'
-    if (!method) return logger.debug("Must include a method name to unwrap. " +
-                                     "Called from: %s", new Error().stack)
+    if (!noduleName) {
+      noduleName = '[unknown]'
+    }
+    if (!method) {
+      return logger.debug(
+        'Must include a method name to unwrap. ' + 'Called from: %s',
+        new Error().stack
+      )
+    }
 
-    var fqmn = noduleName + '.' + method
+    const fqmn = noduleName + '.' + method
 
     if (!nodule) {
       return logger.debug("Can't unwrap %s from nonexistent object.", fqmn)
     }
 
-    var wrapped = nodule[method]
+    const wrapped = nodule[method]
 
     // keep instrumented up to date
-    var pos = instrumented.indexOf(wrapped)
-    if (pos !== -1) instrumented.splice(pos, 1)
+    const pos = instrumented.indexOf(wrapped)
+    if (pos !== -1) {
+      instrumented.splice(pos, 1)
+    }
 
-    if (!wrapped) return logger.debug("%s not defined, so not unwrapping.", fqmn)
-    if (!wrapped.__NR_unwrap) return logger.debug("%s isn't unwrappable.", fqmn)
+    if (!wrapped) {
+      return logger.debug('%s not defined, so not unwrapping.', fqmn)
+    }
+    if (!wrapped.__NR_unwrap) {
+      return logger.debug("%s isn't unwrappable.", fqmn)
+    }
 
     wrapped.__NR_unwrap()
   },
 
   unwrapAll: function unwrapAll() {
-    instrumented.forEach(function cb_forEach(wrapper) {
+    instrumented.forEach((wrapper) => {
       wrapper.__NR_unwrap()
     })
     instrumented = []
@@ -353,9 +277,9 @@ var shimmer = module.exports = {
    * have an opportunity to patch them with instrumentation.
    */
   patchModule: function patchModule(agent) {
-    logger.trace("Wrapping module loader.")
-    var Module = require('module')
-    var filepathMap = {}
+    logger.trace('Wrapping module loader.')
+    const Module = require('module')
+    const filepathMap = {}
 
     shimmer.wrapMethod(Module, 'Module', '_resolveFilename', function wrapRes(resolve) {
       return function wrappedResolveFilename(file) {
@@ -404,8 +328,8 @@ var shimmer = module.exports = {
   },
 
   unpatchModule: function unpatchModule() {
-    logger.trace("Unwrapping to previous module loader.")
-    var Module = require('module')
+    logger.trace('Unwrapping to previous module loader.')
+    const Module = require('module')
 
     shimmer.unwrapMethod(Module, 'Module', '_resolveFilename')
     shimmer.unwrapMethod(Module, 'Module', '_load')
@@ -414,8 +338,8 @@ var shimmer = module.exports = {
   bootstrapInstrumentation: function bootstrapInstrumentation(agent) {
     // Instrument global.
     const globalShim = new shims.Shim(agent, 'globals', 'globals')
-    applyDebugState(shimmer, globalShim, global)
-    var globalsFilepath = path.join(__dirname, 'instrumentation', 'core', 'globals.js')
+    applyDebugState(globalShim, global)
+    const globalsFilepath = path.join(__dirname, 'instrumentation', 'core', 'globals.js')
     _firstPartyInstrumentation(agent, globalsFilepath, globalShim, global, 'globals')
 
     // Instrument each of the core modules.
@@ -427,27 +351,23 @@ var shimmer = module.exports = {
       try {
         uninstrumented = require(mojule)
       } catch (err) {
-        logger.trace(
-          'Could not load core module %s got error %s',
-          mojule,
-          err
-        )
+        logger.trace('Could not load core module %s got error %s', mojule, err)
       }
 
       const shim = shims.createShimFromType(core.type, agent, mojule, mojule)
-      applyDebugState(shimmer, shim, core)
+      applyDebugState(shim, core)
       _firstPartyInstrumentation(agent, filePath, shim, uninstrumented, mojule)
     })
 
     // Register all the first-party instrumentations.
     Object.keys(INSTRUMENTATIONS).forEach(function forEachInstrumentation(moduleName) {
-      var instrInfo = INSTRUMENTATIONS[moduleName]
+      const instrInfo = INSTRUMENTATIONS[moduleName]
       if (instrInfo.module) {
         // Because external instrumentations can change independent of
         // the agent core, we don't want breakages in them to entirely
         // disable the agent.
         try {
-          var hooks = require(instrInfo.module + '/nr-hooks')
+          const hooks = require(instrInfo.module + '/nr-hooks')
           hooks.forEach(shimmer.registerInstrumentation)
         } catch (e) {
           logger.warn('Failed to load instrumentation for ' + instrInfo.module, e)
@@ -457,7 +377,7 @@ var shimmer = module.exports = {
         // TODO: Remove this code when amqplib instrumentation is made external.
         require('./instrumentation/amqplib').selfRegister(shimmer)
       } else {
-        var fileName = path.join(__dirname, 'instrumentation', moduleName + '.js')
+        const fileName = path.join(__dirname, 'instrumentation', moduleName + '.js')
         shimmer.registerInstrumentation({
           moduleName: moduleName,
           type: instrInfo.type,
@@ -469,7 +389,7 @@ var shimmer = module.exports = {
     // Even though domain is a core module we add it as a registered
     // instrumentation to be lazy-loaded because we do not want to cause domain
     // usage.
-    var domainPath = path.join(__dirname, 'instrumentation/core/domain.js')
+    const domainPath = path.join(__dirname, 'instrumentation/core/domain.js')
     shimmer.registerInstrumentation({
       moduleName: 'domain',
       type: null,
@@ -510,12 +430,13 @@ var shimmer = module.exports = {
    * the same.
    */
   getInstrumentationNameFromModuleName(moduleName) {
-    var instrumentation
+    let instrumentation
     // XXX When updating these special cases, also update `uninstrumented`.
     // To allow for instrumenting both 'pg' and 'pg.js'.
     if (moduleName === 'pg.js') {
       instrumentation = 'pg'
-    } if (moduleName === 'mysql2') {
+    }
+    if (moduleName === 'mysql2') {
       // mysql2 (https://github.com/sidorares/node-mysql2) is a drop in replacement for
       // mysql which conforms to the existing mysql API. If we see mysql2, treat it as
       // mysql
@@ -525,4 +446,101 @@ var shimmer = module.exports = {
     }
     return instrumentation
   }
+})
+
+function applyDebugState(shim, nodule) {
+  if (shimmer.debug) {
+    shim.enableDebug()
+    instrumented.push(shim)
+    instrumented.push({
+      __NR_unwrap: function unwrapNodule() {
+        delete nodule.__NR_instrumented_errored
+        delete nodule.__NR_instrumented
+        delete nodule.__NR_shim
+      }
+    })
+    nodule.__NR_shim = shim
+  }
+}
+
+/**
+ * All instrumentation files must export the same interface: a single
+ * initialization function that takes the agent and the module to be
+ * instrumented.
+ */
+function instrument(agent, nodule, moduleName, resolvedName) {
+  const instrumentation = shimmer.registeredInstrumentations[moduleName]
+  if (
+    properties.hasOwn(nodule, '__NR_instrumented') ||
+    properties.hasOwn(nodule, '__NR_instrumented_errored')
+  ) {
+    logger.trace(
+      'Already instrumented or failed to instrument %s, skipping redundant instrumentation',
+      moduleName
+    )
+    return nodule
+  }
+
+  const shim = shims.createShimFromType(instrumentation.type, agent, moduleName, resolvedName)
+
+  applyDebugState(shim, nodule)
+
+  try {
+    if (instrumentation.onRequire(shim, nodule, moduleName) !== false) {
+      nodule = shim.getExport(nodule)
+      nodule.__NR_instrumented = true
+    }
+  } catch (instrumentationError) {
+    nodule.__NR_instrumented_errored = true
+    if (instrumentation.onError) {
+      try {
+        instrumentation.onError(instrumentationError)
+      } catch (e) {
+        logger.warn(
+          e,
+          instrumentationError,
+          'Custom instrumentation for %s failed, then the onError handler threw an error',
+          moduleName
+        )
+      }
+    } else {
+      logger.warn(
+        instrumentationError,
+        'Custom instrumentation for %s failed. Please report this to the ' +
+          'maintainers of the custom instrumentation.',
+        moduleName
+      )
+    }
+  }
+
+  return nodule
+}
+
+function _firstPartyInstrumentation(agent, fileName, shim, nodule, moduleName) {
+  const fullPath = path.resolve(fileName)
+  if (!fs.existsSync(fileName)) {
+    return logger.warn('Tried to load instrumentation from %s, but file does not exist', fullPath)
+  }
+  try {
+    return require(fileName)(agent, nodule, moduleName, shim)
+  } catch (error) {
+    logger.warn(
+      error,
+      'Failed to instrument module %s using %s',
+      path.basename(fileName, '.js'),
+      fullPath
+    )
+  }
+}
+
+function _postLoad(agent, nodule, name, resolvedName) {
+  const instrumentation = shimmer.getInstrumentationNameFromModuleName(name)
+
+  // Check if this is a known instrumentation and then run it.
+  if (shimmer.registeredInstrumentations[instrumentation]) {
+    logger.trace('Instrumenting %s.', name)
+    return instrument(agent, nodule, instrumentation, resolvedName)
+  }
+
+  return nodule
 }