newrelic 7.1.3 → 7.3.1

package/NEWS.md

@@ -1,3 +1,75 @@
+### 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.
+
+  **Deprecation Warning:** The certificate bundle included by New Relic will be disabled by default and then 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 }`.
+
+* The `NEW_RELIC_NO_CONFIG_FILE` environment variable is no longer needed to run the agent without a configuration file.
+
+  * If a configuration file is used with agent configuration environment variables, the environment variables will override the corresponding configuration file settings.
+
+* Fixed bug where applications with multiple names on a dynamically named host (UUID like) would have instances consolidated, losing per-host breakdowns.
+
+  Removed 'host' from agent 'identifier' override to prevent server safety mechanism from kicking in. Host will still be used to identify unique agent instances, so was unnecessary to include as part of the identifier. This also resulted in additional processing overhead on the back-end. The identifier override is still kept in place with multiple application names to continue to allow uniquely identifying instances on the same host with multiple application names where the first name may be identical. For example `app_name['myName', 'unique1']` and `app_name['myName', 'unique2']`. These names would consolidate down into a single instance on the same host without the identifier override.
+
+* Fixed bug where truncated http (external) or datastore segments would generate generic spans instead of appropriate http or datastore spans.
+
+* Set distributed tracing to enabled in the `newrelic.js` template configuration file supplied with the agent.
+
+* Added module root to shim.require() logging to aid debugging.
+
+* Migrated from .npmignore to 'files' list in package.json to control which files are packaged.
+
+  Thank you to @JamesPeiris for the initial nudge via PR to move in this direction.
+
+* Converted remaining collector unit tests to use tap API.
+
+* Added linting to scripts in /bin folder.
+
+  Linting rules added are slightly more permissive than production rules and allow full ecma 8.
+
+* Added new developer documentation to /docs folder.
+
+  This information is ported over from private GHE wiki used prior to going open source. S/O @astorm for original versions of the function wrapping and module instrumentation docs.
+
 ### v7.1.3 (2021-03-09)
 
 * Bumped @grpc/grpc-js to ^1.2.7.

package/THIRD_PARTY_NOTICES.md

@@ -41,6 +41,7 @@ code, the source code can be found at [https://github.com/newrelic/node-newrelic
 * [benchmark](#benchmark)
 * [bluebird](#bluebird)
 * [chai](#chai)
+* [commander](#commander)
 * [eslint](#eslint)
 * [express](#express)
 * [fastify](#fastify)
@@ -74,7 +75,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.5](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js/tree/v1.2.5)), distributed under the [Apache-2.0 License](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js/blob/v1.2.5/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
@@ -283,7 +284,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
@@ -1924,6 +1925,36 @@ 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):
+
+```
+(The MIT License)
+
+Copyright (c) 2011 TJ Holowaychuk <tj@vision-media.ca>
+
+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.
+
+```
+
 ### eslint
 
 This product includes source derived from [eslint](https://github.com/eslint/eslint) ([v6.8.0](https://github.com/eslint/eslint/tree/v6.8.0)), distributed under the [MIT License](https://github.com/eslint/eslint/blob/v6.8.0/LICENSE):

package/bin/test-naming-rules.js

@@ -15,13 +15,13 @@ var urltils = require('../lib/util/urltils')
 var MetricNormalizer = require('../lib/metrics/normalizer')
 
 var cwd = process.cwd()
-var opts = null
+var options = null
 if (arrayContainsAny(process.argv, '-h', '-?', '--help')) {
   printHelp()
 } else if (process.argv.length === 3) {
-  opts = {rules: null, urls: path.resolve(cwd, process.argv[2])}
+  options = {rules: null, urls: path.resolve(cwd, process.argv[2])}
 } else if (process.argv.length === 4) {
-  opts = {
+  options = {
     rules: path.resolve(cwd, process.argv[2]),
     urls: path.resolve(cwd, process.argv[3])
   }
@@ -29,7 +29,7 @@ if (arrayContainsAny(process.argv, '-h', '-?', '--help')) {
   printHelp()
 }
 
-run(opts)
+run(options)
 
 function printHelp() {
   console.log('Usage:')

package/lib/collector/facts.js

@@ -64,14 +64,7 @@ function facts(agent, callback) {
       }
     }
 
-    // TODO:  After reconfiguring agent startup to wait for the server to start
-    //        or for the first transaction, add the `port` for the server too.
-    // NOTE: The concat is necessary to prevent sort from happening in-place.
-    results.identifier = [
-      'nodejs',
-      results.host,
-      results.app_name.concat([]).sort().join(',')
-    ].join(':')
+    results.identifier = getIdentifierOverride(results.app_name)
 
     const ipAddresses = getAllIPAddresses()
     if (ipAddresses.length) {
@@ -112,3 +105,24 @@ function getAllIPAddresses() {
     return addresses
   }, [])
 }
+
+/**
+ * Creates an identifier override to support customers who have multiple agents on the
+ * same host with the first app name that is identical.
+ * https://github.com/newrelic/node-newrelic/commit/c0901e6807a50ac3969d79ab48c31c8e0232a6b5#r18254962
+ * https://source.datanerd.us/collector-collective/connect-service/blob/1470c21109393a5b43c8788da88a37f41a300b98/src/main/java/com/nr/collector/methods/Connect.java#L1424-L1431
+ *
+ * IMPORTANT: we do not include host as it has negative consequences and is unnecessary.
+ * On the server, the host will still be used as part of the key to determine if two agent
+ * connections are the same real agent or a separate one.
+ * https://github.com/newrelic/node-newrelic/issues/654
+ */
+function getIdentifierOverride(appNames) {
+  const identifier = [
+    'nodejs',
+    // NOTE: The concat is necessary to prevent sort from happening in-place.
+    appNames.concat([]).sort().join(',')
+  ].join(':')
+
+  return identifier
+}

package/lib/collector/http-agents.js

@@ -103,14 +103,27 @@ function proxyOptions(config) {
     proxy_url: proxy_url
   }
 
-  // merge user certificates with built-in certs
-
   if (config.certificates && config.certificates.length > 0) {
-    logger.info(
-      'Using a proxy with a special cert. This enables our cert bundle which, combined ' +
-      'with some versions of node, exacerbates a leak in node core TLS.'
-    )
-    opts.certificates = config.certificates.concat(certificates)
+    opts.certificates = config.certificates
+
+    // merge user certificates with built-in certs
+    if (config.feature_flag.certificate_bundle) {
+      logger.info(
+        'Using a proxy with a special cert. This enables our cert bundle which, combined ' +
+        'with some versions of node, exacerbates a leak in node core TLS.'
+      )
+
+      const certWarningMessage = [
+        'Deprecation Warning: The certificate bundle included by New Relic will be ',
+        'disabled by default and then 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 }.'
+      ].join('')
+      logger.warnOnce('CERT_WARNING', certWarningMessage)
+
+      opts.certificates = config.certificates.concat(certificates)
+    }
   }
 
   return opts

package/lib/collector/remote-method.js

@@ -263,10 +263,24 @@ RemoteMethod.prototype._request = function _request(options) {
     request = https.request(requestOptions)
   } else {
     if (this._config.certificates && this._config.certificates.length > 0) {
-      logger.debug(
-        'Adding custom certificate to the cert bundle.'
-      )
-      requestOptions.ca = this._config.certificates.concat(certificates)
+      requestOptions.ca = this._config.certificates
+
+      if (this._config.feature_flag.certificate_bundle) {
+        logger.debug(
+          'Adding custom certificate to the cert bundle.'
+        )
+
+        const certWarningMessage = [
+          'Deprecation Warning: The certificate bundle included by New Relic will be ',
+          'disabled by default and then 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 }.'
+        ].join('')
+        logger.warnOnce('CERT_WARNING', certWarningMessage)
+
+        requestOptions.ca = this._config.certificates.concat(certificates)
+      }
     }
     request = https.request(requestOptions)
   }

package/lib/config/index.js

@@ -1098,6 +1098,8 @@ Config.prototype._fromEnvironment = function _fromEnvironment(metadata, data) {
     if (typeof node === 'string') {
       var setting = process.env[node]
       if (setting) {
+        logger.debug(`${node} environment variable set.`)
+
         if (ENV.LIST_VARS.has(node)) {
           let split = ENV.LIST_VARS_CUSTOM_DELIMITERS[node] || /,/
           data[value] = setting.split(split).map(function trimVal(k) {
@@ -1616,11 +1618,9 @@ Config.prototype.getAggregatorConfig = function getAggregatorConfig(method) {
  *   5. If this module is installed as a dependency, the directory above the
  *      node_modules folder in which newrelic is installed.
  *
- * For configuration via environment (useful on Joyent, Azure, Heroku, or
- * other PaaS offerings), set NEW_RELIC_NO_CONFIG_FILE to something truthy
- * and read README.md for details on what configuration variables are
- * necessary, as well as a complete enumeration of the other available
- * variables.
+ * When node process environment varaibles and a config file are used,
+ * the environment variables will override their corresponding
+ * configuration file settings.
  *
  * @param {object} config Optional configuration to be used in place of a
  *                        config file.
@@ -1636,15 +1636,22 @@ function initialize(config) {
   if (config) return new Config(config)
 
   if (isTruthular(process.env.NEW_RELIC_NO_CONFIG_FILE)) {
-    config = new Config(Object.create(null))
-    if (config.newrelic_home) delete config.newrelic_home
-    return config
+    logger.info('NEW_RELIC_NO_CONFIG_FILE set, deferring to environment variables.')
+
+    return createNewConfigObject(config)
   }
 
   var filepath = _findConfigFile()
   if (!filepath) {
-    _noConfigFile()
-    return null
+    logger.info(['Unable to find configuration file.',
+      'If a configuration file is desired (common for non-containerized environments),',
+      `a base configuration file can be copied from ${BASE_CONFIG_PATH}`,
+      'and renamed to "newrelic.js" in the directory from which you will start',
+      'your application.',
+      'Attempting to start agent using environment variables.'
+    ].join(' '))
+
+    return createNewConfigObject(config)
   }
 
   var userConf
@@ -1653,12 +1660,16 @@ function initialize(config) {
   } catch (error) {
     logger.error(error)
 
-    throw new Error([
-      `Unable to read configuration file "${filepath}".`,
-      `A base configuration file can be copied from ${BASE_CONFIG_PATH}`,
-      'and renamed to "newrelic.js" in the directory from which you will start',
-      'your application.'
-    ].join('\n'))
+    logger.warn([
+      `Unable to read existing configuration file "${filepath}".`,
+      'To allow reading of the file (if desired),',
+      'please ensure the application has read access and the file is exporting valid JSON.',
+      'Attempting to start agent using enviornment variables.'
+    ].join(' '))
+  }
+
+  if (!userConf) {
+    return createNewConfigObject(config)
   }
 
   config = new Config(userConf)
@@ -1670,32 +1681,13 @@ function initialize(config) {
   return config
 }
 
-function _noConfigFile() {
-  const mainpath = path.resolve(path.join(process.cwd(), DEFAULT_FILENAME))
-  // If agent was loaded with -r flag, default to the path of the file being executed
-  const mainModule = process.mainModule && process.mainModule.filename || process.argv[1]
-  const altpath = path.resolve(
-    path.dirname(mainModule),
-    DEFAULT_FILENAME
-  )
-
-  let locations = mainpath
-  if (mainpath !== altpath) {
-    locations += ' or ' + altpath
-  }
-
-  const errorMessage = [
-    'Unable to find New Relic module configuration. A base configuration file',
-    `can be copied from ${BASE_CONFIG_PATH}`,
-    `and put at ${locations}.`,
-    'If you are not using file-based configuration, please set the environment',
-    'variable `NEW_RELIC_NO_CONFIG_FILE=true`.'
-  ].join(' ')
-
-  logger.error(errorMessage)
-  /* eslint-disable no-console */
-  console.error(errorMessage)
-  /* eslint-enable no-console */
+/**
+ * This helper function creates an empty configuration object
+ */
+function createNewConfigObject(config) {
+  config = new Config(Object.create(null))
+  if (config.newrelic_home) delete config.newrelic_home
+  return config
 }
 
 /**

package/lib/feature_flags.js

@@ -9,10 +9,14 @@
 exports.prerelease = {
   express5: false,
   await_support: true,
-  serverless_mode: true,
+  serverless_mode: true, // TODO: Move to released & remove code checks next Major.
   promise_segments: false,
   reverse_naming_rules: false,
-  fastify_instrumentation: false
+  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,
+  new_promise_tracking: false
 }
 
 // flags that are no longer used for released features

package/lib/grpc/connection.js

@@ -14,14 +14,14 @@ const util = require('util')
 
 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 +54,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
   }
 
@@ -320,26 +322,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
 }