newrelic 9.4.0 → 9.6.0

package/lib/shim/shim.js

@@ -6,12 +6,12 @@
 'use strict'
 
 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 +52,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 +130,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 +142,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 +289,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
@@ -522,7 +520,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 +551,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
@@ -614,17 +612,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 +630,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 +782,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 +989,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 +1028,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 +1055,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
 }
@@ -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 */
@@ -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 {

package/lib/shim/webframework-shim.js

@@ -13,6 +13,7 @@ const Shim = require('./shim')
 const specs = require('./specs')
 const urltils = require('../util/urltils')
 const util = require('util')
+const symbols = require('../symbols')
 
 /**
  * An enumeration of well-known web frameworks so that new instrumentations can
@@ -54,13 +55,6 @@ const MIDDLEWARE_TYPE_NAMES = {
   ROUTER: 'ROUTER'
 }
 
-/**
- * Name of the key used to store transaction information on `req` and `res`.
- *
- * @private
- */
-const TRANSACTION_INFO_KEY = '__NR_transactionInfo'
-
 /**
  * Constructs a shim associated with the given agent instance, specialized for
  * instrumenting web frameworks.
@@ -1036,7 +1030,7 @@ function _makeNextBinder(nextDetails, txInfo) {
  */
 function _getTransactionInfo(shim, req) {
   try {
-    return req[TRANSACTION_INFO_KEY] || null
+    return req[symbols.transactionInfo] || null
   } catch (e) {
     shim.logger.debug(e, 'Failed to fetch transaction info from req')
     return null

package/lib/shimmer.js

@@ -14,6 +14,7 @@ const properties = require('./util/properties')
 const shims = require('./shim')
 
 const NAMES = require('./metrics/names')
+const symbols = require('./symbols')
 
 const MODULE_TYPE = shims.constants.MODULE_TYPE
 
@@ -97,7 +98,7 @@ const shimmer = (module.exports = {
    * @returns {bool} True if `fn` exists and has an attached original, else false.
    */
   isWrapped: function isWrapped(fn) {
-    return !!(fn && fn.__NR_original)
+    return !!(fn && fn[symbols.original])
   },
 
   /**
@@ -118,7 +119,8 @@ const 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:')
+      logger.warn(new Error(), 'Must include a method name to wrap. Called from:')
+      return
     }
 
     if (!noduleName) {
@@ -132,29 +134,33 @@ const shimmer = (module.exports = {
       const fqmn = noduleName + '.' + method
 
       if (!nodule) {
-        return logger.debug("Can't wrap %s from nonexistent object.", fqmn)
+        logger.debug("Can't wrap %s from nonexistent object.", fqmn)
+        return
       }
 
       if (!wrapper) {
-        return logger.debug("Can't wrap %s without a wrapper generator.", fqmn)
+        logger.debug("Can't wrap %s without a wrapper generator.", fqmn)
+        return
       }
 
       const original = nodule[method]
 
       if (!original) {
-        return logger.trace('%s not defined, so not wrapping.', fqmn)
+        logger.trace('%s not defined, so not wrapping.', fqmn)
+        return
       }
-      if (original.__NR_unwrap) {
-        return logger.debug('%s already wrapped by agent.', fqmn)
+      if (original[symbols.unwrap]) {
+        logger.debug('%s already wrapped by agent.', fqmn)
+        return
       }
 
       const wrapped = wrapper(original, method)
       Object.keys(original).forEach((key) => {
         wrapped[key] = original[key]
       })
-      wrapped.__NR_original = original
+      wrapped[symbols.original] = original
       // eslint-disable-next-line camelcase
-      wrapped.__NR_unwrap = function __NR_unwrap() {
+      wrapped[symbols.unwrap] = function unwrap() {
         nodule[method] = original
         logger.trace('Removed instrumentation from %s.', fqmn)
       }
@@ -221,7 +227,7 @@ const shimmer = (module.exports = {
 
     if (shimmer.debug) {
       instrumented.push({
-        __NR_unwrap: function unwrapDeprecated() {
+        [symbols.unwrap]: function unwrapDeprecated() {
           delete nodule[property]
           nodule[property] = original
         }
@@ -259,16 +265,16 @@ const shimmer = (module.exports = {
     if (!wrapped) {
       return logger.debug('%s not defined, so not unwrapping.', fqmn)
     }
-    if (!wrapped.__NR_unwrap) {
+    if (!wrapped[symbols.unwrap]) {
       return logger.debug("%s isn't unwrappable.", fqmn)
     }
 
-    wrapped.__NR_unwrap()
+    wrapped[symbols.unwrap]()
   },
 
   unwrapAll: function unwrapAll() {
     instrumented.forEach((wrapper) => {
-      wrapper.__NR_unwrap()
+      wrapper[symbols.unwrap]()
     })
     instrumented = []
   },
@@ -472,7 +478,7 @@ const shimmer = (module.exports = {
     // This is to not break the public API
     // previously it would just call instrumentation
     // and not check the result
-    return returnModule ? result : !!result.__NR_instrumented
+    return returnModule ? result : !!result[symbols.instrumented]
   }
 })
 
@@ -481,13 +487,13 @@ function applyDebugState(shim, nodule) {
     shim.enableDebug()
     instrumented.push(shim)
     instrumented.push({
-      __NR_unwrap: function unwrapNodule() {
-        delete nodule.__NR_instrumented_errored
-        delete nodule.__NR_instrumented
-        delete nodule.__NR_shim
+      [symbols.unwrap]: function unwrapNodule() {
+        delete nodule[symbols.instrumentedErrored]
+        delete nodule[symbols.instrumented]
+        delete nodule[symbols.shim]
       }
     })
-    nodule.__NR_shim = shim
+    nodule[symbols.shim] = shim
   }
 }
 
@@ -504,8 +510,8 @@ function applyDebugState(shim, nodule) {
 function instrumentPostLoad(agent, nodule, moduleName, resolvedName) {
   const instrumentation = shimmer.registeredInstrumentations[moduleName]
   if (
-    properties.hasOwn(nodule, '__NR_instrumented') ||
-    properties.hasOwn(nodule, '__NR_instrumented_errored')
+    properties.hasOwn(nodule, symbols.instrumented) ||
+    properties.hasOwn(nodule, symbols.instrumentedErrored)
   ) {
     logger.trace(
       'Already instrumented or failed to instrument %s, skipping redundant instrumentation',
@@ -527,10 +533,10 @@ function instrumentPostLoad(agent, nodule, moduleName, resolvedName) {
   try {
     if (instrumentation.onRequire(shim, nodule, moduleName) !== false) {
       nodule = shim.getExport(nodule)
-      nodule.__NR_instrumented = true
+      nodule[symbols.instrumented] = true
     }
   } catch (instrumentationError) {
-    nodule.__NR_instrumented_errored = true
+    nodule[symbols.instrumentedErrored] = true
     if (instrumentation.onError) {
       try {
         instrumentation.onError(instrumentationError)

package/lib/symbols.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2022 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+module.exports = {
+  cache: Symbol('cache'),
+  context: Symbol('context'),
+  databaseName: Symbol('databaseName'),
+  disableDT: Symbol('Disable distributed tracing'), // description for backwards compatibility
+  executorContext: Symbol('executorContext'),
+  instrumented: Symbol('instrumented'),
+  instrumentedErrored: Symbol('instrumentedErrored'),
+  name: Symbol('name'),
+  onceExecuted: Symbol('onceExecuted'),
+  offTheRecord: Symbol('offTheRecord'),
+  original: Symbol('original'),
+  segment: Symbol('segment'),
+  shim: Symbol('shim'),
+  storeDatabase: Symbol('storeDatabase'),
+  transaction: Symbol('transaction'),
+  transactionInfo: Symbol('transactionInfo'),
+  unwrap: Symbol('unwrap')
+}

package/lib/system-info.js

@@ -21,7 +21,7 @@ function isInteger(i) {
   return i === parseInt(i, 10)
 }
 
-function fetchSystemInfo(agent, callback) {
+function fetchSystemInfo(agent, callback, numTasks = 5) {
   const config = agent.config
   const systemInfo = {
     processorArch: os.arch()
@@ -74,7 +74,6 @@ function fetchSystemInfo(agent, callback) {
   }
 
   let tasksDone = 0
-  const numTasks = 5
   function finishedResponse() {
     if (++tasksDone === numTasks) {
       callback(null, systemInfo)

package/lib/transaction/tracer/index.js

@@ -7,12 +7,7 @@
 
 const Transaction = require('../index.js')
 const logger = require('../../logger').child({ component: 'tracer' })
-
-/*
- * CONSTANTS
- */
-const ORIGINAL = '__NR_original'
-const SEGMENT = '__NR_segment'
+const symbols = require('../../symbols')
 
 module.exports = Tracer
 
@@ -35,7 +30,6 @@ Tracer.prototype.transactionNestProxy = transactionNestProxy
 Tracer.prototype.bindFunction = bindFunction
 Tracer.prototype.bindEmitter = bindEmitter
 Tracer.prototype.getOriginal = getOriginal
-Tracer.prototype.getSegmentFromWrapped = getSegmentFromWrapped
 Tracer.prototype.slice = argSlice
 Tracer.prototype.wrapFunctionNoSegment = wrapFunctionNoSegment
 Tracer.prototype.wrapFunctionFirstNoSegment = wrapFunctionFirstNoSegment
@@ -124,7 +118,7 @@ function transactionProxy(handler) {
     return tracer.bindFunction(handler, transaction.trace.root, true).apply(this, arguments)
   }
 
-  wrapped[ORIGINAL] = handler
+  wrapped[symbols.original] = handler
 
   return wrapped
 }
@@ -175,7 +169,7 @@ function transactionNestProxy(type, handler) {
     return tracer.bindFunction(handler, segment).apply(this, arguments)
   }
 
-  wrapped[ORIGINAL] = handler
+  wrapped[symbols.original] = handler
 
   return wrapped
 }
@@ -188,8 +182,8 @@ function bindFunction(handler, segment, full) {
   return _makeWrapped(this, handler, segment || this.getSegment(), !!full)
 }
 function _makeWrapped(tracer, handler, active, full) {
-  wrapped[ORIGINAL] = getOriginal(handler)
-  wrapped[SEGMENT] = active
+  wrapped[symbols.original] = getOriginal(handler)
+  wrapped[symbols.segment] = active
 
   return wrapped
 
@@ -206,7 +200,7 @@ function _makeWrapped(tracer, handler, active, full) {
       logger.trace(err, 'Error from wrapped function:')
 
       if (prev === null && process.domain != null) {
-        process.domain.__NR_transactionSegment = tracer.getSegment()
+        process.domain[symbols.segment] = tracer.getSegment()
       }
 
       throw err // Re-throwing application error, this is not an agent error.
@@ -219,11 +213,11 @@ function _makeWrapped(tracer, handler, active, full) {
 }
 
 function getOriginal(fn) {
-  return fn && fn[ORIGINAL] ? fn[ORIGINAL] : fn
-}
-
-function getSegmentFromWrapped(fn) {
-  return fn && fn[SEGMENT] ? fn[SEGMENT] : null
+  const original = fn[symbols.original]
+  if (original) {
+    return original
+  }
+  return fn
 }
 
 function bindEmitter(emitter, segment) {
@@ -473,7 +467,7 @@ function wrapCallback(original, segment, wrapped) {
   return tracer.bindFunction(
     function wrappedCallback() {
       if (wrapped) {
-        wrapped[ORIGINAL] = original
+        wrapped[symbols.original] = original
       }
 
       const child = tracer.createSegment(

package/lib/util/arity.js

@@ -6,6 +6,7 @@
 'use strict'
 
 const hasOwnProperty = require('./properties').hasOwn
+const symbols = require('../symbols')
 
 // Starting in what we believe to be Node v4 you can set the name and length of
 // a function as properties. This is more ideal than wrapping a function.
@@ -16,17 +17,11 @@ function fixArity(original, wrapper) {
     name: { value: original.name },
     length: { value: original.length }
   }
+  Object.defineProperties(wrapper, toDefine)
 
-  if (!hasOwnProperty(wrapper, '__NR_name')) {
-    toDefine.__NR_name = {
-      configurable: false,
-      enumerable: false,
-      writable: false,
-      value: wrapper.name
-    }
+  if (!hasOwnProperty(wrapper, symbols.name)) {
+    wrapper[symbols.name] = wrapper.name
   }
 
-  Object.defineProperties(wrapper, toDefine)
-
   return wrapper
 }

package/lib/util/properties.js

@@ -7,16 +7,6 @@
 
 const hasOwnProperty = Object.hasOwnProperty
 
-// The logger needs to be lazy-loaded to get around ordering issues with config.
-let _logger = null
-let getLogger = function makeLogger() {
-  _logger = require('../logger').child({ component: 'util-properties' })
-  getLogger = function reallyGetLogger() {
-    return _logger
-  }
-  return _logger
-}
-
 /**
  * Checks if an object has its own property with the given key.
  *
@@ -53,39 +43,3 @@ exports.isEmpty = function isEmpty(obj) {
   }
   return true
 }
-
-/**
- * Sets a non-enumerable property on an object with the given value.
- *
- * XXX: This process is very slow, so use only when necessary. Check the
- * configuration `transaction_tracer.hide_internals` before calling this.
- *
- * @private
- *
- * @param {*}       obj   - The item to add the hidden property to.
- * @param {string}  name  - The name of the property to add.
- * @param {*}       val   - The value to set the property to.
- *
- * @return {*} The `obj` argument.
- */
-exports.setInternal = function setInternalProperty(obj, name, val) {
-  if (!obj || !name) {
-    getLogger().debug('Not setting property; object or name is missing.')
-    return obj
-  }
-
-  try {
-    if (!exports.hasOwn(obj, name)) {
-      Object.defineProperty(obj, name, {
-        enumerable: false,
-        writable: true,
-        value: val
-      })
-    } else {
-      obj[name] = val
-    }
-  } catch (err) {
-    getLogger().debug(err, 'Failed to set property "%s" to %j', name, val)
-  }
-  return obj
-}