newrelic 7.2.0 → 7.4.0

package/NEWS.md

@@ -1,3 +1,65 @@
+### v7.4.0 (2021-05-11)
+
+* Updated third party notices and manifest for husky and lint-staged.
+
+* Updated redis versioned tests to use unique DB indexes per file to avoid collisions and flushing of in-progress tests.
+
+* Pinned hapi 17 versioned tests to only minor/patch versions within 17.x.
+
+* Bumped timeout for redis versioned tests.
+
+* Wired up husky + lint staged to execute linting on all changed files in pre-commit hook.
+
+* Handled a proxy misconfiguration of collector and log an actionable warning message.
+
+* Added `flaky_code` and `success_delay_ms` handling of flaky grpc connections to infinite tracing.
+
+* Added resources to README to highlight external modules that customers should be aware of and possibly use for their applications.
+
+* Logged all New Relic metadata env vars at startup.
+
+* Fixed images for improved reader experience.
+
+  Thank you to @henryjw for the contribution.
+
+### v7.3.1 (2021-04-14)
+
+* Fixed issue with 'new_promise_tracking' feature flag functionality where segments for ended transactions would get propagated in certain cases by promises that had no continuations scheduled (via await or manually).
+
+  If you are experiencing high overhead levels with your promise usage and the agent attached, we recommend testing your application with  'new_promise_tracking' set to true to see if overhead is reduced. You'll also want to verify your data is still being captured correctly in case it falls into a known or unknown limitation of this approach.  **NOTE: chaining of promise continuations onto an already resolved promise across an async hop (scheduled timer) will result in state-loss with this new functionality turned on. This is a less-common use-case but worth considering with your applications.**
+
+**Deprecation Warning:** The certificate bundle automatically included by New Relic when using the 'certificates' configuration (commonly with proxies) will be disabled by default in the next major version. This is currently targeted for sometime in May. The bundle will be fully removed in later major versions. We recommend testing with the 'certificate_bundle' feature flag set to `false` to determine if you will need to modify your environment or setup your own appropriate bundle. Example configuration: `feature_flag: { certificate_bundle: false }`.
+
+### v7.3.0 (2021-04-06)
+
+* Added new feature-flag 'new_promise_tracking' which enables cleaning up of segment references on native promise resolve instead of destroy. Includes usage of async-await. This can be enabled via `feature_flag: { new_promise_tracking: true }` in the config file or `NEW_RELIC_FEATURE_FLAG_NEW_PROMISE_TRACKING=1` in your ENV vars.
+
+  Applications with heavy promise usage or high-throughput applications with some promise usage should see moderate to high reduction in memory usage and may see a slight reduction in CPU usage. A bump in throughput may also be noticed in some cases. Results will vary by application.
+
+  If you are experiencing high overhead levels with your promise usage and the agent attached, we recommend testing your application with  'new_promise_tracking' set to true to see if overhead is reduced. You'll also want to verify your data is still being captured correctly in case it falls into a known or unknown limitation of this approach.  **NOTE: chaining of promise continuations onto an already resolved promise across an async hop (scheduled timer) will result in state-loss with this new functionality turned on. This is a less-common use-case but worth considering with your applications.**
+
+* Fixed memory leak introduced when Infinite Tracing is enabled.
+
+  When Infinite Tracing endpoints reconnected they would instantiate a new gRPC client prior to calling `client.recordSpan()`. It appears several objects created by grpc-js (`ChannelImplementation` and child objects, promises, etc.) are held in memory indefinitely due to scheduled timers even when the client is no-longer referenced and the associated stream closed. We now avoid this situation by only creating the client once and then reusing it to establish new stream connections.
+
+### v7.2.1 (2021-03-29)
+
+* Dev-only sub-dependency bump of 'y18n' to clear npm audit warnings.
+
+* Bumped @grpc/grpc-js to ^1.2.11.
+
+* Bumped @grpc/proto-loader to ^0.5.6.
+
+* Agent no longer propagates segments for promises via async-hooks when the transaction associated with the parentSegment has ended.
+
+  This change reduces the amount of context tracking work needed for certain rare edge-case scenarios involving promises.
+
+* Fixed issue where capturing axios request errors could result in a memory leak.
+
+  The agent now clears error references on transaction end, which are not used for later processing. Errors returned from 'axios' requests contain a reference to the request object which deeper down has a handle to a promise in `handleRequestError`. The TraceSegment associated with that promise has a handle to the transaction, which through the error capture ultimately kept the promise in memory and prevented it from being destroyed to free-up the TraceSegment from the segment map. This change also has the benefit of  freeing up some memory early for transactions held onto for transaction traces.
+
+* Added active transaction check to `wrappedResEnd` to prevent unecessary work for ended transactions in the case of multiple `Response.prototype.end()` invocations.
+
 ### v7.2.0 (2021-03-23)
 
 * Added feature flag to allow disabling of certificate bundle usage.

package/README.md

@@ -52,7 +52,7 @@ To use New Relic's Node.js agent entails these three steps, which are described
     /* ... the rest of your program ... */
 ```
 
-If you're compiling your JavaScript and can't control the final `require` order, the Node,js agent will work with node's `-r/--require` flag.
+If you're compiling your JavaScript and can't control the final `require` order, the Node.js agent will work with node's `-r/--require` flag.
 
     $ node -r newrelic your-program.js
     $ node --require newrelic your-program.js
@@ -61,11 +61,26 @@ If you're compiling your JavaScript and can't control the final `require` order,
 
 For more information on getting started, [check the Node.js docs](https://docs.newrelic.com/docs/agents/nodejs-agent/getting-started/introduction-new-relic-nodejs).
 
+### External Modules
+
+There are several modules that can be installed and configured to accompany the Node.js agent:
+
+ * [@newrelic/apollo-server-plugin](https://github.com/newrelic/newrelic-node-apollo-server-plugin): New Relic's official Apollo Server plugin for use with the Node.js agent.
+ * [@newrelic/winston-enricher](https://github.com/newrelic/newrelic-winston-logenricher-node): Provides distributed trace and span information output as JSON-formatted log messages.  This is most commonly used with the New Relic Logs product.
+ * [@newrelic/mysql](https://github.com/newrelic/node-newrelic-mysql)(**Experimental**): Standalone instrumentation for [mysql2](https://github.com/sidorares/node-mysql2#readme) and [mysql2/promise](https://github.com/sidorares/node-mysql2/blob/master/documentation/Promise-Wrapper.md) as well as the same instrumentation for [mysql](https://github.com/mysqljs/mysql#readme) within the Node.js agent.
+
+There are several modules included within the Node.js agent to add more instrumentation for 3rd party modules:
+
+ * [@newrelic/aws-sdk](https://github.com/newrelic/node-newrelic-aws-sdk):  Provides instrumentation for the [AWS SDK](https://www.npmjs.com/package/aws-sdk) npm package.
+ * [@newrelic/koa](https://github.com/newrelic/node-newrelic-koa): Provides instrumentation for [koa](https://koajs.com/), [koa-router](https://github.com/ZijianHe/koa-router), [@koa/router](https://github.com/koajs/router), and [koa-route](https://github.com/koajs/route) npm packages.
+ * [@newrelic/superagent](https://github.com/newrelic/node-newrelic-superagent): Provides instrumentation for [superagent](https://github.com/visionmedia/superagent) npm package.
+ * [@newrelic/native-metrics](https://github.com/newrelic/node-native-metrics): Provides hooks into the native v8 layer of Node.js to provide metrics to the Node.js agent.
+
 ## Usage
 
 ### Using the API
 
-The `newrelic` module returns an object with the Node agent's API methods attached.
+The `newrelic` module returns an object with the Node.js agent's API methods attached.
 
 ```js
     const newrelic = require('newrelic')

package/THIRD_PARTY_NOTICES.md

@@ -49,7 +49,9 @@ code, the source code can be found at [https://github.com/newrelic/node-newrelic
 * [glob](#glob)
 * [got](#got)
 * [http-errors](#http-errors)
+* [husky](#husky)
 * [jsdoc](#jsdoc)
+* [lint-staged](#lint-staged)
 * [memcached](#memcached)
 * [minami](#minami)
 * [mongodb](#mongodb)
@@ -75,7 +77,7 @@ code, the source code can be found at [https://github.com/newrelic/node-newrelic
 
 ### @grpc/grpc-js
 
-This product includes source derived from [@grpc/grpc-js](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js) ([v1.2.7](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js/tree/v1.2.7)), distributed under the [Apache-2.0 License](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js/blob/v1.2.7/LICENSE):
+This product includes source derived from [@grpc/grpc-js](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js) ([v1.2.11](https://github.com/grpc/grpc-node/tree/%40grpc/grpc-js%401.2.11/packages/grpc-js)), distributed under the [Apache-2.0 License](https://github.com/grpc/grpc-node/blob/%40grpc/grpc-js%401.2.11/packages/grpc-js/LICENSE):
 
 ```
                                  Apache License
@@ -284,7 +286,7 @@ This product includes source derived from [@grpc/grpc-js](https://github.com/grp
 
 ### @grpc/proto-loader
 
-This product includes source derived from [@grpc/proto-loader](https://github.com/grpc/grpc-node) ([v0.5.5](https://github.com/grpc/grpc-node/tree/v0.5.5)), distributed under the [Apache-2.0 License](https://github.com/grpc/grpc-node/blob/v0.5.5/LICENSE):
+This product includes source derived from [@grpc/proto-loader](https://github.com/grpc/grpc-node) ([v0.5.6](https://github.com/grpc/grpc-node/tree/%40grpc/proto-loader%400.5.6/packages/proto-loader)), distributed under the [Apache-2.0 License](https://github.com/grpc/grpc-node/blob/%40grpc/proto-loader%400.5.6/packages/proto-loader/LICENSE):
 
 ```
                                  Apache License
@@ -1927,7 +1929,7 @@ SOFTWARE.
 
 ### commander
 
-This product includes source derived from [commander](https://github.com/tj/commander.js) ([v7.0.0](https://github.com/tj/commander.js/tree/v7.0.0)), distributed under the [MIT License](https://github.com/tj/commander.js/blob/v7.0.0/LICENSE):
+This product includes source derived from [commander](https://github.com/tj/commander.js) ([v7.2.0](https://github.com/tj/commander.js/tree/v7.2.0)), distributed under the [MIT License](https://github.com/tj/commander.js/blob/v7.2.0/LICENSE):
 
 ```
 (The MIT License)
@@ -2016,7 +2018,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 ### fastify
 
-This product includes source derived from [fastify](https://github.com/fastify/fastify) ([v2.14.1](https://github.com/fastify/fastify/tree/v2.14.1)), distributed under the [MIT License](https://github.com/fastify/fastify/blob/v2.14.1/LICENSE):
+This product includes source derived from [fastify](https://github.com/fastify/fastify) ([v2.15.3](https://github.com/fastify/fastify/tree/v2.15.3)), distributed under the [MIT License](https://github.com/fastify/fastify/blob/v2.15.3/LICENSE):
 
 ```
 MIT License
@@ -2139,6 +2141,35 @@ THE SOFTWARE.
 
 ```
 
+### husky
+
+This product includes source derived from [husky](https://github.com/typicode/husky) ([v6.0.0](https://github.com/typicode/husky/tree/v6.0.0)), distributed under the [MIT License](https://github.com/typicode/husky/blob/v6.0.0/LICENSE):
+
+```
+MIT License
+
+Copyright (c) 2021 typicode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+```
+
 ### jsdoc
 
 This product includes source derived from [jsdoc](https://github.com/jsdoc/jsdoc) ([v3.6.3](https://github.com/jsdoc/jsdoc/tree/v3.6.3)), distributed under the [Apache-2.0 License](https://github.com/jsdoc/jsdoc/blob/v3.6.3/LICENSE.md):
@@ -2249,6 +2280,35 @@ https://github.com/jmblog/color-themes-for-google-code-prettify
 
 ```
 
+### lint-staged
+
+This product includes source derived from [lint-staged](https://github.com/okonet/lint-staged) ([v11.0.0](https://github.com/okonet/lint-staged/tree/v11.0.0)), distributed under the [MIT License](https://github.com/okonet/lint-staged/blob/v11.0.0/LICENSE):
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2016 Andrey Okonetchnikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+```
+
 ### memcached
 
 This product includes source derived from [memcached](https://github.com/3rd-Eden/node-memcached) ([v2.2.2](https://github.com/3rd-Eden/node-memcached/tree/v2.2.2)), distributed under the [MIT License](https://github.com/3rd-Eden/node-memcached/blob/v2.2.2/LICENSE):

package/lib/collector/api.js

@@ -117,6 +117,22 @@ CollectorAPI.prototype.connect = function connect(callback) {
     this._reqHeadersMap = null
   }
 
+  /**
+   * Checks if proxy is configured to connect via `proxy_host` and `proxy_port`
+   * and if error code is EPROTO or ECONNRESET. This is an indication their proxy
+   * server only accepts HTTP connections, and we should provide an actionable warning to
+   * fix the misconfiguration by setting `proxy` to a fully qualified URL
+   *
+   * @param {Error} error
+   * @returns {Boolean}
+   */
+  function isProxyMisconfigured(error) {
+    const config = api._agent.config
+    return error &&
+      ['EPROTO', 'ECONNRESET'].includes(error.code) &&
+      config.proxy_host && config.proxy_port && !config.proxy
+  }
+
   function retry(error, response) {
     metric.incrementCallCount()
 
@@ -142,6 +158,14 @@ CollectorAPI.prototype.connect = function connect(callback) {
         ' (status code %s)',
         response.status
       )
+    } else if (isProxyMisconfigured(error)) {
+      logger.warn(
+        error,
+        'Your proxy server appears to be configured to accept connections over http. ' +
+        'When setting `proxy_host` and `proxy_port` New Relic attempts to connect over ' +
+        'SSL(https). If your proxy is configured to accept connections over http, try ' +
+        'setting `proxy` to a fully qualified URL(e.g http://proxy-host:8080).'
+      )
     }
 
     let backoff = BACKOFFS[Math.min(attempts, max) - 1]

package/lib/collector/facts.js

@@ -55,6 +55,8 @@ function facts(agent, callback) {
       }, {})
     }
 
+    logger.debug('New Relic metadata %o', results.metadata)
+
     results.event_harvest_config = {
       harvest_limits: {
         analytic_event_data: agent.config.transaction_events.max_samples_stored,

package/lib/feature_flags.js

@@ -15,7 +15,8 @@ exports.prerelease = {
   fastify_instrumentation: false,
   // Starts by defaulting true as introducing for deprecation/removal purposes.
   // Will eventually set false prior full removal of feature.
-  certificate_bundle: true
+  certificate_bundle: true,
+  new_promise_tracking: false
 }
 
 // flags that are no longer used for released features

package/lib/grpc/connection.js

@@ -11,17 +11,23 @@ const logger = require('../logger').child({component: 'grpc_connection'})
 const EventEmitter = require('events')
 const NAMES = require('../metrics/names')
 const util = require('util')
+const GRPC_TEST_META = {
+  flaky: 'NEWRELIC_GRPCCONNECTION_METADATA_FLAKY',
+  delay: 'NEWRELIC_GRPCCONNECTION_METADATA_DELAY',
+  flaky_code: 'NEWRELIC_GRPCCONNECTION_METADATA_FLAKY_CODE',
+  success_delay_ms: 'NEWRELIC_GRPCCONNECTION_METADATA_SUCCESS_DELAY_MS'
+}
 
 const connectionStates = require('./connection/states')
 
-const protoOptions = {keepCase: true,
+const PROTO_OPTIONS = {keepCase: true,
   longs: String,
   enums: String,
   defaults: true,
   oneofs: true
 }
 
-const pathProtoDefinition = __dirname +
+const PROTO_DEFINITION_PATH = __dirname +
   '../../../lib/grpc/endpoints/infinite-tracing/v1.proto'
 
 const DEFAULT_RECONNECT_DELAY_MS = 15 * 1000
@@ -54,11 +60,13 @@ class GrpcConnection extends EventEmitter {
     this._metrics = metrics
     this._setState(connectionStates.disconnected)
 
-    this._endpoint = this.getTraceObserverEndpoint(traceObserverConfig)
     this._licensekey = null
     this._runId = null
     this._requestHeadersMap = null
 
+    this._endpoint = this.getTraceObserverEndpoint(traceObserverConfig)
+
+    this._client = null
     this.stream = null
   }
 
@@ -161,22 +169,27 @@ class GrpcConnection extends EventEmitter {
       }
     }
 
-    // check environment variables for testing parameters and
-    // pass to server via meta-data.
-    const flaky = parseInt(env.NEWRELIC_GRPCCONNECTION_METADATA_FLAKY, 10)
-    const delay = parseInt(env.NEWRELIC_GRPCCONNECTION_METADATA_DELAY, 10)
-    if (flaky) {
-      logger.trace('Adding flaky metadata: %s', flaky)
-      metadata.add('flaky', flaky)
-    }
-    if (delay) {
-      logger.trace('Adding delay metadata: %s', delay)
-      metadata.add('delay',delay)
-    }
+    this._setTestMetadata(metadata, env)
 
     return metadata
   }
 
+  /**
+   * Adds test metadata used to simulate connectivity issues
+   * when appropriate env vars are set
+   *
+   * @param {Metadata} metadata
+   */
+  _setTestMetadata(metadata, env) {
+    for (const [key, envVar] of Object.entries(GRPC_TEST_META)) {
+      const value = parseInt(env[envVar], 10)
+      if (value) {
+        logger.trace('Adding %s metadata: %s', key, value)
+        metadata.add(key, value)
+      }
+    }
+  }
+
   /**
    * Disconnects from gRPC endpoint and schedules establishing a new connection.
    * @param {number} reconnectDelayMs number of milliseconds to wait before reconnecting.
@@ -320,26 +333,48 @@ class GrpcConnection extends EventEmitter {
    * a stream for further writing.
    */
   _connectSpans() {
-    const packageDefinition = protoLoader.loadSync(pathProtoDefinition, protoOptions)
-
-    const serviceDefinition = grpc.loadPackageDefinition(
-      packageDefinition
-    ).com.newrelic.trace.v1
-
-    const credentials = this._generateCredentials(grpc)
-    const client = new serviceDefinition.IngestService(
-      this._endpoint,
-      credentials
-    )
+    if (!this._client) {
+      // Only create once to avoid potential memory leak.
+      // We create here (currently) for consistent error handling.
+      this._client = this._createClient(this._endpoint)
+    }
 
     const metadata =
       this._getMetadata(this._licenseKey, this._runId, this._requestHeadersMap, process.env)
 
-    const stream = client.recordSpan(metadata)
+    const stream = this._client.recordSpan(metadata)
     this._setupSpanStreamObservers(stream)
 
     return stream
   }
+
+  /**
+   * Creates gRPC service client to use for establishing gRPC streams.
+   *
+   * WARNING: creating a client more than once can result in a memory leak.
+   * ChannelImplementation and related objects will stay in memory even after
+   * the stream is closed and we do not have a handle to the client. Currently
+   * impacting grpc-js@1.2.11 and several earlier versions.
+   */
+  _createClient(endpoint) {
+    logger.trace('Creating gRPC client for: ', endpoint)
+
+    const packageDefinition = protoLoader.loadSync(PROTO_DEFINITION_PATH, PROTO_OPTIONS)
+
+    const protoDescriptor = grpc.loadPackageDefinition(
+      packageDefinition
+    )
+
+    const traceApi = protoDescriptor.com.newrelic.trace.v1
+
+    const credentials = this._generateCredentials(grpc)
+    const client = new traceApi.IngestService(
+      endpoint,
+      credentials
+    )
+
+    return client
+  }
 }
 
 module.exports = GrpcConnection

package/lib/instrumentation/core/async_hooks.js

@@ -40,7 +40,7 @@ function initialize(agent, shim) {
 }
 
 function tryAsyncHooks(agent, shim) {
-  var asyncHooks = null
+  let asyncHooks = null
   try {
     asyncHooks = require('async_hooks')
   } catch (e) {
@@ -50,19 +50,45 @@ function tryAsyncHooks(agent, shim) {
 
   // this map is reused to track the segment that was active when
   // the before callback is called to be replaced in the after callback
-  var segmentMap = new Map()
+  const segmentMap = new Map()
   module.exports.segmentMap = segmentMap
 
-  var hook = asyncHooks.createHook({
+  let hookHandlers = getStandardHooks(segmentMap, agent, shim)
+
+  if (agent.config.feature_flag.new_promise_tracking) {
+    logger.info('Enabling new promise tracking style via new_promise_tracking feature flag.')
+    hookHandlers = getPromiseResolveStyleHooks(segmentMap, agent, shim)
+  }
+
+  const hook = asyncHooks.createHook(hookHandlers)
+  hook.enable()
+
+  agent.on('unload', function disableHook() {
+    hook.disable()
+  })
+
+  return true
+}
+
+function getStandardHooks(segmentMap, agent, shim) {
+  const hooks = {
     init: function initHook(id, type, triggerId, promiseWrap) {
-      var transaction = agent.getTransaction()
-      var parentSegment = segmentMap.get(triggerId)
+      if (type !== 'PROMISE') {
+        return
+      }
+
+      const parentSegment = segmentMap.get(triggerId)
 
-      if (!parentSegment && !transaction || type !== 'PROMISE') {
+      if (parentSegment && !parentSegment.transaction.isActive()) {
+        // Stop propagating if the transaction was ended.
         return
       }
 
-      var activeSegment = shim.getActiveSegment() || parentSegment
+      if (!parentSegment && !agent.getTransaction()) {
+        return
+      }
+
+      const activeSegment = shim.getActiveSegment() || parentSegment
       if (promiseWrap && promiseWrap.promise) {
         promiseWrap.promise.__NR_id = id
       }
@@ -70,7 +96,7 @@ function tryAsyncHooks(agent, shim) {
     },
 
     before: function beforeHook(id) {
-      var hookSegment = segmentMap.get(id)
+      const hookSegment = segmentMap.get(id)
 
       if (!hookSegment) {
         return
@@ -80,7 +106,7 @@ function tryAsyncHooks(agent, shim) {
       shim.setActiveSegment(hookSegment)
     },
     after: function afterHook(id) {
-      var hookSegment = segmentMap.get(id)
+      const hookSegment = segmentMap.get(id)
 
       // hookSegment is the segment that was active before the promise
       // executed. If the promise is executing before a segment has been
@@ -96,11 +122,77 @@ function tryAsyncHooks(agent, shim) {
     destroy: function destHook(id) {
       segmentMap.delete(id)
     }
-  }).enable()
+  }
 
-  agent.on('unload', function disableHook() {
-    hook.disable()
-  })
+  return hooks
+}
 
-  return true
+function getPromiseResolveStyleHooks(segmentMap, agent, shim) {
+  const hooks = {
+    init: function initHook(id, type, triggerId, asyncResource) {
+      if (type !== 'PROMISE') {
+        return
+      }
+
+      let parentSegment = segmentMap.get(triggerId)
+
+      if (parentSegment && !parentSegment.transaction.isActive()) {
+        // Stop propagating if the transaction was ended.
+        return
+      }
+
+      if (!parentSegment && !agent.getTransaction()) {
+        return
+      }
+
+      const activeSegment = shim.getActiveSegment() || parentSegment
+      if (asyncResource && asyncResource.promise) {
+        asyncResource.promise.__NR_id = id
+      }
+
+      segmentMap.set(id, activeSegment)
+    },
+
+    before: function beforeHook(id) {
+      const hookSegment = segmentMap.get(id)
+
+      if (!hookSegment) {
+        return
+      }
+
+      segmentMap.set(id, shim.getActiveSegment())
+      shim.setActiveSegment(hookSegment)
+    },
+    after: function afterHook(id) {
+      const hookSegment = segmentMap.get(id)
+
+      // hookSegment is the segment that was active before the promise
+      // executed. If the promise is executing before a segment has been
+      // restored, hookSegment will be null and should be restored. Thus
+      // undefined is the only invalid value here.
+      if (hookSegment === undefined) {
+        return
+      }
+
+      segmentMap.set(id, shim.getActiveSegment())
+      shim.setActiveSegment(hookSegment)
+    },
+    promiseResolve: function promiseResolveHandler(id) {
+      const hookSegment = segmentMap.get(id)
+      segmentMap.delete(id)
+
+      if (hookSegment === undefined) {
+        return
+      }
+
+      // Because the ID will no-longer be in memory until dispose to propagate the null
+      // we need to set it active here or else we may continue to propagate the wrong tree.
+      // May be some risk of setting this at the wrong time
+      if (hookSegment === null) {
+        shim.setActiveSegment(hookSegment)
+      }
+    }
+  }
+
+  return hooks
 }

package/lib/instrumentation/core/http.js

@@ -267,6 +267,11 @@ function wrapResponseEnd(agent, proto) {
         return end.apply(this, arguments)
       }
 
+      if (!txInfo.transaction.isActive()) {
+        logger.trace('wrappedResEnd invoked for ended transaction implying multiple invocations.')
+        return end.apply(this, arguments)
+      }
+
       // If an error happened, add it to the aggregator.
       if (txInfo.error) {
         if (!txInfo.errorHandled || urltils.isError(agent.config, this.statusCode)) {

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

@@ -72,6 +72,7 @@ function createStandardAggregator(config, collector, metrics) {
 }
 
 function validateInfiniteTracing(trace_observer) {
+  // TODO: Remove semver check when Node 10 support dropped.
   if (!psemver.satisfies('>=10.10.0')) {
     logger.warn(
       'Infinite tracing disabled: this version of Node is not supported (must be >=10.10.0)'

package/lib/transaction/index.js

@@ -225,9 +225,28 @@ Transaction.prototype.end = function end() {
   }
 
   this.agent.emit('transactionFinished', this)
+
+  // Do after emit so all post-processing can complete
+  this._cleanUneededReferences()
+
   return this
 }
 
+/**
+ * Cleans up references that will not be used later for processing such as
+ * transaction traces.
+ *
+ * Errors won't be needed for later processing but can contain extra details we
+ * don't want to hold in memory. Particularly, axios errors can result in indirect
+ * references to promises which will prevent them from being destroyed and result
+ * in a memory leak. This is due to the TraceSegment not getting removed from the
+ * async-hooks segmentMap because 'destroy' never fires.
+ */
+Transaction.prototype._cleanUneededReferences = function _cleanUneededReferences() {
+  this.userErrors = null
+  this.exceptions = null
+}
+
 /**
  * For web transactions, this represents the time from when the request was received
  * to when response was sent.  For background transactions, it is equal to duration
@@ -768,6 +787,11 @@ function _linkExceptionToSegment(exception) {
 Transaction.prototype.addException = _addException
 
 function _addException(exception) {
+  if (!this.isActive()) {
+    logger.trace('Transaction is not active. Not capturing error: ', exception)
+    return
+  }
+
   this._linkExceptionToSegment(exception)
   this.exceptions.push(exception)
 }
@@ -782,6 +806,11 @@ function _addException(exception) {
 Transaction.prototype.addUserError = _addUserError
 
 function _addUserError(exception) {
+  if (!this.isActive()) {
+    logger.trace('Transaction is not active. Not capturing user error: ', exception)
+    return
+  }
+
   this._linkExceptionToSegment(exception)
   this.userErrors.push(exception)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "7.2.0",
+  "version": "7.4.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -143,8 +143,8 @@
     "newrelic-naming-rules": "./bin/test-naming-rules.js"
   },
   "dependencies": {
-    "@grpc/grpc-js": "^1.2.7",
-    "@grpc/proto-loader": "^0.5.5",
+    "@grpc/grpc-js": "^1.2.11",
+    "@grpc/proto-loader": "^0.5.6",
     "@newrelic/aws-sdk": "^3.1.0",
     "@newrelic/koa": "^5.0.0",
     "@newrelic/superagent": "^4.0.0",
@@ -171,12 +171,14 @@
     "commander": "^7.0.0",
     "eslint": "^6.8.0",
     "express": "*",
-    "fastify": "^2.14.1",
+    "fastify": "^2.15.3",
     "generic-pool": "^3.6.1",
     "glob": "^7.1.2",
     "got": "^8.0.1",
     "http-errors": "^1.7.3",
+    "husky": "^6.0.0",
     "jsdoc": "^3.6.3",
+    "lint-staged": "^11.0.0",
     "memcached": ">=0.2.8",
     "minami": "^1.1.1",
     "mongodb": "^3.3.3",