newrelic 8.5.0 → 8.7.0

package/lib/config/index.js

@@ -229,6 +229,7 @@ Config.prototype.mergeServerConfig = mergeServerConfig
  * recognized, unsupported, and unknown parameters.
  *
  * @param {object} json The config blob sent by New Relic.
+ * @param recursion
  */
 Config.prototype.onConnect = function onConnect(json, recursion) {
   json = json || Object.create(null)
@@ -865,7 +866,7 @@ Config.prototype.checkAsyncHookStatus = function checkAsyncHookStatus() {
  * I wanted to cache the DisplayHost, but if I attached the variable to the config object,
  * it sends the extra variable to New Relic, which is not desired.
  *
- * @return {string} display host name
+ * @returns {string} display host name
  */
 Config.prototype.getDisplayHost = getDisplayHost
 
@@ -903,7 +904,7 @@ function getDisplayHost() {
  * I wanted to cache the Hostname, but if I attached the variable to the config object,
  * it sends the extra variable to New Relic, which is not desired.
  *
- * @return {string} host name
+ * @returns {string} host name
  */
 Config.prototype.getHostnameSafe = getHostnameSafe
 
@@ -980,6 +981,7 @@ Config.prototype.applications = function applications() {
  *
  * @param {object} external The configuration being loaded.
  * @param {object} internal Whichever chunk of the config being overridden.
+ * @param arbitrary
  */
 Config.prototype._fromPassed = function _fromPassed(external, internal, arbitrary) {
   if (!external) {
@@ -1065,6 +1067,8 @@ Config.prototype._featureFlagsFromEnv = function _featureFlagsFromEnv() {
  *                        need to set this yourself.
  * @param object data     The current level of the configuration object. Should
  *                        never need to set this yourself.
+ * @param metadata
+ * @param data
  */
 Config.prototype._fromEnvironment = function _fromEnvironment(metadata, data) {
   if (!metadata) {
@@ -1122,7 +1126,6 @@ Config.prototype._fromEnvironment = function _fromEnvironment(metadata, data) {
  * environment variable.
  *
  * @param {*} inputConfig configuration passed to the Config constructor
- *
  * @returns {boolean}
  */
 Config.prototype._loggingManuallySet = function _loggingManuallySet(inputConfig) {
@@ -1137,7 +1140,6 @@ Config.prototype._loggingManuallySet = function _loggingManuallySet(inputConfig)
  * file or enveironment variable
  *
  * @param {*} inputConfig configuration pass to the Config constructor
- *
  * @returns {boolean}
  */
 Config.prototype._nativeMetricsManuallySet = function _nativeMetricsManuallySet(inputConfig) {
@@ -1156,7 +1158,6 @@ Config.prototype._nativeMetricsManuallySet = function _nativeMetricsManuallySet(
  * environment variable.
  *
  * @param {*} inputConfig configuration passed to the Config constructor
- *
  * @returns {boolean}
  */
 Config.prototype._DTManuallySet = function _DTManuallySet(inputConfig) {
@@ -1173,6 +1174,7 @@ Config.prototype._DTManuallySet = function _DTManuallySet(inputConfig) {
  *   - disables cross_application_tracer.enabled if set
  *   - defaults logging to disabled
  *   - verifies data specific to running DT is defined either in config file of env vars
+ *
  * @param {*} inputConfig configuration passed to the Config constructor
  */
 Config.prototype._enforceServerless = function _enforceServerless(inputConfig) {
@@ -1282,7 +1284,7 @@ Config.prototype._canonicalize = function _canonicalize() {
   }
 
   const expectedCodes = this.error_collector && this.error_collector.expected_status_codes
-  if (statusCodes) {
+  if (expectedCodes) {
     this.error_collector.expected_status_codes = _parseCodes(expectedCodes)
   }
 
@@ -1410,7 +1412,6 @@ Config.prototype._applyHighSecurity = function _applyHighSecurity() {
  *
  * @param {Agent} agent
  * @param {object} policies
- *
  * @returns {CollectorResponse} The result of the processing, with the known
  *  policies as the response payload.
  */
@@ -1540,7 +1541,7 @@ function redactValue(value) {
  * Get a JSONifiable object containing all settings we want to report to the
  * collector and store in the environment_values table.
  *
- * @return Object containing simple key-value pairs of settings
+ * @returns Object containing simple key-value pairs of settings
  */
 Config.prototype.publicSettings = function publicSettings() {
   let settings = Object.create(null)
@@ -1683,6 +1684,8 @@ function initialize(config) {
 
 /**
  * This helper function creates an empty configuration object
+ *
+ * @param config
  */
 function createNewConfigObject(config) {
   config = new Config(Object.create(null))

package/lib/context-manager/create-context-manager.js

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2021 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const logger = require('../logger')
+
+/**
+ * Factory function to create context manager implementations used by the
+ * ContextManager class.
+ *
+ * @param {object} config New Relic config instance.
+ * @returns {*} The appropriate underlying context manager implementation based on
+ * the current configuration.
+ */
+function createContextManager(config) {
+  if (config.logging.diagnostics) {
+    logger.info('Using LegacyDiagnosticContextManager')
+
+    const LegacyDiagnosticContextManager = require('./diagnostics/legacy-diagnostic-context-manager')
+    return new LegacyDiagnosticContextManager(config)
+  }
+
+  logger.info('Using LegacyContextManager')
+
+  const LegacyContextManager = require('./legacy-context-manager')
+  return new LegacyContextManager(config)
+}
+
+module.exports = createContextManager

package/lib/context-manager/diagnostics/legacy-diagnostic-context-manager.js

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2021 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const LegacyContextManager = require('../legacy-context-manager')
+
+/**
+ * Overrides setContext to add diagnostic logging around setting and removing
+ * from context. Currently just supports the segment.probe().
+ *
+ * Exists in own class to keep default context management as minimal/efficient as possible
+ * given we wrap pretty much every functions execution.
+ */
+class LegacyDiagnosticContextManager extends LegacyContextManager {
+  setContext(newContext) {
+    this._logDiagnostic(this._context, 'Removed from context')
+
+    this._context = newContext
+
+    this._logDiagnostic(newContext, 'Set in context')
+  }
+
+  _logDiagnostic(context, message) {
+    // This is to currently support diagnostic logging of segments which gets attached to
+    // transactions with a stack trace. All of this is output at once at the end of a transaction
+    // when enabled for clear tracing.
+    if (context && context.probe) {
+      context.probe(message)
+    }
+  }
+}
+
+module.exports = LegacyDiagnosticContextManager

package/lib/context-manager/legacy-context-manager.js

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2021 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+/**
+ * Class for managing state in the agent.
+ * Keeps track of a single context instance.
+ *
+ * Given current usage with every instrumented function, the functions in this
+ * class should do as little work as possible to avoid unnecessary overhead.
+ *
+ * @class
+ */
+class LegacyContextManager {
+  /**
+   * @param {object} config New Relic config instance
+   */
+  constructor(config) {
+    this._config = config
+    this._context = null
+  }
+
+  /**
+   * Get the currently active context.
+   *
+   * @returns {object} The current active context.
+   */
+  getContext() {
+    return this._context
+  }
+
+  /**
+   * Set a new active context. Not bound to function execution.
+   *
+   * @param {object} newContext The context to set as active.
+   */
+  setContext(newContext) {
+    this._context = newContext
+  }
+
+  /**
+   * Run a function with the passed in context as the active context.
+   * Restores the previously active context upon completion.
+   *
+   * @param {object} context The context to set as active during callback execution.
+   * @param {Function} callback The function to execute in context.
+   * @param {Function} [cbThis] Optional `this` to apply to the callback.
+   * @param {Array<*>} [args] Optional arguments object or args array to invoke the callback with.
+   * @returns {*} Returns the value returned by the callback function.
+   */
+  runInContext(context, callback, cbThis, args) {
+    const oldContext = this.getContext()
+    this.setContext(context)
+
+    try {
+      return callback.apply(cbThis, args)
+    } finally {
+      this.setContext(oldContext)
+    }
+  }
+}
+
+module.exports = LegacyContextManager

package/lib/instrumentation/mongodb/common.js

@@ -47,9 +47,11 @@ common.instrumentCollection = function instrumentCollection(shim, Collection) {
  * Instruments all methods from constants.DB_OPS on
  * the Db class.
  *
- * @param {Object} params
+ * @param {object} params
  * @param {Shim} params.shim
  * @param {Db} params.Db
+ * @param shim
+ * @param Db
  */
 common.instrumentDb = function instrumentDb(shim, Db) {
   if (Db && Db.prototype) {
@@ -62,6 +64,7 @@ common.instrumentDb = function instrumentDb(shim, Db) {
 
 /**
  * Sets up the desc for all instrumented query methods
+ *
  * @param {Shim} shim
  * @param {string} methodName
  */
@@ -123,7 +126,7 @@ common.captureAttributesOnStarted = function captureAttributesOnStarted(shim, in
  * @param {Shim} shim
  * @param {string} connStr
  * @param {string} db database name
- * @param {Object} client mongo client instance
+ * @param {object} client mongo client instance
  */
 function setHostPort(shim, connStr, db, client) {
   const parts = connStr.split(':')
@@ -153,6 +156,9 @@ function setHostPort(shim, connStr, db, client) {
  * for the query segment. v4 refactored where the toplogy is stored.
  * You can now get the details via the client obj that's deeply nested
  * See: https://github.com/mongodb/node-mongodb-native/pull/2594/files#diff-1d214e57ddda9095d296e5700ebce701333bfefcf417e234c584d14091b2f50dR168
+ *
+ * @param shim
+ * @param obj
  */
 function getInstanceAttributeParameters(shim, obj) {
   if (obj.s && obj.s.db && obj.s.topology) {
@@ -197,8 +203,10 @@ function getInstanceAttributeParameters(shim, obj) {
   }
 
   function doCapture(conf, database) {
-    let host = null
-    let port = null
+    // in older versions of 3.x the host/port
+    // lived directly on the topology.s.options
+    let host = conf.host
+    let port = conf.port
 
     // servers is an array but we will always pull the first for consistency
     if (conf.servers && conf.servers.length) {

package/lib/instrumentation/promise.js

@@ -11,28 +11,22 @@ const shimmer = require('../shimmer')
 
 /**
  * @namespace Library.Spec
- *
  * @property {string} name
  *  The name of this promise library.
- *
  * @property {?string} constructor
  *  Optional. The name of the property that is the Promise constructor. Default
  *  is to use the library itself as the Promise constructor.
- *
  * @property {?bool} executor
  *  Optional. If true, the Promise constructor itself will be wrapped for the
  *  executor. If false then `_proto`, `_static`, or `_library` must have an
  *  `executor` field whose value is the name of the executor function. Default
  *  is false.
- *
  * @property {Library.Spec.Mapping} $proto
  *  The mapping for Promise instance method concepts (i.e. `then`). These are
  *  mapped on the Promise class' prototype.
- *
  * @property {Library.Spec.Mapping} $static
  *  The mapping for Promise static method concepts (i.e. `all`, `race`). These
  *  are mapped on the Promise class itself.
- *
  * @property {?Library.Spec.Mapping} $library
  *  The mapping for library-level static method concepts (i.e. `fcall`, `when`).
  *  These are mapped on the library containing the Promise class. NOTE: in most
@@ -42,35 +36,23 @@ const shimmer = require('../shimmer')
 
 /**
  * @namespace Library.Spec.Mapping
- *
- * @desc
+ * @description
  *   A mapping of promise concepts (i.e. `then`) to this library's implementation
  *   name(s) (i.e. `["then", "chain"]`). Each value can by either a single string
  *   or an array of strings if the concept exists under multiple keys. If any
  *   given concept doesn't exist in this library, it is simply skipped.
- *
- * @property {array} $copy
+ * @property {Array} $copy
  *  An array of properties or methods to just directly copy without wrapping.
  *  This field only matters when `Library.Spec.executor` is `true`.
- *
- * @property {string|array} executor
- *
- *
- * @property {string|array} then
- *
- *
- * @property {string|array} all
- *
- *
- * @property {string|array} race
- *
- *
- * @property {string|array} resolve
+ * @property {string | Array} executor
+ * @property {string | Array} then
+ * @property {string | Array} all
+ * @property {string | Array} race
+ * @property {string | Array} resolve
  *  Indicates methods to wrap which are resolve factories. This method only
  *  requires wrapping if the library doesn't use an executor internally to
  *  implement it.
- *
- * @property {string|array} reject
+ * @property {string | Array} reject
  *  Indicates methods to wrap which are reject factories. Like `resolve`, this
  *  method only requires wrapping if the library doesn't use an executor
  *  internally to implement it.
@@ -80,11 +62,13 @@ const shimmer = require('../shimmer')
  * Instruments a promise library.
  *
  * @param {Agent}         agent   - The New Relic APM agent.
- * @param {function}      library - The promise library.
+ * @param {Function}      library - The promise library.
  * @param {?Library.Spec} spec    - Spec for this promise library mapping.
  */
 /* eslint-disable camelcase */
 module.exports = function initialize(agent, library, spec) {
+  const contextManager = agent._contextManager
+
   if (spec.useFinally == null) {
     spec.useFinally = true
   }
@@ -144,7 +128,7 @@ module.exports = function initialize(agent, library, spec) {
       return Promise(executor) // eslint-disable-line new-cap
     }
 
-    const parent = agent.tracer.segment
+    const parent = contextManager.getContext()
     let promise = null
     if (
       !parent ||
@@ -170,15 +154,13 @@ module.exports = function initialize(agent, library, spec) {
       const segment = _createSegment(segmentName)
       Contextualizer.link(null, promise, segment, spec.useFinally)
 
-      agent.tracer.segment = segment
       segment.start()
       try {
         // Must run after promise is defined so that `__NR_wrapper` can be set.
-        executor.apply(context.self, context.args)
+        contextManager.runInContext(segment, executor, context.self, context.args)
       } catch (e) {
         context.args[1](e)
       } finally {
-        agent.tracer.segment = parent
         segment.touch()
       }
     }
@@ -259,8 +241,7 @@ module.exports = function initialize(agent, library, spec) {
    * execution.
    *
    * @param {object} context - The object to export the execution context with.
-   *
-   * @return {function} A function which, when executed, will add its context
+   * @returns {Function} A function which, when executed, will add its context
    *  and arguments to the `context` parameter.
    */
   function wrapExecutorContext(context) {
@@ -285,7 +266,9 @@ module.exports = function initialize(agent, library, spec) {
   /**
    * Creates a wrapper for `Promise#then` that extends the transaction context.
    *
-   * @return {function} A wrapped version of `Promise#then`.
+   * @param then
+   * @param name
+   * @returns {Function} A wrapped version of `Promise#then`.
    */
   function wrapThen(then, name) {
     return _wrapThen(then, name, true)
@@ -294,7 +277,9 @@ module.exports = function initialize(agent, library, spec) {
   /**
    * Creates a wrapper for `Promise#catch` that extends the transaction context.
    *
-   * @return {function} A wrapped version of `Promise#catch`.
+   * @param cach
+   * @param name
+   * @returns {Function} A wrapped version of `Promise#catch`.
    */
   function wrapCatch(cach, name) {
     return _wrapThen(cach, name, false)
@@ -303,14 +288,13 @@ module.exports = function initialize(agent, library, spec) {
   /**
    * Creates a wrapper for promise chain extending methods.
    *
-   * @param {function} then
+   * @param {Function} then
    *  The function we are to wrap as a chain extender.
-   *
+   * @param name
    * @param {bool} useAllParams
    *  When true, all parameters which are functions will be wrapped. Otherwise,
    *  only the last parameter will be wrapped.
-   *
-   * @return {function} A wrapped version of the function.
+   * @returns {Function} A wrapped version of the function.
    */
   function _wrapThen(then, name, useAllParams) {
     // Don't wrap non-functions.
@@ -377,6 +361,9 @@ module.exports = function initialize(agent, library, spec) {
 
   /**
    * Creates a wrapper around the static `Promise` factory method.
+   *
+   * @param cast
+   * @param name
    */
   function wrapCast(cast, name) {
     if (typeof cast !== 'function' || cast.name === '__NR_wrappedCast') {
@@ -437,8 +424,8 @@ module.exports = function initialize(agent, library, spec) {
  *
  * @param {object}        obj     - The source of the methods to wrap.
  * @param {string}        name    - The name of this source.
- * @param {string|array}  methods - The names of the methods to wrap.
- * @param {function}      wrapper - The function which wraps the methods.
+ * @param {string | Array}  methods - The names of the methods to wrap.
+ * @param {Function}      wrapper - The function which wraps the methods.
  */
 function _safeWrap(obj, name, methods, wrapper) {
   if (methods && methods.length) {

package/lib/metrics/names.js

@@ -252,7 +252,11 @@ const INFINITE_TRACING = {
 }
 
 const FEATURES = {
-  CERTIFICATES: SUPPORTABILITY.FEATURES + '/Certificates'
+  CERTIFICATES: SUPPORTABILITY.FEATURES + '/Certificates',
+  INSTRUMENTATION: {
+    ON_RESOLVED: SUPPORTABILITY.FEATURES + '/Instrumentation/OnResolved',
+    ON_REQUIRE: SUPPORTABILITY.FEATURES + '/Instrumentation/OnRequire'
+  }
 }
 
 module.exports = {

package/lib/parse-proc-cpuinfo.js

@@ -17,6 +17,12 @@ function parseProcCPUInfo(data) {
     packages: null
   }
 
+  // In some rare cases the OS may be locked down so that you cannot retrieve this info.
+  if (!data) {
+    logger.debug('No CPU data to parse, returning empty stats.')
+    return processorStats
+  }
+
   // separate the processors
   let splitData = data.split('\n').map(function formatAttribute(attr) {
     return attr.split(':').map(function eliminateExtraWhitespace(s) {
@@ -34,7 +40,7 @@ function parseProcCPUInfo(data) {
 
   splitData = collapseMultilineValues(splitData)
 
-  const processors = seperateProcessors(splitData)
+  const processors = separateProcessors(splitData)
 
   processorStats = countProcessorStats(processors)
   if (!processorStats.cores) {
@@ -73,7 +79,7 @@ function collapseMultilineValues(li) {
 
 // walk through the processed list of key, value pairs and populate
 // objects till you find a collision
-function seperateProcessors(processorData) {
+function separateProcessors(processorData) {
   const processors = []
   let processor = Object.create(null)
   for (let i = 0; i < processorData.length; ++i) {

package/lib/parse-proc-meminfo.js

@@ -10,6 +10,12 @@ const logger = require('./logger.js').child({ component: 'proc-meminfo' })
 module.exports = parseProcMeminfo
 
 function parseProcMeminfo(data) {
+  // In some rare cases the OS may be locked down so that you cannot retrieve this info.
+  if (!data) {
+    logger.debug('No memory data to parse.')
+    return null
+  }
+
   const memTotal = parseInt(data.replace(/MemTotal:\s*(\d*)\skB/, '$1'), 10)
 
   if (memTotal) {

package/lib/serverless/aws-lambda.js

@@ -82,8 +82,14 @@ class AwsLambda {
       // NOTE: This may be converted to holding onto a single ender function if only
       // one invocation is executing at a time.
       shim.wrap(process, 'emit', function wrapEmit(shim, emit) {
-        return function wrappedEmit(ev) {
-          if (ev === 'beforeExit') {
+        return function wrappedEmit(ev, error) {
+          // need to add error as uncaughtException to be used
+          // later to add to transaction errors
+          if (ev === 'unhandledRejection') {
+            uncaughtException = error
+          }
+
+          if (['beforeExit', 'unhandledRejection'].includes(ev)) {
             transactionEnders.forEach((ender) => {
               ender()
             })