newrelic 8.0.0 → 8.4.0

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
 }

package/lib/spans/create-span-event-aggregator.js

@@ -10,21 +10,24 @@ const SpanEventAggregator = require('./span-event-aggregator')
 const StreamingSpanEventAggregator = require('./streaming-span-event-aggregator')
 
 function createSpanEventAggregator(config, collector, metrics) {
-  const trace_observer = config.infinite_tracing.trace_observer
+  const traceObserver = config.infinite_tracing.trace_observer
 
-  if (trace_observer.host) {
-    trace_observer.host = trace_observer.host.trim()
+  if (traceObserver.host) {
+    traceObserver.host = traceObserver.host.trim()
 
-    if (typeof trace_observer.port !== 'string') {
-      trace_observer.port = String(trace_observer.port)
+    if (typeof traceObserver.port !== 'string') {
+      traceObserver.port = String(traceObserver.port)
     }
-    trace_observer.port = trace_observer.port.trim()
+    traceObserver.port = traceObserver.port.trim()
 
     try {
       return createStreamingAggregator(config, collector, metrics)
     } catch (err) {
-      logger.warn(err, 'Failed to create streaming span event aggregator for infinite tracing. ' +
-        'Reverting to standard span event aggregator and disabling infinite tracing')
+      logger.warn(
+        err,
+        'Failed to create streaming span event aggregator for infinite tracing. ' +
+          'Reverting to standard span event aggregator and disabling infinite tracing'
+      )
       config.infinite_tracing.trace_observer = {
         host: '',
         port: ''

package/lib/spans/span-context.js

@@ -5,9 +5,9 @@
 
 'use strict'
 
-const {MAXIMUM_CUSTOM_ATTRIBUTES} = require('../attributes')
-const {PrioritizedAttributes, ATTRIBUTE_PRIORITY} = require('../prioritized-attributes')
-const {DESTINATIONS} = require('../config/attribute-filter')
+const { MAXIMUM_CUSTOM_ATTRIBUTES } = require('../attributes')
+const { PrioritizedAttributes, ATTRIBUTE_PRIORITY } = require('../prioritized-attributes')
+const { DESTINATIONS } = require('../config/attribute-filter')
 
 // Scoping impacts memoization. We could decide to add a scope instead of including
 // spans in segment scope in the future.
@@ -31,13 +31,7 @@ class SpanContext {
   }
 
   addCustomAttribute(key, value, priority) {
-    this.customAttributes.addAttribute(
-      DESTINATIONS.SPAN_EVENT,
-      key,
-      value,
-      false,
-      priority
-    )
+    this.customAttributes.addAttribute(DESTINATIONS.SPAN_EVENT, key, value, false, priority)
   }
 
   /**