newrelic 10.6.2 → 11.0.0

package/lib/shimmer.js

@@ -12,6 +12,9 @@ const logger = require('./logger').child({ component: 'shimmer' })
 const INSTRUMENTATIONS = require('./instrumentations')()
 const properties = require('./util/properties')
 const shims = require('./shim')
+const { Hook } = require('require-in-the-middle')
+const IitmHook = require('import-in-the-middle')
+let pkgsToHook = []
 
 const NAMES = require('./metrics/names')
 const symbols = require('./symbols')
@@ -65,13 +68,6 @@ const CORE_INSTRUMENTATION = {
   }
 }
 
-const FORCE_MODULE_RESOLUTION_WARNING =
-  'Unable to retrieve cached path for one or more modules ' +
-  'with an already loaded parent. Forcing resolution. ' +
-  'This should not occur during normal agent execution. ' +
-  'Module resolution performance my be impacted. ' +
-  'See trace-level logs for specific modules.'
-
 /**
  * Unwrapping is only likely to be used by test code, and is a fairly drastic
  * maneuver, but it should be pretty safe if there's a desire to reboot the
@@ -279,79 +275,6 @@ const shimmer = (module.exports = {
     instrumented = []
   },
 
-  /**
-   * Patch the module.load function so that we see modules loading and
-   * have an opportunity to patch them with instrumentation.
-   *
-   * @param agent
-   */
-  patchModule: function patchModule(agent) {
-    logger.trace('Wrapping module loader.')
-    const Module = require('module')
-    const filepathMap = {}
-
-    shimmer.wrapMethod(Module, 'Module', '_resolveFilename', function wrapRes(resolve) {
-      return function wrappedResolveFilename(file) {
-        // This is triggered by the load call, so record the path that has been seen so
-        // we can examine it after the load call has returned.
-        const resolvedFilepath = resolve.apply(this, arguments)
-
-        // Only fire the first time we see a specific module resolved
-        if (filepathMap[file] !== resolvedFilepath) {
-          filepathMap[file] = resolvedFilepath
-
-          _onResolveFileName(agent, file, resolvedFilepath)
-        }
-
-        return resolvedFilepath
-      }
-    })
-
-    shimmer.wrapMethod(Module, 'Module', '_load', function wrapLoad(load) {
-      return function wrappedLoad(request, parent, isMain) {
-        // _load() will invoke _resolveFilename() first time resolving a module.
-        const m = load.apply(this, arguments)
-
-        const fileName = resolveFileName(request, parent, isMain)
-        return _postLoad(agent, m, request, fileName)
-      }
-    })
-
-    /**
-     * Forces file name resolve for modules not in our cache when
-     * their parent has already been loaded/cached by Node.
-     * Provides a fall-back for unexpected cases that may occur.
-     * Also provides flexibility for testing now that node 11+ caches these.
-     *
-     * @param {*} request
-     * @param {*} parent
-     * @param {*} isMain
-     */
-    function resolveFileName(request, parent, isMain) {
-      const cachedPath = filepathMap[request]
-      if (!cachedPath && parent && parent.loaded) {
-        logger.warnOnce('Force Resolution', FORCE_MODULE_RESOLUTION_WARNING)
-
-        if (logger.traceEnabled()) {
-          logger.trace(`No cached path found for ${request}. Forcing resolution.`)
-        }
-
-        // Our patched _resolveFilename will cache. No need to here.
-        return Module._resolveFilename(request, parent, isMain)
-      }
-
-      return cachedPath
-    }
-  },
-
-  unpatchModule: function unpatchModule() {
-    logger.trace('Unwrapping to previous module loader.')
-    const Module = require('module')
-
-    shimmer.unwrapMethod(Module, 'Module', '_resolveFilename')
-    shimmer.unwrapMethod(Module, 'Module', '_load')
-  },
-
   /**
    * Registers all instrumentation for 3rd party libraries.
    *
@@ -372,9 +295,6 @@ const shimmer = (module.exports = {
           logger.warn('Failed to load instrumentation for ' + instrInfo.module, e)
           return
         }
-      } else if (moduleName === 'amqplib') {
-        // TODO: Remove this code when amqplib instrumentation is made external.
-        require('./instrumentation/amqplib').selfRegister(shimmer)
       } else {
         const fileName = path.join(__dirname, 'instrumentation', moduleName + '.js')
         shimmer.registerInstrumentation({
@@ -404,7 +324,7 @@ const shimmer = (module.exports = {
   registerCoreInstrumentation(agent) {
     // Instrument global.
     const globalShim = new shims.Shim(agent, 'globals', 'globals')
-    applyDebugState(globalShim, global)
+    applyDebugState(globalShim, global, false)
     const globalsFilepath = path.join(__dirname, 'instrumentation', 'core', 'globals.js')
     _firstPartyInstrumentation(agent, globalsFilepath, globalShim, global, 'globals')
 
@@ -420,10 +340,39 @@ const shimmer = (module.exports = {
       }
 
       const shim = shims.createShimFromType(core.type, agent, mojule, mojule)
-      applyDebugState(shim, core)
+      applyDebugState(shim, core, false)
       _firstPartyInstrumentation(agent, filePath, shim, uninstrumented, mojule)
     }
   },
+  // TODO: remove the following methods once test-utilities have been updated and released
+  // with the new registerHooks and removeHooks methods
+  patchModule(agent) {
+    shimmer.registerHooks(agent)
+  },
+  unpatchModule() {
+    shimmer.removeHooks()
+  },
+  registerHooks(agent) {
+    this._ritm = new Hook(pkgsToHook, function onHook(exports, name, basedir) {
+      return _postLoad(agent, exports, name, basedir)
+    })
+    this._iitm = new IitmHook(pkgsToHook, function onESMHook(exports, name, basedir) {
+      return _postLoad(agent, exports, name, basedir, true)
+    })
+  },
+  removeHooks() {
+    if (this._ritm) {
+      this._ritm.unhook()
+      this._ritm = null
+    }
+
+    if (this._iitm) {
+      this._iitm.unhook()
+      this._iitm = null
+    }
+
+    pkgsToHook = []
+  },
 
   bootstrapInstrumentation: function bootstrapInstrumentation(agent) {
     shimmer.registerCoreInstrumentation(agent)
@@ -439,6 +388,12 @@ const shimmer = (module.exports = {
 
     if (!registeredInstrumentation) {
       shimmer.registeredInstrumentations[opts.moduleName] = []
+      // not using a set because this is shared by reference
+      // to allow custom instrumentation to be loaded after the
+      // agent is bootstrapped
+      if (!pkgsToHook.includes(opts.moduleName)) {
+        pkgsToHook.push(opts.moduleName)
+      }
     }
 
     shimmer.registeredInstrumentations[opts.moduleName].push({ ...opts })
@@ -511,16 +466,18 @@ const shimmer = (module.exports = {
   }
 })
 
-function applyDebugState(shim, nodule) {
+function applyDebugState(shim, nodule, inEsm) {
   if (shimmer.debug) {
     shim.enableDebug()
     instrumented.push(shim)
-    instrumented.push({
-      [symbols.unwrap]: function unwrapNodule() {
-        delete nodule[symbols.shim]
-      }
-    })
-    nodule[symbols.shim] = shim
+    if (!inEsm) {
+      instrumented.push({
+        [symbols.unwrap]: function unwrapNodule() {
+          delete nodule[symbols.shim]
+        }
+      })
+      nodule[symbols.shim] = shim
+    }
   }
 }
 
@@ -533,8 +490,9 @@ function applyDebugState(shim, nodule) {
  * @param nodule
  * @param moduleName
  * @param resolvedName
+ * @param esmResolver
  */
-function instrumentPostLoad(agent, nodule, moduleName, resolvedName) {
+function instrumentPostLoad(agent, nodule, moduleName, resolvedName, esmResolver) {
   const instrumentations = shimmer.registeredInstrumentations[moduleName]
   instrumentations.forEach((instrumentation) => {
     if (
@@ -548,6 +506,10 @@ function instrumentPostLoad(agent, nodule, moduleName, resolvedName) {
       return
     }
 
+    // We only return the .default when we're a CJS module in the import-in-the-middle(ESM)
+    // callback hook
+    const resolvedNodule = instrumentation.isEsm || !esmResolver ? nodule : nodule.default
+
     const shim = shims.createShimFromType(
       instrumentation.type,
       agent,
@@ -556,7 +518,7 @@ function instrumentPostLoad(agent, nodule, moduleName, resolvedName) {
       instrumentation.shimName
     )
 
-    applyDebugState(shim, nodule)
+    applyDebugState(shim, resolvedNodule, esmResolver)
     trackInstrumentationUsage(
       agent,
       shim,
@@ -573,7 +535,7 @@ function instrumentPostLoad(agent, nodule, moduleName, resolvedName) {
     }
 
     try {
-      if (instrumentation.onRequire(shim, nodule, moduleName) !== false) {
+      if (instrumentation.onRequire(shim, resolvedNodule, moduleName) !== false) {
         nodule = shim.getExport(nodule)
         instrumentation[symbols.instrumented] = true
       }
@@ -621,7 +583,7 @@ function _firstPartyInstrumentation(agent, fileName, shim, nodule, moduleName) {
   }
 }
 
-function _postLoad(agent, nodule, name, resolvedName) {
+function _postLoad(agent, nodule, name, resolvedName, esmResolver) {
   const instrumentation = shimmer.getInstrumentationNameFromModuleName(name)
   const registeredInstrumentation = shimmer.registeredInstrumentations[instrumentation]
   const hasPostLoadInstrumentation =
@@ -632,76 +594,12 @@ function _postLoad(agent, nodule, name, resolvedName) {
   // Check if this is a known instrumentation and then run it.
   if (hasPostLoadInstrumentation) {
     logger.trace('Instrumenting %s with onRequire (module loaded) hook.', name)
-    return instrumentPostLoad(agent, nodule, instrumentation, resolvedName)
+    return instrumentPostLoad(agent, nodule, instrumentation, resolvedName, esmResolver)
   }
 
   return nodule
 }
 
-function _onResolveFileName(agent, requiredNameOrPath, resolvedFilepath) {
-  const instrumentation = shimmer.getInstrumentationNameFromModuleName(requiredNameOrPath)
-  const registeredInstrumentation = shimmer.registeredInstrumentations[instrumentation]
-  const hasResolvedFileInstrumentation =
-    registeredInstrumentation &&
-    registeredInstrumentation.length &&
-    registeredInstrumentation.filter((instrumentation) => instrumentation.onResolved).length
-
-  // Check if this is a known instrumentation and then run it.
-  if (hasResolvedFileInstrumentation) {
-    logger.trace('Instrumenting %s with onResolved hook.', requiredNameOrPath)
-    _instrumentOnResolved(agent, instrumentation, resolvedFilepath)
-  }
-}
-
-/**
- * Invokes the onResolved handler with a shim instance.
- *
- * Given Node.js caches resolvedFilePaths in versions we support and we cache as well
- * for the cases we force resolution, we should not run into the case of multiple
- * invocations for the same module. As such, this function does not defend against multiple runs.
- *
- * @param agent
- * @param moduleName
- * @param resolvedFilepath
- */
-function _instrumentOnResolved(agent, moduleName, resolvedFilepath) {
-  const instrumentations = shimmer.registeredInstrumentations[moduleName]
-  instrumentations.forEach((instrumentation) => {
-    const shim = shims.createShimFromType(instrumentation.type, agent, moduleName, resolvedFilepath)
-
-    trackInstrumentationUsage(
-      agent,
-      shim,
-      instrumentation.specifier || moduleName,
-      NAMES.FEATURES.INSTRUMENTATION.ON_RESOLVED
-    )
-
-    try {
-      instrumentation.onResolved(shim, moduleName, resolvedFilepath)
-    } catch (instrumentationError) {
-      if (instrumentation.onError) {
-        try {
-          instrumentation.onError(instrumentationError)
-        } catch (error) {
-          logger.warn(
-            error,
-            instrumentationError,
-            'OnResolved instrumentation for %s failed, then the onError handler threw an error',
-            moduleName
-          )
-        }
-      } else {
-        logger.warn(
-          instrumentationError,
-          'OnResolved instrumentation for %s failed. Please report this to the ' +
-            'maintainers of the custom instrumentation.',
-          moduleName
-        )
-      }
-    }
-  })
-}
-
 function hasValidRegisterOptions(opts) {
   if (!opts) {
     logger.warn('Instrumentation registration failed, no options provided')
@@ -713,7 +611,7 @@ function hasValidRegisterOptions(opts) {
     return false
   }
 
-  if (!opts.onRequire && !opts.onResolved) {
+  if (!opts.onRequire) {
     logger.warn(
       'Instrumentation registration for %s failed, no require hooks provided.',
       opts.moduleName
@@ -732,7 +630,8 @@ function hasValidRegisterOptions(opts) {
  * @param {*} agent The agent instance.
  * @param {*} shim The instance of the shim used to instrument the module.
  * @param {string} moduleName The name of the required module.
- * @param {string} metricPrefix Support metric prefix to prepend to the metrics. Will indicate onRequire or onResolved
+ * @param {string} metricPrefix Support metric prefix to prepend to the metrics. Will indicate onRequire
+ *
  * from NAMES.FEATURES.INSTRUMENTATION.
  */
 function trackInstrumentationUsage(agent, shim, moduleName, metricPrefix) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "10.6.2",
+  "version": "11.0.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -136,7 +136,7 @@
   ],
   "homepage": "https://github.com/newrelic/node-newrelic",
   "engines": {
-    "node": ">=14",
+    "node": ">=16",
     "npm": ">=6.0.0"
   },
   "directories": {
@@ -146,8 +146,7 @@
     "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-regex='(\\/|^test\\/integration\\/.*\\.tap\\.js)$' --timeout=180 --no-coverage --reporter classic",
-    "integration:async-local": "npm run prepare-test && npm run sub-install && time c8 -o ./coverage/integration-async-local tap --test-regex='(\\/|^test\\/integration\\/.*\\.tap\\.js)$' --timeout=360 --no-coverage --reporter classic --test-env=NEW_RELIC_FEATURE_FLAG_ASYNC_LOCAL_CONTEXT=1",
+    "integration": "npm run prepare-test && npm run sub-install && time c8 -o ./coverage/integration tap --test-regex='(\\/|^test\\/integration\\/.*\\.tap\\.js)$' --timeout=300 --no-coverage --reporter classic",
     "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,20 +157,18 @@
     "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 && npm run unit:esm",
+    "test": "npm run integration && npm run unit",
     "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:scripts": "time c8 -o ./coverage/scripts-unit tap --test-regex='(\\/|^bin\\/test\\/.*\\.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:major": "VERSIONED_MODE=--major npm run versioned",
     "versioned": "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",
-    "versioned:async-local:major": "NEW_RELIC_FEATURE_FLAG_ASYNC_LOCAL_CONTEXT=1 npm run versioned:major",
+    "versioned:legacy-context": "NEW_RELIC_FEATURE_FLAG_LEGACY_CONTEXT_MANAGER=1 npm run versioned",
+    "versioned:legacy_context:major": "NEW_RELIC_FEATURE_FLAG_LEGACY_CONTEXT_MANAGER=1 npm run versioned:major",
     "versioned:security": "NEW_RELIC_SECURITY_AGENT_ENABLED=true npm run versioned",
     "versioned:security:major": "NEW_RELIC_SECURITY_AGENT_ENABLED=true npm run versioned:major",
     "prepare": "husky install"
@@ -182,28 +179,30 @@
   "dependencies": {
     "@grpc/grpc-js": "^1.8.10",
     "@grpc/proto-loader": "^0.7.5",
-    "@mrleebo/prisma-ast": "^0.5.2",
-    "@newrelic/aws-sdk": "^6.0.0",
-    "@newrelic/koa": "^7.1.1",
+    "@newrelic/aws-sdk": "^7.0.0",
+    "@newrelic/koa": "^8.0.0",
     "@newrelic/security-agent": "0.2.1",
-    "@newrelic/superagent": "^6.0.0",
+    "@newrelic/superagent": "^7.0.0",
     "@tyriar/fibonacci-heap": "^2.0.7",
     "concat-stream": "^2.0.0",
     "https-proxy-agent": "^7.0.1",
+    "import-in-the-middle": "^1.4.2",
     "json-bigint": "^1.0.0",
     "json-stringify-safe": "^5.0.0",
     "readable-stream": "^3.6.1",
+    "require-in-the-middle": "^7.2.0",
     "semver": "^7.5.2",
     "winston-transport": "^4.5.0"
   },
   "optionalDependencies": {
     "@contrast/fn-inspect": "^3.3.0",
-    "@newrelic/native-metrics": "^9.0.1"
+    "@newrelic/native-metrics": "^10.0.0",
+    "@prisma/prisma-fmt-wasm": "^4.17.0-16.27eb2449f178cd9fe1a4b892d732cc4795f75085"
   },
   "devDependencies": {
     "@newrelic/eslint-config": "^0.3.0",
     "@newrelic/newrelic-oss-cli": "^0.1.2",
-    "@newrelic/test-utilities": "^7.3.2",
+    "@newrelic/test-utilities": "^8.0.0",
     "@octokit/rest": "^18.0.15",
     "@slack/bolt": "^3.7.0",
     "ajv": "^6.12.6",
@@ -242,7 +241,6 @@
     "sinon": "^4.5.0",
     "tap": "^16.3.4",
     "temp": "^0.8.1",
-    "testdouble": "3.17.2",
     "when": "*"
   },
   "repository": {

package/lib/context-manager/diagnostics/legacy-diagnostic-context-manager.js

@@ -1,36 +0,0 @@
-/*
- * Copyright 2021 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-
-const LegacyContextManager = require('../legacy-context-manager')
-
-/**
- * Overrides setContext to add diagnostic logging around setting and removing
- * from context. Currently just supports the segment.probe().
- *
- * Exists in own class to keep default context management as minimal/efficient as possible
- * given we wrap pretty much every functions execution.
- */
-class LegacyDiagnosticContextManager extends LegacyContextManager {
-  setContext(newContext) {
-    this._logDiagnostic(this._context, 'Removed from context')
-
-    this._context = newContext
-
-    this._logDiagnostic(newContext, 'Set in context')
-  }
-
-  _logDiagnostic(context, message) {
-    // This is to currently support diagnostic logging of segments which gets attached to
-    // transactions with a stack trace. All of this is output at once at the end of a transaction
-    // when enabled for clear tracing.
-    if (context && context.probe) {
-      context.probe(message)
-    }
-  }
-}
-
-module.exports = LegacyDiagnosticContextManager

package/lib/esm-shim.mjs

@@ -1,36 +0,0 @@
-/*
- * 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)
-}