newrelic 9.0.3 → 9.2.0

package/NEWS.md

@@ -1,9 +1,43 @@
-### v9.0.3 (2022-09-06)
-
-* Updated gRPC client instrumenation to respect `grpc.record_errors` when deciding to log errors on gRPC client requests.
-
-* Fixed transaction name finalization to properly copy the appropriate transaction name to root segment.
-
+### v9.2.0 (2022-10-06)
+
+* Added ability to instrument ES Modules with the New Relic ESM Loader.
+  * [Example ESM application](https://github.com/newrelic/newrelic-node-examples/tree/main/esm-app)
+
+* Added support for custom ESM instrumentation.
+  * There is structure to registering custom ESM instrumentation.  Set the relative path to the instrumentation entry point via `api.esm.custom_instrumentation_entrypoint`
+  * [Sample custom ESM instrumentation entrypoint](https://github.com/newrelic/newrelic-node-examples/blob/main/esm-app/custom-instrumentation/index.js)
+  * All the `newrelic.instrument*` methods will still work except `newrelic.instrumentLoadedModule`.  This is because it is geared toward CommonJS modules. 
+
+* Added test for asserting ESM loader functionality on ESM-only package
+
+* Added supportability metric of `Supportability/Nodejs/Collector/MaxPayloadSizeLimit/<endpoint>` when `max_payload_size_in_bytes` configuration value is exceeded.
+
+* Removed `application_logging.forwarding.enabled` stanza from sample config as the feature is now enabled by default.
+
+### v9.1.0 (2022-09-22)
+
+* Added [experimental loader](https://nodejs.org/api/esm.html#loaders) to support instrumentation of CommonJS packages in ECMAScript Module(ESM) applications.
+  * It only supports versions of Node.js >= `16.12.0`.
+  * It is subject to change due to its experimental stability.
+
+* Enhanced supportability metrics for ESM support.
+  * Added new metrics to track usage of ESM loader(`Supportability/Features/ESM/Loader` and `Supportability/Features/ESM/UnsupportedLoader`).
+  * Updated instrumentation map to include an optional "friendly name" for tracking metrics.
+
+* Enabled re-throwing ESM import errors of `newrelic.js` so that the user is informed to rename it to `newrelic.cjs`
+
+* Fixed an issue with mongodb instrumentation where IPv6 address([::1]) was not getting mapped to localhost when setting the host attribute on the segment.
+
+* Added a test ESM loader to properly mock out agent in versioned tests.
+
+* Added ESM versioned tests for: `express`, `pg`, `mongodb`, and `@grpc/grpc-js`.
+
+### v9.0.3 (2022-09-06)
+
+* Updated gRPC client instrumentation to respect `grpc.record_errors` when deciding to log errors on gRPC client requests.
+
+* Fixed transaction name finalization to properly copy the appropriate transaction name to root segment.
+
 ### v9.0.2 (2022-08-23)
 
 * Added unit test suite for `lib/logger.js`.

package/README.md

@@ -20,11 +20,15 @@ To use New Relic's Node.js agent entails these three steps, which are described
 
 1. To install the agent for performance monitoring, use your favorite npm-based package manager and install the `newrelic` package into your application:
 
-    `$ npm install newrelic`
+    ```sh
+    $ npm install newrelic
+    ```
 
 2. Then, copy the stock configuration file to your program's base folder:
 
-    `$ cp ./node_modules/newrelic/newrelic.js ./<your destination>`
+    ```sh
+    $ cp ./node_modules/newrelic/newrelic.js ./<your destination>
+    ```
 
 3. Now, add your New Relic license key and application/service name to that file:
 
@@ -58,6 +62,28 @@ If you cannot control how your program is run, you can load the `newrelic` modul
     /* ... the rest of your program ... */
 ```
 
+## ECMAScript Modules
+
+If your application is written with `import` and `export` statements in javascript, you are using [ES Modules](https://nodejs.org/api/esm.html#modules-ecmascript-modules) and must bootstrap the agent in a different way.
+
+The New Relic Node.js agent includes ***_experimental_*** support for ES Modules. The agent is reliant on an experimental feature in Node.js in order to appropriately register instrumentation. Until the Node.js API for [ES Module Loaders](https://nodejs.org/api/esm.html#loaders) is stable, breaking changes may occur when updating Node.js. Lastly, the ESM loader does not follow the same [supported Node.js versions](https://docs.newrelic.com/docs/apm/agents/nodejs-agent/getting-started/compatibility-requirements-nodejs-agent#system) as the agent. The minimum supported version of Node.js is `v16.12.0`.
+
+### Setup
+
+ 1. If you rely on a configuration file to run the agent, you must rename the file from `newrelic.js` to `newrelic.cjs` so it can be properly loaded.  All the contents of the configuration file will behave the same once you rename. See [CommonJS modules in ESM](https://nodejs.org/api/modules.html#enabling) for more details.
+
+```sh
+$ mv newrelic.js newrelic.cjs
+```
+
+ 2. To use the newrelic ESM loader, start your program with node and use the `--experimental-loader` flag and a path to the loader file, like this:
+
+```sh
+$ 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.
+
 ## 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

@@ -64,6 +64,7 @@ code, the source code can be found at [https://github.com/newrelic/node-newrelic
 * [sinon](#sinon)
 * [tap](#tap)
 * [temp](#temp)
+* [testdouble](#testdouble)
 * [when](#when)
 
 **[optionalDependencies](#optionalDependencies)**
@@ -1333,7 +1334,7 @@ SOFTWARE.
 
 ### @newrelic/eslint-config
 
-This product includes source derived from [@newrelic/eslint-config](https://github.com/newrelic/eslint-config-newrelic) ([v0.0.3](https://github.com/newrelic/eslint-config-newrelic/tree/v0.0.3)), distributed under the [Apache-2.0 License](https://github.com/newrelic/eslint-config-newrelic/blob/v0.0.3/LICENSE):
+This product includes source derived from [@newrelic/eslint-config](https://github.com/newrelic/eslint-config-newrelic) ([v0.2.0](https://github.com/newrelic/eslint-config-newrelic/tree/v0.2.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/eslint-config-newrelic/blob/v0.2.0/LICENSE):
 
 ```
                                  Apache License
@@ -1766,7 +1767,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 ### @newrelic/test-utilities
 
-This product includes source derived from [@newrelic/test-utilities](https://github.com/newrelic/node-test-utilities) ([v7.0.0](https://github.com/newrelic/node-test-utilities/tree/v7.0.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-test-utilities/blob/v7.0.0/LICENSE):
+This product includes source derived from [@newrelic/test-utilities](https://github.com/newrelic/node-test-utilities) ([v7.1.1](https://github.com/newrelic/node-test-utilities/tree/v7.1.1)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-test-utilities/blob/v7.1.1/LICENSE):
 
 ```
                                  Apache License
@@ -2223,7 +2224,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 ### eslint-plugin-jsdoc
 
-This product includes source derived from [eslint-plugin-jsdoc](https://github.com/gajus/eslint-plugin-jsdoc) ([v36.1.1](https://github.com/gajus/eslint-plugin-jsdoc/tree/v36.1.1)), distributed under the [BSD-3-Clause License](https://github.com/gajus/eslint-plugin-jsdoc/blob/v36.1.1/LICENSE):
+This product includes source derived from [eslint-plugin-jsdoc](https://github.com/gajus/eslint-plugin-jsdoc) ([v39.3.6](https://github.com/gajus/eslint-plugin-jsdoc/tree/v39.3.6)), distributed under the [BSD-3-Clause License](https://github.com/gajus/eslint-plugin-jsdoc/blob/v39.3.6/LICENSE):
 
 ```
 Copyright (c) 2018, Gajus Kuizinas (http://gajus.com/)
@@ -2317,10 +2318,10 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 ### eslint
 
-This product includes source derived from [eslint](https://github.com/eslint/eslint) ([v7.32.0](https://github.com/eslint/eslint/tree/v7.32.0)), distributed under the [MIT License](https://github.com/eslint/eslint/blob/v7.32.0/LICENSE):
+This product includes source derived from [eslint](https://github.com/eslint/eslint) ([v8.24.0](https://github.com/eslint/eslint/tree/v8.24.0)), distributed under the [MIT License](https://github.com/eslint/eslint/blob/v8.24.0/LICENSE):
 
 ```
-Copyright JS Foundation and other contributors, https://js.foundation
+Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -8977,6 +8978,35 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 ```
 
+### testdouble
+
+This product includes source derived from [testdouble](https://github.com/testdouble/testdouble.js) ([v3.16.6](https://github.com/testdouble/testdouble.js/tree/v3.16.6)), distributed under the [MIT License](https://github.com/testdouble/testdouble.js/blob/v3.16.6/LICENSE.txt):
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2015 Test Double, LLC.
+
+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.
+
+```
+
 ### when
 
 This product includes source derived from [when](https://github.com/cujojs/when) ([v3.7.8](https://github.com/cujojs/when/tree/v3.7.8)), distributed under the [MIT License](https://github.com/cujojs/when/blob/v3.7.8/LICENSE.txt):

package/api.js

@@ -1298,7 +1298,9 @@ API.prototype.instrumentMessages = function instrumentMessages(moduleName, onReq
 }
 
 /**
- * Applies an instrumentation to an already loaded module.
+ * Applies an instrumentation to an already loaded CommonJs module.
+ *
+ * Note: This function will not work for ESM packages.
  *
  *    // oh no, express was loaded before newrelic
  *    const express   = require('express')

package/esm-loader.mjs

@@ -0,0 +1,204 @@
+/*
+ * Copyright 2022 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import newrelic from './index.js'
+import shimmer from './lib/shimmer.js'
+import loggingModule from './lib/logger.js'
+import NAMES from './lib/metrics/names.js'
+import semver from 'semver'
+import path from 'node:path'
+
+const isSupportedVersion = () => semver.gte(process.version, 'v16.12.0')
+// This check will prevent resolve hooks executing from within this file
+// If I do `import('foo')` in here it'll hit the resolve hook multiple times
+const isFromEsmLoader = (context) =>
+  context && context.parentURL && context.parentURL.includes('newrelic/esm-loader.mjs')
+
+const logger = loggingModule.child({ component: 'esm-loader' })
+const esmShimPath = new URL('./lib/esm-shim.mjs', import.meta.url)
+const customEntryPoint = newrelic?.agent?.config?.api.esm.custom_instrumentation_entrypoint
+
+// Hook point within agent for customers to register their custom instrumentation.
+if (customEntryPoint) {
+  const resolvedEntryPoint = path.resolve(customEntryPoint)
+  logger.debug('Registering custom ESM instrumentation at %s', resolvedEntryPoint)
+  await import(resolvedEntryPoint)
+}
+
+addESMSupportabilityMetrics(newrelic.agent)
+
+// exporting for testing purposes
+export const registeredSpecifiers = new Map()
+
+/**
+ * Hook chain responsible for resolving a file URL for a given module specifier
+ *
+ * Our loader has to be the last user-supplied loader if chaining is happening,
+ * as we rely on `nextResolve` being the default Node.js resolve hook to get our URL
+ *
+ * Docs: https://nodejs.org/api/esm.html#resolvespecifier-context-nextresolve
+ *
+ * @param {string} specifier string identifier in an import statement or import() expression
+ * @param {object} context metadata about the specifier, including url of the parent module and any import assertions
+ *        Optional argument that only needs to be passed when changed
+ * @param {Function} nextResolve The subsequent resolve hook in the chain, or the Node.js default resolve hook after the last user-supplied resolve hook
+ * @returns {Promise} Promise object representing the resolution of a given specifier
+ */
+export async function resolve(specifier, context, nextResolve) {
+  if (!newrelic.agent || !isSupportedVersion() || isFromEsmLoader(context)) {
+    return nextResolve(specifier, context, nextResolve)
+  }
+
+  /**
+   * We manually call the default Node.js resolve hook so
+   * that we can get the fully qualified URL path and the
+   * package type (commonjs/module/builtin) without
+   * duplicating the logic of the Node.js hook
+   */
+  const resolvedModule = await nextResolve(specifier, context, nextResolve)
+  const instrumentationName = shimmer.getInstrumentationNameFromModuleName(specifier)
+  const instrumentationDefinition = shimmer.registeredInstrumentations[instrumentationName]
+
+  if (instrumentationDefinition) {
+    const { url, format } = resolvedModule
+    logger.debug(`Instrumentation exists for ${specifier} ${format} package.`)
+
+    if (format === 'commonjs') {
+      // ES Modules translate import statements into fully qualified filepaths, so we create a copy of our instrumentation under this filepath
+      const instrumentationDefinitionCopy = Object.assign({}, instrumentationDefinition)
+
+      // Stripping the prefix is necessary because the code downstream gets this url without it
+      instrumentationDefinitionCopy.moduleName = url.replace('file://', '')
+
+      // Added to keep our Supportability metrics from exploding/including customer info via full filepath
+      instrumentationDefinitionCopy.specifier = specifier
+
+      shimmer.registerInstrumentation(instrumentationDefinitionCopy)
+
+      logger.debug(
+        `Registered CommonJS instrumentation for ${specifier} under ${instrumentationDefinitionCopy.moduleName}`
+      )
+    } else if (format === 'module') {
+      registeredSpecifiers.set(url, specifier)
+      const modifiedUrl = new URL(url)
+      // add a query param to the resolved url so the load hook below knows
+      // to rewrite and wrap the source code
+      modifiedUrl.searchParams.set('hasNrInstrumentation', 'true')
+      resolvedModule.url = modifiedUrl.href
+    } else {
+      logger.debug(`${specifier} is not a CommonJS nor ESM package, skipping for now.`)
+    }
+  }
+
+  return resolvedModule
+}
+
+/**
+ * Hook chain responsible for determining how a URL should be interpreted, retrieved, and parsed.
+ *
+ * Our loader has to be the last user-supplied loader if chaining is happening,
+ * as we rely on `nextLoad` being the default Node.js resolve hook to load the ESM.
+ *
+ * Docs: https://nodejs.org/dist/latest-v18.x/docs/api/esm.html#loadurl-context-nextload
+ *
+ * @param {string} url the URL returned by the resolve chain
+ * @param {object} context metadata about the url, including conditions, format and import assertions
+ * @param {Function} nextLoad the subsequent load hook in the chain, or the Node.js default load hook after the last user-supplied load hook
+ * @returns {Promise} Promise object representing the load of a given url
+ */
+export async function load(url, context, nextLoad) {
+  if (!newrelic.agent || !isSupportedVersion()) {
+    return nextLoad(url, context, nextLoad)
+  }
+
+  let parsedUrl
+
+  try {
+    parsedUrl = new URL(url)
+  } catch (err) {
+    logger.error('Unable to parse url: %s, msg: %s', url, err.message)
+    return nextLoad(url, context, nextLoad)
+  }
+
+  const hasNrInstrumentation = parsedUrl.searchParams.get('hasNrInstrumentation')
+
+  if (!hasNrInstrumentation) {
+    return nextLoad(url, context, nextLoad)
+  }
+
+  /**
+   * undo the work we did in the resolve hook above
+   * so we can properly rewrite source and not get in an infinite loop
+   */
+  parsedUrl.searchParams.delete('hasNrInstrumentation')
+
+  const originalUrl = parsedUrl.href
+  const specifier = registeredSpecifiers.get(originalUrl)
+  const rewrittenSource = await wrapEsmSource(originalUrl, specifier)
+  logger.debug(`Registered module instrumentation for ${specifier}.`)
+
+  return {
+    format: 'module',
+    source: rewrittenSource,
+    shortCircuit: true
+  }
+}
+
+/**
+ * Helper function for determining which of our Supportability metrics to use for the current loader invocation
+ *
+ * @param {object} agent
+ *        instantiation of the New Relic agent
+ * @returns {void}
+ */
+function addESMSupportabilityMetrics(agent) {
+  if (!agent) {
+    return
+  }
+
+  if (isSupportedVersion()) {
+    agent.metrics.getOrCreateMetric(NAMES.FEATURES.ESM.LOADER).incrementCallCount()
+  } else {
+    logger.warn(
+      'New Relic for Node.js ESM loader requires a version of Node >= v16.12.0; your version is %s.  Instrumentation will not be registered.',
+      process.version
+    )
+    agent.metrics.getOrCreateMetric(NAMES.FEATURES.ESM.UNSUPPORTED_LOADER).incrementCallCount()
+  }
+
+  if (customEntryPoint) {
+    agent.metrics.getOrCreateMetric(NAMES.FEATURES.ESM.CUSTOM_INSTRUMENTATION).incrementCallCount()
+  }
+}
+
+/**
+ * Rewrites the source code of a ES module we want to instrument.
+ * 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.
+ *
+ * @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
+ */
+async function wrapEsmSource(url, specifier) {
+  const pkg = await import(url)
+  const props = Object.keys(pkg)
+  const trimmedUrl = url.replace('file://', '')
+
+  return `
+    import wrapModule from '${esmShimPath.href}'
+    import * as _originalModule from '${url}'
+    const _wrappedModule = wrapModule(_originalModule, '${specifier}', '${trimmedUrl}')
+    ${props
+      .map((propName) => {
+        const propertyExportSource = `
+    let _${propName} = _wrappedModule.${propName}
+    export { _${propName} as ${propName} }`
+
+        return propertyExportSource
+      })
+      .join('\n')}
+  `
+}

package/index.js

@@ -134,7 +134,7 @@ function createAgent(config) {
   if (appNames.length < 1) {
     const message =
       'New Relic requires that you name this application!\n' +
-      'Set app_name in your newrelic.js file or set environment variable\n' +
+      'Set app_name in your newrelic.js or newrelic.cjs file or set environment variable\n' +
       'NEW_RELIC_APP_NAME. Not starting!'
     logger.error(message)
     throw new Error(message)

package/lib/collector/remote-method.js

@@ -235,6 +235,9 @@ RemoteMethod.prototype._safeRequest = function _safeRequest(options) {
   let level = 'trace'
 
   if (!isValidLength(options.body, maxPayloadSize)) {
+    this._agent.metrics
+      .getOrCreateMetric(`${DATA_USAGE.PREFIX}/MaxPayloadSizeLimit/${this.name}`)
+      .incrementCallCount()
     logger.warn(
       'The payload size %d being sent to method %s exceeded the maximum size of %d',
       Buffer.byteLength(options.body, 'utf8'),

package/lib/config/default.js

@@ -26,7 +26,7 @@ exports.config = () => ({
   license_key: '',
   /**
    *
-   * Enables/Disables security politices.  Paste your security policies
+   * Enables/Disables security policies.  Paste your security policies
    * token from the New Relic Admin below.
    *
    * @env NEW_RELIC_SECURITY_POLICIES_TOKEN
@@ -623,7 +623,15 @@ exports.config = () => ({
      *
      * @env NEW_RELIC_API_NOTICE_ERROR
      */
-    notice_error_enabled: true
+    notice_error_enabled: true,
+    /**
+     * Sets the path to custom ESM instrumentation
+     *
+     * @env NEW_RELIC_API_ESM_CUSTOM_INSTRUMENTATION_ENTRYPOINT
+     */
+    esm: {
+      custom_instrumentation_entrypoint: null
+    }
   },
   /**
    * Transaction Events

package/lib/config/env.js

@@ -114,7 +114,10 @@ const ENV_MAPPING = {
   api: {
     custom_attributes_enabled: 'NEW_RELIC_API_CUSTOM_ATTRIBUTES',
     custom_events_enabled: 'NEW_RELIC_API_CUSTOM_EVENTS',
-    notice_error_enabled: 'NEW_RELIC_API_NOTICE_ERROR'
+    notice_error_enabled: 'NEW_RELIC_API_NOTICE_ERROR',
+    esm: {
+      custom_instrumentation_entrypoint: 'NEW_RELIC_API_ESM_CUSTOM_INSTRUMENTATION_ENTRYPOINT'
+    }
   },
   datastore_tracer: {
     instance_reporting: {

package/lib/config/index.js

@@ -1647,6 +1647,10 @@ function initialize(config) {
   try {
     userConf = require(filepath).config
   } catch (error) {
+    if (error.code === 'ERR_REQUIRE_ESM') {
+      // Attempted to import newrelic.js or similar from an ESM module, error out early.
+      throw error
+    }
     logger.error(error)
 
     logger.warn(

package/lib/esm-shim.mjs

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import shimmer from './shimmer.js'
+import newrelic from '../index.js'
+const { agent } = newrelic
+
+export default function wrapModule(module, moduleName, resolvedPath) {
+  const proxiedProps = Object.assign(Object.create(null), module)
+  const proxiedModule = new Proxy(module, {
+    get: (target, key) => {
+      return proxiedProps[key] || target[key]
+    },
+    set: (target, key, val) => {
+      return (proxiedProps[key] = val)
+    },
+    /**
+     * This is normally not allowed.
+     *  We have some things that define property, unsure if at the module level.
+     * Ideally, we can get away from doing this sort of thing at all in the future
+     * in a post AsyncLocalStorage world, etc.
+     * If we never do at the module level, perhaps we can not define this or defer upstream
+     *
+     * @param target
+     * @param key
+     * @param descriptor
+     */
+    defineProperty: (target, key, descriptor) => {
+      return Object.defineProperty(proxiedProps, key, descriptor)
+    }
+  })
+
+  return shimmer.instrumentPostLoad(agent, proxiedModule, moduleName, resolvedPath, true)
+}

package/lib/instrumentation/mongodb/v4-mongo.js

@@ -45,7 +45,7 @@ function cmdStartedHandler(shim, evnt) {
       if (hosts && hosts.length && hosts[0].socketPath) {
         port = hosts[0].socketPath
       }
-    } else if (['127.0.0.1', '::1'].includes(host)) {
+    } else if (['127.0.0.1', '::1', '[::1]'].includes(host)) {
       host = 'localhost'
     }
 

package/lib/metrics/names.js

@@ -257,6 +257,11 @@ const INFINITE_TRACING = {
 }
 
 const FEATURES = {
+  ESM: {
+    LOADER: `${SUPPORTABILITY.FEATURES}/ESM/Loader`,
+    UNSUPPORTED_LOADER: `${SUPPORTABILITY.FEATURES}/ESM/UnsupportedLoader`,
+    CUSTOM_INSTRUMENTATION: `${SUPPORTABILITY.FEATURES}/ESM/CustomInstrumentation`
+  },
   CERTIFICATES: SUPPORTABILITY.FEATURES + '/Certificates',
   INSTRUMENTATION: {
     ON_RESOLVED: SUPPORTABILITY.FEATURES + '/Instrumentation/OnResolved',

package/lib/shimmer.js

@@ -467,12 +467,12 @@ const shimmer = (module.exports = {
     return instrumentation
   },
 
-  instrumentPostLoad(agent, module, moduleName, resolvedName) {
+  instrumentPostLoad(agent, module, moduleName, resolvedName, returnModule = false) {
     const result = _postLoad(agent, module, moduleName, resolvedName)
     // This is to not break the public API
     // previously it would just call instrumentation
     // and not check the result
-    return !!result.__NR_instrumented
+    return returnModule ? result : !!result.__NR_instrumented
   }
 })
 
@@ -517,7 +517,12 @@ function instrumentPostLoad(agent, nodule, moduleName, resolvedName) {
   const shim = shims.createShimFromType(instrumentation.type, agent, moduleName, resolvedName)
 
   applyDebugState(shim, nodule)
-  trackInstrumentationUsage(agent, shim, moduleName, NAMES.FEATURES.INSTRUMENTATION.ON_REQUIRE)
+  trackInstrumentationUsage(
+    agent,
+    shim,
+    instrumentation.specifier || moduleName,
+    NAMES.FEATURES.INSTRUMENTATION.ON_REQUIRE
+  )
 
   try {
     if (instrumentation.onRequire(shim, nodule, moduleName) !== false) {
@@ -613,7 +618,12 @@ function _instrumentOnResolved(agent, moduleName, resolvedFilepath) {
 
   const shim = shims.createShimFromType(instrumentation.type, agent, moduleName, resolvedFilepath)
 
-  trackInstrumentationUsage(agent, shim, moduleName, NAMES.FEATURES.INSTRUMENTATION.ON_RESOLVED)
+  trackInstrumentationUsage(
+    agent,
+    shim,
+    instrumentation.specifier || moduleName,
+    NAMES.FEATURES.INSTRUMENTATION.ON_RESOLVED
+  )
 
   try {
     instrumentation.onResolved(shim, moduleName, resolvedFilepath)

package/newrelic.js

@@ -28,14 +28,6 @@ exports.config = {
    * attributes include/exclude lists.
    */
   allow_all_headers: true,
-  application_logging: {
-    forwarding: {
-      /**
-       * Toggles whether the agent gathers log records for sending to New Relic.
-       */
-      enabled: true
-    }
-  },
   attributes: {
     /**
      * Prefix of attributes to exclude from all destinations. Allows * as wildcard

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "9.0.3",
+  "version": "9.2.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -113,6 +113,16 @@
       "name": "Jordi Gutiérrez Hermoso",
       "email": "jgutierrezhermoso@newrelic.com",
       "web": "https://newrelic.com"
+    },
+    {
+      "name": "Maurice Rickard",
+      "email": "mrickard@newrelic.com",
+      "web": "https://newrelic.com"
+    },
+    {
+      "name": "Jessica Lopatta",
+      "email": "jlopatta@newrelic.com",
+      "web": "https://newrelic.com"
     }
   ],
   "description": "New Relic agent",
@@ -138,17 +148,18 @@
     "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",
     "prepare-test": "npm run ssl && npm run docker-env",
-    "lint": "eslint ./*.js lib test bin examples",
-    "lint:fix": "eslint --fix, ./*.js lib test bin examples",
+    "lint": "eslint ./*.{js,mjs} lib test bin examples",
+    "lint:fix": "eslint --fix, ./*.{js,mjs} lib test bin examples",
     "public-docs": "jsdoc -c ./jsdoc-conf.json --tutorials examples/shim api.js lib/shim/ lib/transaction/handle.js && cp examples/shim/*.png out/",
     "publish-docs": "./bin/publish-docs.sh",
     "services": "./bin/docker-services.sh",
     "smoke": "npm run ssl && time tap test/smoke/**/**/*.tap.js --timeout=180 --no-coverage",
     "ssl": "./bin/ssl.sh",
     "sub-install": "node test/bin/install_sub_deps",
-    "test": "npm run integration && npm run unit",
+    "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",
     "update-cross-agent-tests": "./bin/update-cats.sh",
     "versioned-tests": "./bin/run-versioned-tests.sh",
     "update-changelog-version": "node ./bin/update-changelog-version",
@@ -180,21 +191,21 @@
     "@newrelic/native-metrics": "^9.0.0"
   },
   "devDependencies": {
-    "@newrelic/eslint-config": "^0.0.3",
+    "@newrelic/eslint-config": "^0.2.0",
     "@newrelic/newrelic-oss-cli": "^0.1.2",
     "@newrelic/proxy": "^2.0.0",
-    "@newrelic/test-utilities": "^7.0.0",
+    "@newrelic/test-utilities": "^7.1.1",
     "@octokit/rest": "^18.0.15",
     "@slack/bolt": "^3.7.0",
     "ajv": "^6.12.6",
     "async": "^3.2.4",
     "chai": "^4.1.2",
     "commander": "^7.0.0",
-    "eslint": "^7.32.0",
+    "eslint": "^8.24.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-disable": "^2.0.1",
     "eslint-plugin-header": "^3.1.1",
-    "eslint-plugin-jsdoc": "^36.1.0",
+    "eslint-plugin-jsdoc": "^39.3.6",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^3.4.0",
     "express": "*",
@@ -215,6 +226,7 @@
     "sinon": "^4.5.0",
     "tap": "^16.0.1",
     "temp": "^0.8.1",
+    "testdouble": "^3.16.6",
     "when": "*"
   },
   "repository": {
@@ -232,6 +244,7 @@
     "THIRD_PARTY_NOTICES.md",
     "lib/",
     "bin/tracetractor",
-    "bin/test-naming-rules.js"
+    "bin/test-naming-rules.js",
+    "esm-loader.mjs"
   ]
 }