newrelic 9.3.0 → 9.4.0

package/NEWS.md

@@ -1,13 +1,40 @@
-### v9.3.0 (2022-10-17)
-
+### v9.4.0 (2022-10-24)
+
+* Removed legacy agent async context propagation. The default behavior is now what was behind the `feature_flag.new_promise_tracking`. You can read more about the difference [here](https://docs.newrelic.com/docs/release-notes/agent-release-notes/nodejs-release-notes/node-agent-7-3-0#new-features). 
+
+* Fixed an issue with the ES Module loader that properly registers instrumentation when the file path included url encoded characters.
+
+* Added an API for enqueuing application logs for forwarding 
+
+```js
+newrelic.recordLogEvent({ message: 'hello world', level: 'info' })`
+```
+
+
+**Note**: If you are including a serialized error make sure it is on the `error` key of the log event: 
+
+```js
+const error = new Error('testing errors'); 
+newrelic.recordLogEvent({ message: 'error example', level: 'error', error })
+```
+
+* Fixed `cassandra-driver` instrumentation to properly set instance details on query segments/spans.
+
+* Added a new context manager that leverages AsyncLocalStorage for async context propagation.
+    * This will be available via a feature flag  `config.feature_flag.async_local_context`
+    * Alternatively you can set the environment variable of `NEW_RELIC_FEATURE_FLAG_ASYNC_LOCAL_CONTEXT=1`
+    * By enabling this feature flag it should make the agent use less memory and CPU.
+
+### v9.3.0 (2022-10-17)
+
 * Added instrumentation to bunyan to support application logging use cases: forwarding, local decorating, and metrics.
    
-   Big thanks to @brianphillips for his contribution 🚀
-
-* Added c8 to track code coverage.
-
-* Added documentation about custom instrumentation in ES module applications
-
+   Big thanks to @brianphillips for his contribution 🚀
+
+* Added c8 to track code coverage.
+
+* Added documentation about custom instrumentation in ES module applications
+
 ### v9.2.0 (2022-10-06)
 
 * Added ability to instrument ES Modules with the New Relic ESM Loader.

package/api.js

@@ -18,6 +18,7 @@ const isValidType = require('./lib/util/attribute-types')
 const TransactionShim = require('./lib/shim/transaction-shim')
 const TransactionHandle = require('./lib/transaction/handle')
 const AwsLambda = require('./lib/serverless/aws-lambda')
+const applicationLogging = require('./lib/util/application-logging')
 
 const ATTR_DEST = require('./lib/config/attribute-filter').DESTINATIONS
 const MODULE_TYPE = require('./lib/shim/constants').MODULE_TYPE
@@ -426,6 +427,86 @@ API.prototype.noticeError = function noticeError(error, customAttributes) {
   this.agent.errors.addUserError(transaction, error, filteredAttributes)
 }
 
+/**
+ * Sends an application log message to New Relic. The agent already
+ * automatically does this for some instrumented logging libraries,
+ * but in case you are using another logging method that is not
+ * already instrumented by the agent, you can use this function
+ * instead.
+ *
+ * If application log forwarding is disabled in the agent
+ * configuration, this function does nothing.
+ *
+ * An example of using this function is
+ *
+ *    newrelic.recordLogEvent({
+ *       message: 'cannot find file',
+ *       level: 'ERROR',
+ *       error: new SystemError('missing.txt')
+ *    })
+ *
+ * @param {object} logEvent The log event object to send. Any
+ *   attributes besides `message`, `level`, `timestamp`, and `error` are
+ *   recorded unchanged. The `logEvent` object itself will be mutated by
+ *   this function.
+ * @param {string} logEvent.message The log message.
+ * @param {string} logEvent.level The log level severity. If this key is
+ *   missing, it will default to UNKNOWN
+ * @param {number} logEvent.timestamp   ECMAScript epoch number denoting the
+ *   time that this log message was produced. If this key is missing,
+ *   it will default to the output of `Date.now()`.
+ * @param {Error} logEvent.error Error associated to this log event. Ignored if missing.
+ */
+API.prototype.recordLogEvent = function recordLogEvent(logEvent = {}) {
+  const metric = this.agent.metrics.getOrCreateMetric(NAMES.SUPPORTABILITY.API + '/recordLogEvent')
+  metric.incrementCallCount()
+
+  if (!applicationLogging.isLogForwardingEnabled(this.agent.config, this.agent)) {
+    logger.warnOnce(
+      'Record logs',
+      'Application log forwarding disabled, method API#recordLogEvent will not record messages'
+    )
+    return
+  }
+
+  // If they don't pass a logEvent object, or it doesn't have the
+  // required `message` key, bail out.
+  if (typeof logEvent !== 'object' || logEvent.message === undefined) {
+    logger.warn(
+      'recordLogEvent requires an object with a `message` attribute for its single argument, got %s (%s)',
+      stringify(logEvent),
+      typeof logEvent
+    )
+    return
+  }
+  logEvent.message = applicationLogging.truncate(logEvent.message)
+
+  if (!logEvent.level) {
+    logger.debug('no log level set, setting it to UNKNOWN')
+    logEvent.level = 'UNKNOWN'
+  }
+
+  if (typeof logEvent.timestamp !== 'number') {
+    logger.debug('no timestamp set, setting it to `Date.now()`')
+    logEvent.timestamp = Date.now()
+  }
+
+  if (logEvent.error) {
+    logEvent['error.message'] = applicationLogging.truncate(logEvent.error.message)
+    logEvent['error.stack'] = applicationLogging.truncate(logEvent.error.stack)
+    logEvent['error.class'] =
+      logEvent.error.name === 'Error' ? logEvent.error.constructor.name : logEvent.error.name
+    delete logEvent.error
+  }
+
+  if (applicationLogging.isMetricsEnabled(this.agent.config)) {
+    applicationLogging.incrementLoggingLinesMetrics(logEvent.level, this.agent.metrics)
+  }
+
+  const metadata = this.agent.getLinkingMetadata()
+  this.agent.logs.add(Object.assign({}, logEvent, metadata))
+}
+
 /**
  * If the URL for a transaction matches the provided pattern, name the
  * transaction with the provided name. If there are capture groups in the

package/esm-loader.mjs

@@ -9,6 +9,7 @@ import loggingModule from './lib/logger.js'
 import NAMES from './lib/metrics/names.js'
 import semver from 'semver'
 import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 
 const isSupportedVersion = () => semver.gte(process.version, 'v16.12.0')
 // This check will prevent resolve hooks executing from within this file
@@ -70,7 +71,7 @@ export async function resolve(specifier, context, nextResolve) {
       const instrumentationDefinitionCopy = Object.assign({}, instrumentationDefinition)
 
       // Stripping the prefix is necessary because the code downstream gets this url without it
-      instrumentationDefinitionCopy.moduleName = url.replace('file://', '')
+      instrumentationDefinitionCopy.moduleName = fileURLToPath(url)
 
       // Added to keep our Supportability metrics from exploding/including customer info via full filepath
       instrumentationDefinitionCopy.specifier = specifier
@@ -178,6 +179,9 @@ function addESMSupportabilityMetrics(agent) {
  * This is done by injecting the ESM shim which proxies every property on the exported
  * module and registers the module with shimmer so instrumentation can be registered properly.
  *
+ * Note: this autogenerated code _requires_ that the import have the file:// prefix!
+ * Without it, Node.js throws an ERR_INVALID_URL error: you've been warned.
+ *
  * @param {string} url the URL returned by the resolve chain
  * @param {string} specifier string identifier in an import statement or import() expression
  * @returns {string} source code rewritten to wrap with our esm-shim
@@ -185,7 +189,7 @@ function addESMSupportabilityMetrics(agent) {
 async function wrapEsmSource(url, specifier) {
   const pkg = await import(url)
   const props = Object.keys(pkg)
-  const trimmedUrl = url.replace('file://', '')
+  const trimmedUrl = fileURLToPath(url)
 
   return `
     import wrapModule from '${esmShimPath.href}'

package/lib/context-manager/async-local-context-manager.js

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2021 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const { AsyncLocalStorage } = require('async_hooks')
+
+/**
+ * Class for managing state in the agent.
+ * Uses AsyncLocalStorage for context propagation of state across async boundaries.
+ *
+ * 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 AsyncLocalContextManager {
+  /**
+   * @param {object} config New Relic config instance
+   */
+  constructor(config) {
+    this._config = config
+
+    this._asyncLocalStorage = new AsyncLocalStorage()
+  }
+
+  /**
+   * Get the currently active context.
+   *
+   * @returns {object} The current active context.
+   */
+  getContext() {
+    return this._asyncLocalStorage.getStore() || null
+  }
+
+  /**
+   * Set a new active context. Not bound to function execution.
+   * The AsyncLocalStorage method is considered experimental
+   *
+   * @param {object} newContext The context to set as active.
+   */
+  setContext(newContext) {
+    this._asyncLocalStorage.enterWith(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 toInvoke = cbThis ? callback.bind(cbThis) : callback
+
+    if (args) {
+      return this._asyncLocalStorage.run(context, toInvoke, ...args)
+    }
+
+    return this._asyncLocalStorage.run(context, toInvoke)
+  }
+}
+
+module.exports = AsyncLocalContextManager

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

@@ -5,6 +5,8 @@
 
 'use strict'
 
+const semver = require('semver')
+
 const logger = require('../logger')
 
 /**
@@ -16,6 +18,26 @@ const logger = require('../logger')
  * the current configuration.
  */
 function createContextManager(config) {
+  if (config.feature_flag.async_local_context) {
+    // TODO: Remove >=16 check when only support 16+. AsyncLocal became stable in 16.4.0
+    if (semver.satisfies(process.version, '>=16.4.0')) {
+      return createAsyncLocalContextManager(config)
+    }
+
+    logger.warn('The AsyncLocalContextManager is only supported on Node version 16.4.0 and later.')
+  }
+
+  return createLegacyContextManager(config)
+}
+
+function createAsyncLocalContextManager(config) {
+  logger.info('Using AsyncLocalContextManager')
+
+  const AsyncLocalContextManager = require('./async-local-context-manager')
+  return new AsyncLocalContextManager(config)
+}
+
+function createLegacyContextManager(config) {
   if (config.logging.diagnostics) {
     logger.info('Using LegacyDiagnosticContextManager')
 

package/lib/feature_flags.js

@@ -8,12 +8,12 @@
 // unreleased flags gating an active feature
 exports.prerelease = {
   express5: false,
-  new_promise_tracking: false,
   promise_segments: false,
   reverse_naming_rules: false,
   undici_instrumentation: false,
   undici_async_tracking: true,
-  unresolved_promise_cleanup: true
+  unresolved_promise_cleanup: true,
+  async_local_context: false
 }
 
 // flags that are no longer used for released features
@@ -24,6 +24,7 @@ exports.released = [
   'custom_metrics',
   'express_segments',
   'native_metrics',
+  'new_promise_tracking',
   'protocol_17',
   'serverless_mode',
   'send_request_uri_attribute',

package/lib/instrumentation/amqplib.js

@@ -212,7 +212,7 @@ function wrapPromiseChannel(shim) {
 
   const proto = libPModel.Channel.prototype
   if (shim.isWrapped(proto.consume)) {
-    shim.logger.trace('Promise model already isntrumented.')
+    shim.logger.trace('Promise model already instrumented.')
     return
   }
 

package/lib/instrumentation/bunyan.js

@@ -11,19 +11,10 @@ const {
   isLocalDecoratingEnabled,
   isMetricsEnabled,
   createModuleUsageMetric,
-  incrementLoggingLinesMetrics
+  incrementLoggingLinesMetrics,
+  truncate
 } = require('../util/application-logging')
 
-const MAX_LENGTH = 1021
-const OUTPUT_LENGTH = 1024
-const truncate = (str) => {
-  if (str && str.length > OUTPUT_LENGTH) {
-    return str.substring(0, MAX_LENGTH) + '...'
-  }
-
-  return str
-}
-
 const logger = require('../logger').child({ component: 'bunyan' })
 
 function augmentLogData(originalLog, agent, nameFromLevel) {

package/lib/instrumentation/cassandra-driver.js

@@ -5,16 +5,91 @@
 
 'use strict'
 
-module.exports = function initialize(agent, cassandra, moduleName, shim) {
-  const proto = cassandra.Client.prototype
+const semver = require('semver')
+
+/**
+ * Instruments the `cassandra-driver` module, function that is
+ * passed to `onRequire` when instantiating instrumentation.
+ *
+ * @param {object} _agent - NewRelic agent
+ * @param {object} cassandra - The cassandra-driver library definition
+ * @param {string} _moduleName - String representation of require/import path
+ * @param {object} shim - shim for instrumentation
+ */
+module.exports = function initialize(_agent, cassandra, _moduleName, shim) {
+  const cassandraVersion = shim.require('./package.json').version
+
   shim.setDatastore(shim.CASSANDRA)
-  shim.recordOperation(proto, ['connect', 'shutdown'], { callback: shim.LAST })
-  if (proto._innerExecute) {
-    shim.recordQuery(proto, '_innerExecute', { query: shim.FIRST, callback: shim.LAST })
+
+  const ClientProto = cassandra.Client.prototype
+  const RequestExecutionProto = shim.require('./lib/request-execution.js').prototype
+
+  shim.recordOperation(ClientProto, ['connect', 'shutdown'], { callback: shim.LAST })
+
+  if (semver.satisfies(cassandraVersion, '>=4.4.0')) {
+    shim.recordQuery(ClientProto, '_execute', {
+      query: shim.FIRST,
+      callback: shim.LAST
+    })
+
+    shim.wrap(
+      RequestExecutionProto,
+      '_sendOnConnection',
+      function wrapSendOnConnection(shim, _sendOnConnection) {
+        return function wrappedSendOnConnection() {
+          shim.captureInstanceAttributes(
+            this._connection.address,
+            this._connection.port,
+            this._connection.keyspace
+          )
+
+          return _sendOnConnection.apply(this, arguments)
+        }
+      }
+    )
   } else {
-    shim.recordQuery(proto, '_execute', { query: shim.FIRST, callback: shim.LAST })
+    shim.recordQuery(ClientProto, '_innerExecute', {
+      query: shim.FIRST,
+      callback: shim.LAST
+    })
+
+    shim.wrap(RequestExecutionProto, 'start', function wrapStart(shim, start) {
+      return function wrappedStart() {
+        const parent = shim.getSegment()
+        const self = this
+
+        const args = shim.argsToArray.apply(shim, arguments)
+
+        /**
+         * In older versions of cassandra-driver, we can't rely on RequestExecution._sendOnConnection,
+         * so instead we use the callback passed to RequestExecution.start as a sort of hook point,
+         * because we know for sure that the connection was set and in scope right before the callback
+         * is executed.
+         *
+         * We also have to set the active segment to the RequestExecution.start's segment to ensure that
+         * we're adding the connection attributes to the correct segment.
+         *
+         * See: https://github.com/datastax/nodejs-driver/blob/v3.4.0/lib/request-execution.js#L51
+         */
+        args[0] = shim.wrap(args[0], function wrapGetHostCallback(shim, getHostCallback) {
+          return function wrappedGetHostCallback() {
+            shim.setActiveSegment(parent)
+
+            shim.captureInstanceAttributes(
+              self._connection.address,
+              self._connection.port,
+              self._connection.keyspace
+            )
+            return getHostCallback.apply(this, arguments)
+          }
+        })
+
+        return start.apply(this, args)
+      }
+    })
   }
-  shim.recordBatchQuery(proto, 'batch', {
+
+  shim.recordBatchQuery(ClientProto, 'batch', {
     query: findBatchQueryArg,
     callback: shim.LAST
   })
@@ -24,9 +99,13 @@ module.exports = function initialize(agent, cassandra, moduleName, shim) {
  * Given the arguments for Cassandra's `batch` method, this finds the first
  * query in the batch.
  *
- * @return {string} The query for this batch request.
+ * @param {object} _shim - shim for instrumentation
+ * @param {Function} _batch - original batch function
+ * @param {string} _fnName - the function name (batch)
+ * @param {Array} args - original arguments passed to the batch function
+ * @returns {string} The query for this batch request.
  */
-function findBatchQueryArg(shim, batch, fnName, args) {
+function findBatchQueryArg(_shim, _batch, _fnName, args) {
   const sql = (args[0] && args[0][0]) || ''
   return sql.query || sql
 }

package/lib/instrumentation/core/async_hooks.js

@@ -11,17 +11,20 @@ const asyncHooks = require('async_hooks')
 module.exports = initialize
 
 function initialize(agent, shim) {
+  if (agent.config.feature_flag.async_local_context) {
+    logger.debug(
+      'New AsyncLocalStorage context enabled. Not enabling manual async_hooks or promise instrumentation'
+    )
+
+    return
+  }
+
   // this map is reused to track the segment that was active when
   // the before callback is called to be replaced in the after callback
   const segmentMap = new Map()
   module.exports.segmentMap = segmentMap
 
-  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 hookHandlers = getPromiseResolveStyleHooks(segmentMap, agent, shim)
 
   const hook = asyncHooks.createHook(hookHandlers)
   hook.enable()
@@ -33,63 +36,6 @@ function initialize(agent, shim) {
   return true
 }
 
-function getStandardHooks(segmentMap, agent, shim) {
-  const hooks = {
-    init: function initHook(id, type, triggerId, promiseWrap) {
-      if (type !== 'PROMISE') {
-        return
-      }
-
-      const 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 (promiseWrap && promiseWrap.promise) {
-        promiseWrap.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)
-    },
-    destroy: function destHook(id) {
-      segmentMap.delete(id)
-    }
-  }
-
-  return hooks
-}
-
 function getPromiseResolveStyleHooks(segmentMap, agent, shim) {
   const hooks = {
     init: function initHook(id, type, triggerId, asyncResource) {

package/lib/instrumentation/core/timers.js

@@ -8,27 +8,9 @@
 module.exports = initialize
 
 function initialize(agent, timers, moduleName, shim) {
-  const processMethods = ['nextTick', '_nextDomainTick', '_tickDomainCallback']
-
-  shim.wrap(process, processMethods, function wrapProcess(shim, fn) {
-    return function wrappedProcess() {
-      const segment = shim.getActiveSegment()
-      if (!segment) {
-        return fn.apply(this, arguments)
-      }
-
-      // Manual copy because helper methods add significant overhead in some usages
-      const len = arguments.length
-      const args = new Array(len)
-      for (let i = 0; i < len; ++i) {
-        args[i] = arguments[i]
-      }
-
-      shim.bindSegment(args, shim.FIRST, segment)
-
-      return fn.apply(this, args)
-    }
-  })
+  if (!agent.config.feature_flag.async_local_context) {
+    instrumentProcessMethods(shim, process)
+  }
 
   instrumentTimerMethods(timers)
 
@@ -43,9 +25,11 @@ function initialize(agent, timers, moduleName, shim) {
 
     shim.record(nodule, asynchronizers, recordAsynchronizers)
 
-    // We don't want to create segments for setImmediate calls, as the
-    // object allocation may incur too much overhead in some situations
-    shim.wrap(nodule, 'setImmediate', wrapSetImmediate)
+    if (!agent.config.feature_flag.async_local_context) {
+      // We don't want to create segments for setImmediate calls, as the
+      // object allocation may incur too much overhead in some situations
+      shim.wrap(nodule, 'setImmediate', wrapSetImmediate)
+    }
 
     shim.wrap(nodule, 'clearTimeout', wrapClearTimeout)
 
@@ -84,6 +68,30 @@ function initialize(agent, timers, moduleName, shim) {
   }
 }
 
+function instrumentProcessMethods(shim, process) {
+  const processMethods = ['nextTick', '_nextDomainTick', '_tickDomainCallback']
+
+  shim.wrap(process, processMethods, function wrapProcess(shim, fn) {
+    return function wrappedProcess() {
+      const segment = shim.getActiveSegment()
+      if (!segment) {
+        return fn.apply(this, arguments)
+      }
+
+      // Manual copy because helper methods add significant overhead in some usages
+      const len = arguments.length
+      const args = new Array(len)
+      for (let i = 0; i < len; ++i) {
+        args[i] = arguments[i]
+      }
+
+      shim.bindSegment(args, shim.FIRST, segment)
+
+      return fn.apply(this, args)
+    }
+  })
+}
+
 function makeWrappedPromisifyCompatible(shim, timers) {
   const originalSetTimeout = shim.getOriginal(timers.setTimeout)
   Object.getOwnPropertySymbols(originalSetTimeout).forEach((symbol) => {
@@ -95,8 +103,10 @@ function makeWrappedPromisifyCompatible(shim, timers) {
     timers.setInterval[symbol] = originalSetInterval[symbol]
   })
 
-  const originalSetImmediate = shim.getOriginal(timers.setImmediate)
-  Object.getOwnPropertySymbols(originalSetImmediate).forEach((symbol) => {
-    timers.setImmediate[symbol] = originalSetImmediate[symbol]
-  })
+  if (!shim.agent.config.feature_flag.async_local_context) {
+    const originalSetImmediate = shim.getOriginal(timers.setImmediate)
+    Object.getOwnPropertySymbols(originalSetImmediate).forEach((symbol) => {
+      timers.setImmediate[symbol] = originalSetImmediate[symbol]
+    })
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "9.3.0",
+  "version": "9.4.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -146,7 +146,8 @@
     "bench": "node ./bin/run-bench.js",
     "docker-env": "./bin/docker-env-vars.sh",
     "docs": "npm ci && jsdoc -c ./jsdoc-conf.json --private -r .",
-    "integration": "npm run prepare-test && npm run sub-install && time c8 -o ./coverage/integration tap test/integration/**/**/*.tap.js --timeout=180 --no-coverage --reporter classic",
+    "integration": "npm run prepare-test && npm run sub-install && time tap --test-regex='(\\/|^test\\/integration\\/.*\\.tap\\.js)$' --timeout=180 --no-coverage --reporter classic",
+    "integration:async-local": "npm run prepare-test && npm run sub-install && time tap --test-regex='(\\/|^test\\/integration\\/.*\\.tap\\.js)$' --timeout=180 --no-coverage --reporter classic --test-env=NEW_RELIC_FEATURE_FLAG_ASYNC_LOCAL_CONTEXT=1",
     "prepare-test": "npm run ssl && npm run docker-env",
     "lint": "eslint ./*.{js,mjs} lib test bin examples",
     "lint:fix": "eslint --fix, ./*.{js,mjs} lib test bin examples",
@@ -159,15 +160,18 @@
     "test": "npm run integration && npm run unit && npm run unit:esm",
     "third-party-updates": "oss third-party manifest --includeOptDeps && oss third-party notices --includeOptDeps && git add THIRD_PARTY_NOTICES.md third_party_manifest.json",
     "unit": "rm -f newrelic_agent.log && time c8 -o ./coverage/unit tap --test-regex='(\\/|^test\\/unit\\/.*\\.test\\.js)$' --timeout=180 --no-coverage --reporter classic",
+    "unit:async-local": "rm -f newrelic_agent.log && time tap --test-regex='(\\/|^test\\/unit\\/.*\\.test\\.js)$' --timeout=180 --no-coverage --reporter classic --test-env=NEW_RELIC_FEATURE_FLAG_ASYNC_LOCAL_CONTEXT=1",
     "unit:esm": "rm -f newrelic_agent.log && time c8 -o ./coverage/esm-unit --include *.mjs --include **/*.mjs --exclude false tap --test-regex='(\\/|^test\\/unit\\/.*\\.test\\.mjs)$' --timeout=180 --no-coverage --reporter classic --node-arg=--experimental-loader=testdouble",
     "update-cross-agent-tests": "./bin/update-cats.sh",
     "versioned-tests": "./bin/run-versioned-tests.sh",
     "update-changelog-version": "node ./bin/update-changelog-version",
     "checkout-external-versioned": "node ./test/versioned-external/checkout-external-tests.js",
     "versioned": "npm run versioned:npm7",
-    "versioned:major": "npm run checkout-external-versioned && npm run prepare-test && VERSIONED_MODE=--major NPM7=1 time ./bin/run-versioned-tests.sh",
+    "versioned:major": "VERSIONED_MODE=--major npm run versioned:npm7",
     "versioned:npm6": "npm run checkout-external-versioned && npm run prepare-test && time ./bin/run-versioned-tests.sh",
     "versioned:npm7": "npm run checkout-external-versioned && npm run prepare-test && NPM7=1 time ./bin/run-versioned-tests.sh",
+    "versioned:async-local": "NEW_RELIC_FEATURE_FLAG_ASYNC_LOCAL_CONTEXT=1 npm run versioned:npm7",
+    "versioned:async-local:major": "NEW_RELIC_FEATURE_FLAG_ASYNC_LOCAL_CONTEXT=1 npm run versioned:major",
     "prepare": "husky install"
   },
   "bin": {