newrelic 9.2.0 → 9.4.0

package/NEWS.md

@@ -1,3 +1,40 @@
+### 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
+
 ### v9.2.0 (2022-10-06)
 
 * Added ability to instrument ES Modules with the New Relic ESM Loader.

package/README.md

@@ -84,6 +84,47 @@ $ node --experimental-loader newrelic/esm-loader.mjs your-program.js
 
 **Note**: Unlike the CommonJS methods listed above, there are no alternatives to running the agent without the `--experimental-loader` flag.
 
+### Custom Instrumentation
+
+The agent supports adding your own custom instrumentation to ES module applications. In order to load custom instrumentation in an ES module app, you'll need to update your `newrelic.cjs` file to include the following:
+
+```js
+    /* File: newrelic.cjs */
+    'use strict'
+    /**
+     * New Relic agent configuration.
+     *
+     * See lib/config/default.js in the agent distribution for a more complete
+     * description of configuration variables and their potential values.
+     */
+    exports.config = {
+      app_name: ['Your application or service name'],
+      license_key: 'your new relic license key',
+      api: {
+        esm: {
+            custom_instrumentation_entrypoint: '/path/to/my/instrumentation.js'
+        }
+      }
+      /* ... rest of configuration .. */
+    }
+```
+
+If you do not use a configuration file, then use the environment variable `NEW_RELIC_API_ESM_CUSTOM_INSTRUMENTATION_ENTRYPOINT` instead.
+
+By updating the configuration, the agent's ES module loader will ensure that your custom instrumentation is added at module load. This is required in ES module applications due to the immutability of module export bindings: we are unable to apply our instrumentation after loading is complete.
+
+We support the following custom instrumentation API methods in ES module apps:
+
+* `newrelic.instrument`
+* `newrelic.instrumentConglomerate`
+* `newrelic.instrumentDatastore`
+* `newrelic.instrumentMessages`
+* `newrelic.instrumentWebframework`
+
+Note that we _do not_ support `newrelic.instrumentLoadedModule`, for the same issue of immutability mentioned above.
+
+If you want to see an example of how to write custom instrumentation in an ES module app, check out our [examples](https://github.com/newrelic/newrelic-node-examples/tree/main/esm-app) repo for a working demo.
+
 ## Getting Started
 
 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).

package/THIRD_PARTY_NOTICES.md

@@ -37,6 +37,7 @@ code, the source code can be found at [https://github.com/newrelic/node-newrelic
 * [@slack/bolt](#slackbolt)
 * [ajv](#ajv)
 * [async](#async)
+* [c8](#c8)
 * [chai](#chai)
 * [commander](#commander)
 * [eslint-config-prettier](#eslint-config-prettier)
@@ -2091,6 +2092,28 @@ THE SOFTWARE.
 
 ```
 
+### c8
+
+This product includes source derived from [c8](https://github.com/bcoe/c8) ([v7.12.0](https://github.com/bcoe/c8/tree/v7.12.0)), distributed under the [ISC License](https://github.com/bcoe/c8/blob/v7.12.0/LICENSE.txt):
+
+```
+Copyright (c) 2017, Contributors
+
+Permission to use, copy, modify, and/or distribute this software
+for any purpose with or without fee is hereby granted, provided
+that the above copyright notice and this permission notice
+appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE
+LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+```
+
 ### chai
 
 This product includes source derived from [chai](https://github.com/chaijs/chai) ([v4.3.6](https://github.com/chaijs/chai/tree/v4.3.6)), distributed under the [MIT License](https://github.com/chaijs/chai/blob/v4.3.6/LICENSE):

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

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2022 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const {
+  isApplicationLoggingEnabled,
+  isLogForwardingEnabled,
+  isLocalDecoratingEnabled,
+  isMetricsEnabled,
+  createModuleUsageMetric,
+  incrementLoggingLinesMetrics,
+  truncate
+} = require('../util/application-logging')
+
+const logger = require('../logger').child({ component: 'bunyan' })
+
+function augmentLogData(originalLog, agent, nameFromLevel) {
+  // shallow copy, since we're modifying things
+  const newLog = Object.assign({}, originalLog)
+  newLog.timestamp = Date.now()
+  newLog.level = nameFromLevel[originalLog.level]
+
+  // put log message into a consistent spot and ensure it's not too long
+  newLog.message = truncate(newLog.msg)
+
+  // tidy up the error output to help with max length restrictions
+  if (newLog.err) {
+    newLog['error.message'] = truncate(newLog.err.message)
+    newLog['error.stack'] = truncate(newLog.err.stack)
+    newLog['error.class'] =
+      newLog.err.name === 'Error' ? newLog.err.constructor.name : newLog.err.name
+    // clear out the old error message
+    delete newLog.err
+  }
+
+  // Add the metadata to the object being logged
+  const metadata = agent.getLinkingMetadata(true)
+  Object.keys(metadata).forEach((m) => {
+    newLog[m] = metadata[m]
+  })
+
+  return newLog
+}
+
+function createLoggerWrapper(shim, fn, fnName, bunyanLogger, nameFromLevel) {
+  const agent = shim.agent
+
+  createModuleUsageMetric('bunyan', agent.metrics)
+
+  // forward logs via the agent logs aggregator
+  bunyanLogger.addStream({
+    name: 'NRLogForwarder',
+    type: 'raw',
+    level: bunyanLogger.level(),
+    stream: {
+      write: function nrLogWrite(logLine) {
+        agent.logs.add(augmentLogData(logLine, agent, nameFromLevel))
+      }
+    }
+  })
+  // no return here means the original return value is preserved
+}
+
+module.exports = function instrument(agent, bunyan, _, shim) {
+  const config = agent.config
+
+  if (!isApplicationLoggingEnabled(config)) {
+    logger.debug('Application logging not enabled. Not instrumenting bunyan.')
+    return
+  }
+
+  const logForwardingEnabled = isLogForwardingEnabled(config, agent)
+  const localDecoratingEnabled = isLocalDecoratingEnabled(config)
+  const metricsEnabled = isMetricsEnabled(config)
+
+  if (logForwardingEnabled) {
+    shim.wrapReturn(bunyan, 'createLogger', createLoggerWrapper, [bunyan.nameFromLevel])
+  }
+
+  if (metricsEnabled || localDecoratingEnabled) {
+    shim.wrap(bunyan.prototype, '_emit', function wrapEmit(_shim, emit) {
+      return function wrappedEmit() {
+        const args = shim.argsToArray.apply(shim, arguments)
+        const rec = args[0]
+
+        if (metricsEnabled) {
+          incrementLoggingLinesMetrics(bunyan.nameFromLevel[rec.level], agent.metrics)
+        }
+
+        if (localDecoratingEnabled) {
+          rec.message = truncate(rec.msg) + agent.getNRLinkingMetadata()
+        }
+        args[0] = rec
+        return emit.apply(this, args)
+      }
+    })
+  }
+}

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/lib/instrumentations.js

@@ -15,6 +15,7 @@ module.exports = function instrumentations() {
     'cassandra-driver': { type: MODULE_TYPE.DATASTORE },
     'connect': { type: MODULE_TYPE.WEB_FRAMEWORK },
     'bluebird': { type: MODULE_TYPE.PROMISE },
+    'bunyan': { type: MODULE_TYPE.GENERIC },
     'director': { type: MODULE_TYPE.WEB_FRAMEWORK },
     'express': { type: MODULE_TYPE.WEB_FRAMEWORK },
     'fastify': { type: MODULE_TYPE.WEB_FRAMEWORK },

package/lib/metrics/names.js

@@ -277,11 +277,13 @@ const LOGGING = {
     INFO: `${LOGGING_LINES_PREFIX}/INFO`,
     WARN: `${LOGGING_LINES_PREFIX}/WARN`,
     ERROR: `${LOGGING_LINES_PREFIX}/ERROR`,
+    FATAL: `${LOGGING_LINES_PREFIX}/FATAL`,
     DEBUG: `${LOGGING_LINES_PREFIX}/DEBUG`,
     TRACE: `${LOGGING_LINES_PREFIX}/TRACE`,
     UNKNOWN: `${LOGGING_LINES_PREFIX}/UNKNOWN`
   },
   LIBS: {
+    BUNYAN: `${SUPPORTABILITY.LOGGING}/${NODEJS.PREFIX}bunyan/enabled`,
     PINO: `${SUPPORTABILITY.LOGGING}/${NODEJS.PREFIX}pino/enabled`,
     WINSTON: `${SUPPORTABILITY.LOGGING}/${NODEJS.PREFIX}winston/enabled`
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "9.2.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 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",
@@ -158,16 +159,19 @@
     "sub-install": "node test/bin/install_sub_deps",
     "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 tap --test-regex='(\\/|^test\\/unit\\/.*\\.test\\.js)$' --timeout=180 --no-coverage --reporter classic",
-    "unit:esm": "rm -f newrelic_agent.log && time tap --test-regex='(\\/|^test\\/unit\\/.*\\.test\\.mjs)$' --timeout=180 --no-coverage --reporter classic --node-arg=--experimental-loader=testdouble",
+    "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": {
@@ -199,6 +203,7 @@
     "@slack/bolt": "^3.7.0",
     "ajv": "^6.12.6",
     "async": "^3.2.4",
+    "c8": "^7.12.0",
     "chai": "^4.1.2",
     "commander": "^7.0.0",
     "eslint": "^8.24.0",