newrelic 9.5.0 → 9.7.0

package/lib/shim/promise-shim.js

@@ -5,13 +5,16 @@
 
 'use strict'
 
+/* eslint sonarjs/cognitive-complexity: ["error", 30] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
+
 const logger = require('../logger').child({ component: 'PromiseShim' })
 const Shim = require('./shim')
+const symbols = require('../symbols')
 
 /**
  * A helper class for wrapping promise modules.
  *
- * @extends Shim
+ * @augments Shim
  */
 /* eslint-disable camelcase */
 class PromiseShim extends Shim {
@@ -21,13 +24,10 @@ class PromiseShim extends Shim {
    *
    * @param {Agent} agent
    *  The agent this shim will use.
-   *
    * @param {string} moduleName
    *  The name of the module being instrumented.
-   *
    * @param {string} resolvedName
    *  The full path to the loaded module.
-   *
    * @see Shim
    */
   constructor(agent, moduleName, resolvedName) {
@@ -49,7 +49,7 @@ class PromiseShim extends Shim {
   /**
    * Sets the class used to identify promises from the wrapped promise library.
    *
-   * @param {function} clss - The promise library's class.
+   * @param {Function} clss - The promise library's class.
    */
   setClass(clss) {
     this._class = clss
@@ -60,10 +60,8 @@ class PromiseShim extends Shim {
    * library being wrapped.
    *
    * @param {*} obj - The object to check the instance type of.
-   *
-   * @return {bool} True if the provided object is an instance of a promise from
+   * @returns {bool} True if the provided object is an instance of a promise from
    *  this promise library.
-   *
    * @see PromiseShim#setClass
    */
   isPromiseInstance(obj) {
@@ -82,16 +80,13 @@ class PromiseShim extends Shim {
    * better to wrap that using {@link PromiseShim#wrapExecutorCaller} than to
    * use this method.
    *
-   * @param {object|function} nodule
+   * @param {object | Function} nodule
    *  The source of the properties to wrap, or a single function to wrap.
-   *
-   * @param {string|array.<string>} [properties]
+   * @param {string | Array.<string>} [properties]
    *  One or more properties to wrap. If omitted, the `nodule` parameter is
    *  assumed to be the constructor to wrap.
-   *
-   * @return {object|function} The first parameter to this function, after
+   * @returns {object | Function} The first parameter to this function, after
    *  wrapping it or its properties.
-   *
    * @see PromiseShim#wrapExecutorCaller
    */
   wrapConstructor(nodule, properties) {
@@ -108,7 +103,7 @@ class PromiseShim extends Shim {
       post: function postPromise(shim, Promise, name, args) {
         // This extra property is added by `_wrapExecutorContext` in the pre step.
         const executor = args[0]
-        const context = executor && executor.__NR_executorContext
+        const context = executor && executor[symbols.executorContext]
         if (!context || !shim.isFunction(context.executor)) {
           return
         }
@@ -135,16 +130,13 @@ class PromiseShim extends Shim {
    * Wrapping the executor caller method directly is preferable to wrapping
    * the constructor of the promise class.
    *
-   * @param {object|function} nodule
+   * @param {object | Function} nodule
    *  The source of the properties to wrap, or a single function to wrap.
-   *
-   * @param {string|array.<string>} [properties]
+   * @param {string | Array.<string>} [properties]
    *  One or more properties to wrap. If omitted, the `nodule` parameter is
    *  assumed to be the function to wrap.
-   *
-   * @return {object|function} The first parameter to this function, after
+   * @returns {object | Function} The first parameter to this function, after
    *  wrapping it or its properties.
-   *
    * @see PromiseShim#wrapConstructor
    */
   wrapExecutorCaller(nodule, properties) {
@@ -159,14 +151,14 @@ class PromiseShim extends Shim {
           return caller.apply(this, arguments)
         }
 
-        if (!this.__NR_context) {
+        if (!this[symbols.context]) {
           Contextualizer.link(null, this, parent)
         }
 
         const args = shim.argsToArray.apply(shim, arguments)
         _wrapExecutorContext(shim, args)
         const ret = caller.apply(this, args)
-        const context = args[0].__NR_executorContext
+        const context = args[0][symbols.executorContext]
         context.promise = this
 
         // Bluebird catches executor errors and auto-rejects when it catches them,
@@ -196,14 +188,12 @@ class PromiseShim extends Shim {
    * and Bluebird's `Promise.delay`. These are static methods which accept some
    * arbitrary value and return a Promise instance.
    *
-   * @param {object|function} nodule
+   * @param {object | Function} nodule
    *  The source of the properties to wrap, or a single function to wrap.
-   *
-   * @param {string|array.<string>} [properties]
+   * @param {string | Array.<string>} [properties]
    *  One or more properties to wrap. If omitted, the `nodule` parameter is
    *  assumed to be the function to wrap.
-   *
-   * @return {object|function} The first parameter to this function, after
+   * @returns {object | Function} The first parameter to this function, after
    *  wrapping it or its properties.
    */
   wrapCast(nodule, properties) {
@@ -235,16 +225,13 @@ class PromiseShim extends Shim {
    * and Bluebird's `Promise#map`. These are methods which take a function to
    * execute once the promise resolves and hands back a new promise.
    *
-   * @param {object|function} nodule
+   * @param {object | Function} nodule
    *  The source of the properties to wrap, or a single function to wrap.
-   *
-   * @param {string|array.<string>} [properties]
+   * @param {string | Array.<string>} [properties]
    *  One or more properties to wrap. If omitted, the `nodule` parameter is
    *  assumed to be the function to wrap.
-   *
-   * @return {object|function} The first parameter to this function, after
+   * @returns {object | Function} The first parameter to this function, after
    *  wrapping it or its properties.
-   *
    * @see PromiseShim#setClass
    * @see PromiseShim#wrapCatch
    */
@@ -265,16 +252,13 @@ class PromiseShim extends Shim {
    * an additional argument to `Promise#catch` which is usually an error class
    * to filter rejections by. This wrap method will handle that case.
    *
-   * @param {object|function} nodule
+   * @param {object | Function} nodule
    *  The source of the properties to wrap, or a single function to wrap.
-   *
-   * @param {string|array.<string>} [properties]
+   * @param {string | Array.<string>} [properties]
    *  One or more properties to wrap. If omitted, the `nodule` parameter is
    *  assumed to be the function to wrap.
-   *
-   * @return {object|function} The first parameter to this function, after
+   * @returns {object | Function} The first parameter to this function, after
    *  wrapping it or its properties.
-   *
    * @see PromiseShim#setClass
    * @see PromiseShim#wrapThen
    */
@@ -288,14 +272,12 @@ class PromiseShim extends Shim {
    * - `wrapPromisify(nodule, properties)`
    * - `wrapPromisify(func)`
    *
-   * @param {object|function} nodule
+   * @param {object | Function} nodule
    *  The source of the properties to wrap, or a single function to wrap.
-   *
-   * @param {string|array.<string>} [properties]
+   * @param {string | Array.<string>} [properties]
    *  One or more properties to wrap. If omitted, the `nodule` parameter is
    *  assumed to be the function to wrap.
-   *
-   * @return {object|function} The first parameter to this function, after
+   * @returns {object | Function} The first parameter to this function, after
    *  wrapping it or its properties.
    */
   wrapPromisify(nodule, properties) {
@@ -315,6 +297,9 @@ class PromiseShim extends Shim {
         })
 
         return __NR_wrappedPromisified
+        /**
+         *
+         */
         function __NR_wrappedPromisified() {
           const segment = shim.getActiveSegment()
           if (!segment) {
@@ -334,6 +319,8 @@ module.exports = PromiseShim
 // -------------------------------------------------------------------------- //
 
 /**
+ * @param shim
+ * @param args
  * @private
  */
 function _wrapExecutorContext(shim, args) {
@@ -343,9 +330,14 @@ function _wrapExecutorContext(shim, args) {
     self: null,
     args: null
   }
-  contextExporter.__NR_executorContext = context
+  contextExporter[symbols.executorContext] = context
   args[0] = contextExporter
 
+  /**
+   *
+   * @param resolve
+   * @param reject
+   */
   function contextExporter(resolve, reject) {
     context.self = this
     context.args = shim.argsToArray.apply(shim, arguments)
@@ -355,19 +347,25 @@ function _wrapExecutorContext(shim, args) {
 }
 
 /**
+ * @param context
+ * @param fn
  * @private
  */
 function _wrapResolver(context, fn) {
   return function wrappedResolveReject(val) {
     const promise = context.promise
-    if (promise && promise.__NR_context) {
-      promise.__NR_context.getSegment().touch()
+    if (promise && promise[symbols.context]) {
+      promise[symbols.context].getSegment().touch()
     }
     fn(val)
   }
 }
 
 /**
+ * @param shim
+ * @param fn
+ * @param name
+ * @param useAllParams
  * @private
  */
 function _wrapThen(shim, fn, name, useAllParams) {
@@ -398,6 +396,12 @@ function _wrapThen(shim, fn, name, useAllParams) {
     }
     return next
 
+    /**
+     *
+     * @param handler
+     * @param i
+     * @param length
+     */
     function wrapHandler(handler, i, length) {
       if (
         !shim.isFunction(handler) || // Not a function
@@ -409,14 +413,14 @@ function _wrapThen(shim, fn, name, useAllParams) {
       }
 
       return function __NR_wrappedThenHandler() {
-        if (!next || !next.__NR_context) {
+        if (!next || !next[symbols.context]) {
           return handler.apply(this, arguments)
         }
 
-        let promSegment = next.__NR_context.getSegment()
+        let promSegment = next[symbols.context].getSegment()
         const segment = promSegment || shim.getSegment()
         if (segment && segment !== promSegment) {
-          next.__NR_context.setSegment(segment)
+          next[symbols.context].setSegment(segment)
           promSegment = segment
         }
 
@@ -425,7 +429,7 @@ function _wrapThen(shim, fn, name, useAllParams) {
           ret = shim.applySegment(handler, promSegment, true, this, arguments)
         } finally {
           if (ret && typeof ret.then === 'function') {
-            ret = next.__NR_context.continueContext(ret)
+            ret = next[symbols.context].continueContext(ret)
           }
         }
         return ret
@@ -459,9 +463,9 @@ class Contextualizer {
   }
 
   static link(prev, next, segment) {
-    let ctxlzr = prev && prev.__NR_context
+    let ctxlzr = prev && prev[symbols.context]
     if (ctxlzr && !ctxlzr.isActive()) {
-      ctxlzr = prev.__NR_context = null
+      ctxlzr = prev[symbols.context] = null
     }
 
     if (ctxlzr) {
@@ -503,17 +507,17 @@ class Contextualizer {
       const idx = ctxlzr.child === false ? ctxlzr.context.branch() : ctxlzr.idx
 
       // Create a new context for this next promise.
-      next.__NR_context = new Contextualizer(idx, ctxlzr.context)
-      next.__NR_context.parentIdx = ctxlzr.idx
+      next[symbols.context] = new Contextualizer(idx, ctxlzr.context)
+      next[symbols.context].parentIdx = ctxlzr.idx
 
       // If this was our first child, remember it in case we have a 2nd.
       if (ctxlzr.child === null) {
-        ctxlzr.child = next.__NR_context
+        ctxlzr.child = next[symbols.context]
       }
     } else if (segment) {
       // This next promise is the root of a chain. Either there was no previous
       // promise or the promise was created out of context.
-      next.__NR_context = new Contextualizer(0, new Context(segment))
+      next[symbols.context] = new Contextualizer(0, new Context(segment))
     }
   }
 
@@ -542,7 +546,7 @@ class Contextualizer {
 
   continueContext(prom) {
     const self = this
-    const nextContext = prom.__NR_context
+    const nextContext = prom[symbols.context]
     if (!nextContext) {
       return prom
     }
@@ -565,6 +569,9 @@ class Contextualizer {
       }
     )
 
+    /**
+     *
+     */
     function __NR_continueContext() {
       self.setSegment(nextContext.getSegment())
     }

package/lib/shim/shim.js

@@ -5,13 +5,15 @@
 
 'use strict'
 
+/* eslint sonarjs/cognitive-complexity: ["error", 59] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
+
 const arity = require('../util/arity')
-const constants = require('./constants')
 const hasOwnProperty = require('../util/properties').hasOwn
 const logger = require('../logger').child({ component: 'Shim' })
 const path = require('path')
 const specs = require('./specs')
 const util = require('util')
+const symbols = require('../symbols')
 
 // Some modules do terrible things, like change the prototype of functions. To
 // avoid crashing things we'll use a cached copy of apply everywhere.
@@ -52,14 +54,14 @@ module.exports = Shim
 Shim.defineProperty = defineProperty
 Shim.defineProperties = defineProperties
 
+// This is for backwards compat for external libraries like aws-sdk that expect the symbol to be defined here
+defineProperty(Shim, 'DISABLE_DT', symbols.disableDT)
+defineProperty(Shim.prototype, 'DISABLE_DT', symbols.disableDT)
+
 // Copy the argument index enumeration onto the shim.
 Shim.prototype.ARG_INDEXES = specs.ARG_INDEXES
 defineProperties(Shim.prototype, specs.ARG_INDEXES)
 
-// Copy symbols to the shim as well.
-defineProperties(Shim, constants.SYMBOLS)
-defineProperties(Shim.prototype, constants.SYMBOLS)
-
 // Define other miscellaneous properties of the shim.
 defineProperties(Shim.prototype, {
   /**
@@ -130,8 +132,6 @@ Shim.prototype.argsToArray = argsToArray
 Shim.prototype.normalizeIndex = normalizeIndex
 Shim.prototype.once = once
 
-Shim.prototype.setInternalProperty = setInternalProperty
-
 Shim.prototype.defineProperty = defineProperty
 Shim.prototype.defineProperties = defineProperties
 Shim.prototype.setDefaults = setDefaults
@@ -144,7 +144,7 @@ Shim.prototype.fixArity = arity.fixArity
 // Internal methods.
 Shim.prototype.getExport = getExport
 Shim.prototype.enableDebug = enableDebug
-Shim.prototype.__NR_unwrap = unwrapAll
+Shim.prototype[symbols.unwrap] = unwrapAll
 
 // -------------------------------------------------------------------------- //
 
@@ -291,10 +291,10 @@ Shim.prototype.__NR_unwrap = unwrapAll
  *  `true`. Good for preventing double wrapping of prototype methods.
  *
  *  ```js
- *  if (spec.$once && spec.__NR_onceExecuted) {
+ *  if (spec.$once && spec[symbols.onceExecuted]) {
  *    return context
  *  }
- *  spec.__NR_onceExecuted = true
+ *  spec[symbols.onceExecuted] = true
  *  ```
  * @property {ArgumentsFunction} $arguments
  *  Executes the function with all of the arguments passed in. The arguments can
@@ -350,7 +350,7 @@ Shim.prototype.__NR_unwrap = unwrapAll
  *    segment = shim.createSegment(seg.name, seg.recorder, seg.parent)
  *  }
  *  ```
- * @property {object.<string, *>} $cache
+ * @property {Object<string, *>} $cache
  *  Adds the value as an extra parameter to all specs in the same context as the
  *  cache. If the current context is a function, the cache will be recreated on
  *  each invocation of the function. This value can be useful for passing a
@@ -468,7 +468,7 @@ function execute(nodule, spec) {
   if (this.isFunction(spec)) {
     spec(this, nodule)
   } else {
-    _specToFunction(spec)(this, nodule)
+    _specToFunction(spec)
   }
 }
 
@@ -522,7 +522,7 @@ function wrap(nodule, properties, spec, args) {
     }
   }
 
-  // TODO: Add option for omitting __NR_original; unwrappable: false
+  // TODO: Add option for omitting symbols.original; unwrappable: false
   spec = this.setDefaults(spec, { matchArity: false })
 
   // If we're just wrapping one thing, just wrap it and return.
@@ -553,10 +553,10 @@ function wrap(nodule, properties, spec, args) {
       this.logger.trace('Replacing "%s" with wrapped version', prop)
 
       nodule[prop] = wrapped
-      this.setInternalProperty(wrapped, '__NR_unwrap', function unwrapWrap() {
+      wrapped[symbols.unwrap] = function unwrapWrap() {
         nodule[prop] = original
         return original
-      })
+      }
     }
   }, this)
   return nodule
@@ -597,7 +597,7 @@ function wrapReturn(nodule, properties, spec, args) {
     properties = null
   }
   if (!this.isFunction(spec)) {
-    spec = _specToFunction(spec)
+    _specToFunction(spec)
   }
   if (!this.isArray(args)) {
     args = []
@@ -614,17 +614,17 @@ function wrapReturn(nodule, properties, spec, args) {
     const handler = {
       get: function getTrap(target, prop) {
         // Allow for look up of the target
-        if (prop === '__NR_original') {
+        if (prop === symbols.original) {
           return target
         }
-        if (prop === '__NR_unwrap') {
+        if (prop === symbols.unwrap) {
           return unwrapReference
         }
 
         return target[prop]
       },
       defineProperty: function definePropertyTrap(target, key, descriptor) {
-        if (key === '__NR_unwrap') {
+        if (key === symbols.unwrap) {
           unwrapReference = descriptor.value
         } else {
           Object.defineProperty(target, key, descriptor)
@@ -632,7 +632,7 @@ function wrapReturn(nodule, properties, spec, args) {
         return true
       },
       set: function setTrap(target, key, val) {
-        if (key === '__NR_unwrap') {
+        if (key === symbols.unwrap) {
           unwrapReference = val
         } else {
           target[key] = val
@@ -784,9 +784,9 @@ function getExport(defaultExport) {
  */
 function isWrapped(nodule, property) {
   if (property) {
-    return !!(nodule && nodule[property] && nodule[property].__NR_original)
+    return !!(nodule && nodule[property] && nodule[property][symbols.original])
   }
-  return !!(nodule && nodule.__NR_original)
+  return !!(nodule && nodule[symbols.original])
 }
 
 /**
@@ -991,10 +991,10 @@ function unwrap(nodule, properties) {
 
   this.logger.trace('Unwrapping %s', properties || '<nodule>')
   let original = properties ? nodule[properties] : nodule
-  while (original && original.__NR_original) {
-    original = this.isFunction(original.__NR_unwrap)
-      ? original.__NR_unwrap()
-      : original.__NR_original
+  while (original && original[symbols.original]) {
+    original = this.isFunction(original[symbols.unwrap])
+      ? original[symbols.unwrap]()
+      : original[symbols.original]
   }
   return original
 }
@@ -1030,10 +1030,10 @@ function unwrapOnce(nodule, properties) {
 
   this.logger.trace('Unwrapping %s', properties || '<nodule>')
   let original = properties ? nodule[properties] : nodule
-  if (original && original.__NR_original) {
-    original = this.isFunction(original.__NR_unwrap)
-      ? original.__NR_unwrap()
-      : original.__NR_original
+  if (original && original[symbols.original]) {
+    original = this.isFunction(original[symbols.unwrap])
+      ? original[symbols.unwrap]()
+      : original[symbols.original]
   }
   return original
 }
@@ -1057,8 +1057,8 @@ function getOriginal(nodule, property) {
   }
 
   let original = property ? nodule[property] : nodule
-  while (original && original.__NR_original) {
-    original = original.__NR_original
+  while (original && original[symbols.original]) {
+    original = original[symbols.original]
   }
   return original
 }
@@ -1107,7 +1107,7 @@ function bindSegment(nodule, property, segment, full) {
     return nodule
   }
 
-  const wrapped = this.wrap(nodule, property, function wrapFunc(shim, func) {
+  return this.wrap(nodule, property, function wrapFunc(shim, func) {
     if (!shim.isFunction(func)) {
       return func
     }
@@ -1122,8 +1122,6 @@ function bindSegment(nodule, property, segment, full) {
     shim.storeSegment(binder, segment)
     return binder
   })
-
-  return wrapped
 }
 
 /**
@@ -1206,8 +1204,8 @@ function bindCallbackSegment(args, cbIdx, parentSegment) {
  *  with the object.
  */
 function getSegment(obj) {
-  if (obj && obj.__NR_segment) {
-    return obj.__NR_segment
+  if (obj && obj[symbols.segment]) {
+    return obj[symbols.segment]
   }
 
   return this._contextManager.getContext()
@@ -1264,7 +1262,9 @@ function setActiveSegment(segment) {
  * @param {TraceSegment}  [segment] - The segment to link the object to.
  */
 function storeSegment(obj, segment) {
-  this.setInternalProperty(obj, '__NR_segment', segment || this.getSegment())
+  if (obj) {
+    obj[symbols.segment] = segment || this.getSegment()
+  }
 }
 
 /* eslint-disable max-params */
@@ -1300,7 +1300,7 @@ function applySegment(func, segment, full, context, args, inContextCB) {
   const contextManager = this._contextManager
   const prevSegment = contextManager.getContext()
 
-  return contextManager.runInContext(segment, () => {
+  return contextManager.runInContext(segment, function runInContextCb() {
     if (full) {
       segment.start()
     }
@@ -1313,7 +1313,7 @@ function applySegment(func, segment, full, context, args, inContextCB) {
       return fnApply.call(func, context, args)
     } catch (error) {
       if (prevSegment === null && process.domain != null) {
-        process.domain.__NR_segment = contextManager.getContext()
+        process.domain[symbols.segment] = contextManager.getContext()
       }
 
       throw error // Re-throwing application error, this is not an agent error.
@@ -1571,51 +1571,6 @@ function once(fn) {
   }
 }
 
-/**
- * Sets a property to the given value. If the property doesn't exist yet it will
- * be made writable and non-enumerable.
- *
- * @memberof Shim.prototype
- * @param {!object} obj   - The object to add the property to.
- * @param {!string} name  - The name for this property.
- * @param {*}       val   - The value to set the property as.
- * @returns {object} The `obj` value.
- */
-function setInternalProperty(obj, name, val) {
-  if (!obj || !name) {
-    this.logger.debug('Not setting property; object or name is missing.')
-    return obj
-  }
-
-  try {
-    if (this.agent.config.transaction_tracer.hide_internals) {
-      _slowSetInternalProperty(obj, name, val)
-    } else {
-      obj[name] = val
-    }
-  } catch (err) {
-    this.logger.debug(err, 'Failed to set property "%s" to %j', name, val)
-  }
-  return obj
-}
-
-/**
- * @param obj
- * @param name
- * @param val
- */
-function _slowSetInternalProperty(obj, name, val) {
-  if (!hasOwnProperty(obj, name)) {
-    Object.defineProperty(obj, name, {
-      enumerable: false,
-      writable: true,
-      value: val
-    })
-  } else {
-    obj[name] = val
-  }
-}
-
 /**
  * Defines a read-only property on the given object.
  *
@@ -1805,7 +1760,7 @@ function enableDebug() {
  * enabled first.
  *
  * @private
- * @member Shim.prototype.__NR_unwrap
+ * @member Shim.prototype.unwrap
  */
 function unwrapAll() {
   if (this._wrapped) {
@@ -1870,9 +1825,9 @@ function _wrap(shim, original, name, spec, args) {
 
     // TODO: Once all wrapping is converted to proxies, we won't need to
     // set this property as the trap on 'get' will return the original for
-    // __NR_original. For now, we have to prevent setting this on original.
-    if (!wrapped.__NR_original) {
-      shim.setInternalProperty(wrapped, '__NR_original', original)
+    // symbols.original. For now, we have to prevent setting this on original.
+    if (!wrapped[symbols.original]) {
+      wrapped[symbols.original] = original
     }
 
     if (shim._debug) {

package/lib/shim/transaction-shim.js

@@ -295,7 +295,7 @@ function insertCATRequestHeaders(headers, useAlternateHeaderNames) {
   }
 
   if (distributedTracingEnabled) {
-    // TODO: Should probably honor SHIM_SYMBOLS.DISABLE_DT.
+    // TODO: Should probably honor symbols.disableDT.
     // TODO: Official testing and support.
     tx.insertDistributedTraceHeaders(headers)
   } else {