newrelic 10.6.2 → 11.1.0

package/esm-loader.mjs

@@ -3,228 +3,4 @@
  * 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'
-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
-// 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 (registeredSpecifiers.get(url)) {
-      logger.debug(
-        `Instrumentation already registered for ${specifier} under ${fileURLToPath(
-          url
-        )}, skipping resolve hook...`
-      )
-    } else 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 = [...instrumentationDefinition]
-
-      instrumentationDefinitionCopy.forEach((copy) => {
-        // Stripping the prefix is necessary because the code downstream gets this url without it
-        copy.moduleName = fileURLToPath(url)
-
-        // Added to keep our Supportability metrics from exploding/including customer info via full filepath
-        copy.specifier = specifier
-        shimmer.registerInstrumentation(copy)
-        logger.debug(
-          `Registered CommonJS instrumentation for ${specifier} under ${copy.moduleName}`
-        )
-      })
-
-      // Keep track of what we've registered so we don't double register (see: https://github.com/newrelic/node-newrelic/issues/1646)
-      registeredSpecifiers.set(url, { specifier })
-    } else if (format === 'module') {
-      addNrInstrumentation(resolvedModule)
-      registeredSpecifiers.set(url, { specifier, hasNrInstrumentation: true })
-    } else {
-      logger.debug(`${specifier} is not a CommonJS nor ESM package, skipping for now.`)
-    }
-  }
-
-  return resolvedModule
-}
-
-/**
- * This is purely done so that we can import the incoming specifier
- * in the load hook.  It used to be used to determine if instrumentation existed
- * for specifier but we found a RCE with that solution.
- *
- * @param {object} resolvedModule the result of call resolve on a specifier
- */
-function addNrInstrumentation(resolvedModule) {
-  const modifiedUrl = new URL(resolvedModule.url)
-  modifiedUrl.searchParams.set('hasNrInstrumentation', 'true')
-  resolvedModule.url = modifiedUrl.href
-}
-
-/**
- * Extracts the href without query params
- *
- * @param {string} url url of specifier
- * @returns {string} new url without hasNrInstrumentation query param
- */
-function removeNrInstrumentation(url) {
-  let parsedUrl
-
-  try {
-    parsedUrl = new URL(url)
-    url = parsedUrl.href.split('?')[0]
-  } catch (err) {
-    logger.error('Unable to parse url: %s, msg: %s', url, err.message)
-  }
-
-  return url
-}
-
-/**
- * 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)
-  }
-
-  url = removeNrInstrumentation(url)
-
-  const pkg = registeredSpecifiers.get(url)
-
-  if (!pkg?.hasNrInstrumentation) {
-    return nextLoad(url, context, nextLoad)
-  }
-
-  const { specifier } = pkg
-
-  const rewrittenSource = await wrapEsmSource(url, 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.
- *
- * 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
- */
-async function wrapEsmSource(url, specifier) {
-  const pkg = await import(url)
-  const props = Object.keys(pkg)
-  const trimmedUrl = fileURLToPath(url)
-
-  return `
-    import wrapModule from '${esmShimPath.href}'
-    import * as _originalModule from '${url}'
-    const _wrappedModule = wrapModule(_originalModule, '${specifier}', '${trimmedUrl}')
-    ${props
-      .map((propName) => {
-        return `
-    let _${propName} = _wrappedModule.${propName}
-    export { _${propName} as ${propName} }`
-      })
-      .join('\n')}
-  `
-}
+export * from 'import-in-the-middle/hook.mjs'

package/index.js

@@ -8,6 +8,7 @@
 // Record opening times before loading any other files.
 const preAgentTime = process.uptime()
 const agentStart = Date.now()
+const { isMainThread } = require('worker_threads')
 
 // Load unwrapped core now to ensure it gets the freshest properties.
 require('./lib/util/unwrapped-core')
@@ -16,8 +17,14 @@ const featureFlags = require('./lib/feature_flags').prerelease
 const psemver = require('./lib/util/process-version')
 let logger = require('./lib/logger') // Gets re-loaded after initialization.
 const NAMES = require('./lib/metrics/names')
+const isESMSupported = psemver.satisfies('>=16.2.0')
 
 const pkgJSON = require('./package.json')
+if (!isMainThread) {
+  logger.warn('Using New Relic for Node.js in worker_threads is not supported. Not starting!')
+  return
+}
+
 logger.info(
   'Using New Relic for Node.js. Agent version: %s; Node version: %s.',
   pkgJSON.version,
@@ -150,12 +157,12 @@ function createAgent(config) {
   }
 
   const shimmer = require('./lib/shimmer')
-  shimmer.patchModule(agent)
   shimmer.bootstrapInstrumentation(agent)
 
   // Check for already loaded modules and warn about them.
   const uninstrumented = require('./lib/uninstrumented')
   uninstrumented.check(shimmer.registeredInstrumentations)
+  shimmer.registerHooks(agent)
 
   agent.start(function afterStart(error) {
     if (error) {
@@ -221,22 +228,33 @@ function recordFeatureFlagMetrics(agent) {
  *  3. require('newrelic')
  *
  *  Then a supportability metric is loaded to decide.
- *  Note: We already take care of scenario #2 in newrelic/esm-loader.mjs
  *
  * @param {Agent} agent active NR agent
  */
 function recordLoaderMetric(agent) {
-  const isESM = agent.metrics.getMetric(NAMES.FEATURES.ESM.LOADER)
   let isDashR = false
 
   process.execArgv.forEach((arg, index) => {
     if (arg === '-r' && process.execArgv[index + 1] === 'newrelic') {
       agent.metrics.getOrCreateMetric(NAMES.FEATURES.CJS.PRELOAD).incrementCallCount()
       isDashR = true
+    } else if (
+      (arg === '--loader' || arg === '--experimental-loader') &&
+      process.execArgv[index + 1] === 'newrelic/esm-loader.mjs'
+    ) {
+      if (isESMSupported) {
+        agent.metrics.getOrCreateMetric(NAMES.FEATURES.ESM.LOADER).incrementCallCount()
+      } else {
+        agent.metrics.getOrCreateMetric(NAMES.FEATURES.ESM.UNSUPPORTED_LOADER)
+        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
+        )
+      }
     }
   })
 
-  if (!isESM && !isDashR) {
+  if (!isDashR) {
     agent.metrics.getOrCreateMetric(NAMES.FEATURES.CJS.REQUIRE).incrementCallCount()
   }
 }

package/lib/config/default.js

@@ -738,14 +738,6 @@ defaultConfig.definition = () => ({
       formatter: boolean,
       default: true,
       env: 'NEW_RELIC_API_NOTICE_ERROR'
-    },
-    /**
-     * Sets the path to custom ESM instrumentation
-     */
-    esm: {
-      custom_instrumentation_entrypoint: {
-        default: null
-      }
     }
   },
   /**

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

@@ -5,8 +5,6 @@
 
 'use strict'
 
-const semver = require('semver')
-
 const logger = require('../logger')
 
 /**
@@ -18,16 +16,11 @@ 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.')
+  if (config.feature_flag.legacy_context_manager) {
+    return createLegacyContextManager(config)
   }
 
-  return createLegacyContextManager(config)
+  return createAsyncLocalContextManager(config)
 }
 
 function createAsyncLocalContextManager(config) {
@@ -38,13 +31,6 @@ function createAsyncLocalContextManager(config) {
 }
 
 function createLegacyContextManager(config) {
-  if (config.logging.diagnostics) {
-    logger.info('Using LegacyDiagnosticContextManager')
-
-    const LegacyDiagnosticContextManager = require('./diagnostics/legacy-diagnostic-context-manager')
-    return new LegacyDiagnosticContextManager(config)
-  }
-
   logger.info('Using LegacyContextManager')
 
   const LegacyContextManager = require('./legacy-context-manager')

package/lib/feature_flags.js

@@ -10,10 +10,9 @@ exports.prerelease = {
   express5: false,
   promise_segments: false,
   reverse_naming_rules: false,
-  undici_instrumentation: false,
   undici_async_tracking: true,
   unresolved_promise_cleanup: true,
-  async_local_context: false
+  legacy_context_manager: false
 }
 
 // flags that are no longer used for released features
@@ -32,7 +31,9 @@ exports.released = [
   'dt_format_w3c',
   'fastify_instrumentation',
   'await_support',
-  'certificate_bundle'
+  'certificate_bundle',
+  'async_local_context',
+  'undici_instrumentation'
 ]
 
 // flags that are no longer used for unreleased features

package/lib/instrumentation/@prisma/client.js

@@ -13,41 +13,6 @@ const parseSql = require('../../db/query-parsers/sql')
 const RAW_COMMANDS = ['executeRaw', 'queryRaw']
 
 const semver = require('semver')
-const { getSchema } = require('@mrleebo/prisma-ast')
-
-/**
- * The library we use to parse the prisma schema retains double quotes around
- * strings, and they need to be stripped
- *
- * @param {string} [str=''] string to strip double-quotes from
- * @returns {string} stripped string
- */
-function trimQuotes(str = '') {
-  return str.match(/"(.*)"/)[1]
-}
-
-/**
- * You can set the connection string in schema as raw string,
- * env var mapping, or an override at client instantiation time.
- *
- * @param {*} url string/object value of url in datsource stanza of schema
- * @param {string} overrideUrl value of url in overrides at client instantiation
- * @returns {string} properly parsed connection url
- */
-function parseDataModelUrl(url, overrideUrl) {
-  let parsedUrl = ''
-
-  if (overrideUrl) {
-    parsedUrl = overrideUrl
-  } else if (typeof url === 'string') {
-    parsedUrl = trimQuotes(url)
-  } else if (url.name && url.name === 'env') {
-    const envVar = trimQuotes(url.params[0])
-    parsedUrl = process.env[envVar]
-  }
-
-  return parsedUrl
-}
 
 /**
  * Parses a connection string. Most database engines in prisma are SQL and all
@@ -148,22 +113,34 @@ function queryParser(query) {
 }
 
 /**
- * Extracts the prisma connection information from the engine. This used to use
- * prisma functions available on engine `getConfig` but that's no longer accessible.
- * Instead we went the route of parsing the schema DSL.
+ * Extracts connection string from parse datasource config
+ *
+ * @param {object} datasource active datasource
+ * @returns {string} connection string
+ */
+function extractConnectionString(datasource = {}) {
+  return process.env[datasource?.url?.fromEnvVar] || datasource?.url?.value
+}
+
+/**
+ * Extracts the prisma connection information from the engine. This calls an internal
+ * package used to parse the prisma schema config.
  *
  * @param {object} client prisma client instance
- * @returns {Promise} returns prisma datasource connection configuration { provider, url }
+ * @returns {object} returns prisma datasource connection configuration { provider, url }
  */
 function extractPrismaDatasource(client) {
-  const { datamodel, datasourceOverrides: overrides } = client._engine
-  const schema = getSchema(datamodel)
-  const datasource = schema.list.filter(({ type }) => type === 'datasource')[0]
-  const urlData = datasource.assignments.filter(({ key }) => key === 'url')[0].value
-  const url = parseDataModelUrl(urlData, overrides[datasource.name])
+  const { get_config: getConfig } = require('@prisma/prisma-fmt-wasm')
+  const options = JSON.stringify({
+    prismaSchema: client?._engine?.datamodel,
+    ignoreEnvVarErrors: true
+  })
+  const config = JSON.parse(getConfig(options))
+  const activeDatasource = config?.datasources?.[0]
+
   return {
-    provider: trimQuotes(datasource.assignments.filter(({ key }) => key === 'provider')[0].value),
-    url
+    provider: activeDatasource.provider,
+    url: extractConnectionString(activeDatasource)
   }
 }
 

package/lib/instrumentation/{amqplib.js → amqplib/amqplib.js}

@@ -7,34 +7,6 @@
 
 const url = require('url')
 
-module.exports.selfRegister = function selfRegister(shimmer) {
-  shimmer.registerInstrumentation({
-    moduleName: 'amqplib',
-    type: 'message',
-    onRequire: instrumentChannelAPI
-  })
-  shimmer.registerInstrumentation({
-    moduleName: 'amqplib/channel_api',
-    type: 'message',
-    onRequire: instrumentChannelAPI
-  })
-  shimmer.registerInstrumentation({
-    moduleName: 'amqplib/channel_api.js',
-    type: 'message',
-    onRequire: instrumentChannelAPI
-  })
-  shimmer.registerInstrumentation({
-    moduleName: 'amqplib/callback_api',
-    type: 'message',
-    onRequire: instrumentCallbackAPI
-  })
-  shimmer.registerInstrumentation({
-    moduleName: 'amqplib/callback_api.js',
-    type: 'message',
-    onRequire: instrumentCallbackAPI
-  })
-}
-
 module.exports.instrumentPromiseAPI = instrumentChannelAPI
 module.exports.instrumentCallbackAPI = instrumentCallbackAPI
 

package/lib/instrumentation/amqplib/nr-hooks.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const amqplib = require('./amqplib')
+
+module.exports = [
+  {
+    moduleName: 'amqplib/callback_api',
+    type: 'message',
+    onRequire: amqplib.instrumentCallbackAPI
+  },
+  {
+    moduleName: 'amqplib/channel_api',
+    type: 'message',
+    onRequire: amqplib.instrumentPromiseAPI
+  }
+]

package/lib/instrumentation/core/async-hooks.js

@@ -11,7 +11,7 @@ const asyncHooks = require('async_hooks')
 module.exports = initialize
 
 function initialize(agent, shim) {
-  if (agent.config.feature_flag.async_local_context) {
+  if (!agent.config.feature_flag.legacy_context_manager) {
     logger.debug(
       'New AsyncLocalStorage context enabled. Not enabling manual async_hooks or promise instrumentation'
     )

package/lib/instrumentation/core/timers.js

@@ -11,9 +11,9 @@ const Timers = require('timers')
 module.exports = initialize
 
 function initialize(agent, timers, _moduleName, shim) {
-  const isAsyncLocalContext = agent.config.feature_flag.async_local_context
+  const isLegacyContext = agent.config.feature_flag.legacy_context_manager
 
-  if (!isAsyncLocalContext) {
+  if (isLegacyContext) {
     instrumentProcessMethods(shim, process)
     instrumentSetImmediate(shim, [timers, global])
   }

package/lib/instrumentation/grpc-js/grpc.js

@@ -11,27 +11,23 @@ const { DESTINATIONS } = require('../../config/attribute-filter')
 const DESTINATION = DESTINATIONS.TRANS_EVENT | DESTINATIONS.ERROR_EVENT
 const semver = require('semver')
 
-module.exports = function instrument(shim) {
-  const grpcVersion = shim.require('./package.json').version
-  const genericShim = shim.makeSpecializedShim(shim.GENERIC, 'grpc-client-interceptor')
-
-  if (semver.gte(grpcVersion, '1.8.0')) {
-    const resolvingCall = genericShim.require('./build/src/resolving-call')
-    genericShim.wrap(resolvingCall.ResolvingCall.prototype, 'start', wrapStart)
-  } else {
-    const callStream = genericShim.require('./build/src/call-stream')
-    genericShim.wrap(callStream.Http2CallStream.prototype, 'start', wrapStart)
-  }
+module.exports.wrapStartResolve = function wrappedClient(shim, resolvingCall) {
+  shim.wrap(resolvingCall.ResolvingCall.prototype, 'start', wrapStart)
+}
 
-  const webFrameworkShim = shim.makeSpecializedShim(shim.WEB_FRAMEWORK, 'server')
+module.exports.wrapStartCall = function wrappedClient(shim, callStream) {
+  shim.wrap(callStream.Http2CallStream.prototype, 'start', wrapStart)
+}
+
+module.exports.wrapServer = function wrapServer(shim, server) {
+  const grpcVersion = shim.require('./package.json').version
   if (semver.lt(grpcVersion, '1.4.0')) {
     shim.logger.debug('gRPC server-side instrumentation only supported on grpc-js >=1.4.0')
     return
   }
 
-  const server = webFrameworkShim.require('./build/src/server')
-  webFrameworkShim.setFramework('gRPC')
-  webFrameworkShim.wrap(server.Server.prototype, 'register', wrapRegister)
+  shim.setFramework('gRPC')
+  shim.wrap(server.Server.prototype, 'register', wrapRegister)
 }
 
 /**

package/lib/instrumentation/grpc-js/nr-hooks.js

@@ -7,13 +7,25 @@
 const grpc = require('./grpc')
 
 /**
- * Need to use nr-hooks style for grpc because we're using the onResolved hook
- * to register instrumentation.
+ * Need to use nr-hooks style for grpc because we're instrumentation a submodule.
  */
 module.exports = [
   {
-    type: 'conglomerate', // generic shim for client, web framework shim for server
-    moduleName: '@grpc/grpc-js',
-    onResolved: grpc
+    type: 'generic',
+    moduleName: '@grpc/grpc-js/build/src/resolving-call',
+    isEsm: true,
+    onRequire: grpc.wrapStartResolve
+  },
+  {
+    type: 'generic',
+    moduleName: '@grpc/grpc-js/build/src/call-stream',
+    isEsm: true,
+    onRequire: grpc.wrapStartCall
+  },
+  {
+    type: 'web-framework',
+    moduleName: '@grpc/grpc-js/build/src/server',
+    isEsm: true,
+    onRequire: grpc.wrapServer
   }
 ]

package/lib/instrumentation/pino/nr-hooks.js

@@ -7,13 +7,12 @@
 const pino = require('./pino')
 
 /**
- * Need to use nr-hooks style for pino because we're using the onResolved hook
- * to register instrumentation.
+ * Need to use nr-hooks style because we are instrumenting a submodule.
  */
 module.exports = [
   {
     type: 'generic',
-    moduleName: 'pino',
-    onResolved: pino
+    moduleName: 'pino/lib/tools',
+    onRequire: pino
   }
 ]