newrelic 13.4.0 → 13.5.0

package/lib/instrumentation/aws-sdk/v3/sqs.js

@@ -18,10 +18,10 @@ const InstrumentationDescriptor = require('../../../instrumentation-descriptor')
  * when command is `PublishCommand`
  *
  * @param {Shim} shim instance
- * @param {Object} config configuration options
- * @param {function} next middleware function
- * @param {Object} context context
- * @returns {function}
+ * @param {object} config configuration options
+ * @param {Function} next middleware function
+ * @param {object} context context
+ * @returns {Function}
  */
 function sqsMiddleware(shim, config, next, context) {
   if (SEND_COMMANDS.includes(context.commandName)) {
@@ -38,10 +38,10 @@ function sqsMiddleware(shim, config, next, context) {
  * Returns the spec for PublishCommand
  *
  * @param {Shim} shim instance
- * @param {function} original original middleware function
+ * @param {Function} original original middleware function
  * @param {string} name function name
  * @param {Array} args to the middleware function
- * @returns {Object}
+ * @returns {object}
  */
 function getSqsSpec(shim, original, name, args) {
   const [command] = args

package/lib/instrumentation/fastify/spec-builders.js

@@ -79,10 +79,10 @@ function buildMiddlewareSpecForRouteHandler(shim, path) {
      * that is actually handling the request, the path is actually left on)
      *
      * @param {WebFrameworkShim} shim instance
-     * @param {function} fn function
+     * @param {Function} fn function
      * @param {string} fnName function name
      * @param {Array} args arguments
-     * @param {function} bindSegment the bindSegment function
+     * @param {Function} bindSegment the bindSegment function
      */
     next: function wrapNext(shim, fn, fnName, args, bindSegment) {
       const reply = args[1]
@@ -98,26 +98,6 @@ function buildMiddlewareSpecForRouteHandler(shim, path) {
   })
 }
 
-/**
- * Spec for all Fastify middleware (excluding route handlers)
- *
- * @param {WebFrameworkShim} shim instance
- * @param {string} name metric name for middleware being executed
- * @param {number|string|null} route route
- * @returns {object} spec for Fastify middleware
- */
-function buildMiddlewareSpecForMiddlewareFunction(shim, name, route) {
-  return new MiddlewareSpec({
-    name,
-    route,
-    next: shim.LAST,
-    params: getParamsFromFastifyRequest,
-    req: getRequestFromFastify,
-    type: shim.MIDDLEWARE
-  })
-}
-
 module.exports = {
-  buildMiddlewareSpecForRouteHandler,
-  buildMiddlewareSpecForMiddlewareFunction
+  buildMiddlewareSpecForRouteHandler
 }

package/lib/instrumentation/fastify.js

@@ -7,30 +7,8 @@
 
 const semver = require('semver')
 const {
-  buildMiddlewareSpecForRouteHandler,
-  buildMiddlewareSpecForMiddlewareFunction
+  buildMiddlewareSpecForRouteHandler
 } = require('./fastify/spec-builders')
-const { MiddlewareMounterSpec } = require('../shim/specs')
-
-/**
- * These are the events that occur during a fastify
- * request
- * see: https://www.fastify.io/docs/latest/Lifecycle/
- *
- * Note: preSerialization and onSend happen after the route handler
- * executes.  `onResponse` does not execute until after the client
- * sends the response so it'll never be in scope of the transaction
- */
-const REQUEST_HOOKS = [
-  'onRequest',
-  'preParsing',
-  'preValidation',
-  'preHandler',
-  'preSerialization',
-  'onSend',
-  'onResponse',
-  'onError'
-]
 
 /**
  * Sets up fastify route handler
@@ -45,13 +23,14 @@ const REQUEST_HOOKS = [
  * maintain code
  *
  * @param {WebFrameworkShim} shim instance
- * @param {Object} fastify Fastify instance
+ * @param {object} fastify Fastify instance
  */
-const setupRouteHandler = (shim, fastify) => {
+function setupRouteHandler(shim, fastify) {
   fastify.addHook('onRoute', (routeOptions) => {
     if (!routeOptions.handler) {
       return
     }
+
     /**
      * recordMiddleware handler call
      *
@@ -66,88 +45,38 @@ const setupRouteHandler = (shim, fastify) => {
 
     routeOptions.handler = newRouteHandler
   })
-
-  shim.wrap(fastify, 'addHook', function addWrapHook(shim, fn) {
-    return function wrappedAddHook(...args) {
-      const hookName = args[0]
-      if (REQUEST_HOOKS.includes(hookName)) {
-        const middlewareFunction = args[1]
-        const name = `${hookName}/${shim.getName(middlewareFunction)}`
-        const middlewareSpec = buildMiddlewareSpecForMiddlewareFunction(shim, name)
-        const newMiddlewareFunction = shim.recordMiddleware(middlewareFunction, middlewareSpec)
-
-        args[1] = newMiddlewareFunction
-      }
-      return fn.apply(this, args)
-    }
-  })
 }
 
 module.exports = function initialize(agent, fastify, moduleName, shim) {
   shim.setFramework(shim.FASTIFY)
 
   const fastifyVersion = shim.pkgVersion
+  const noDiagChannel = semver.lt(fastifyVersion, '3.21.0')
   const isv3Plus = semver.satisfies(fastifyVersion, '>=3.0.0')
 
-  /**
-   * Fastify exports a function, so we need to use wrapExport
-   */
-  const wrappedExport = shim.wrapExport(fastify, function wrapFastifyModule(shim, fn) {
-    return function wrappedFastifyModule() {
-      // call original function to get the fastify object (which is singleton-ish)
-      const fastifyForWrapping = fn.apply(this, arguments)
-
-      setupRouteHandler(shim, fastifyForWrapping)
-
-      setupMiddlewareHandlers(shim, fastifyForWrapping, isv3Plus)
-
-      return fastifyForWrapping
-    }
-  })
-
-  if (isv3Plus) {
-    setupExports(fastify, wrappedExport)
+  if (!isv3Plus) {
+    shim.logger.warn('Fastify version: %s is unsupported, minimum supported version is `3.0.0`', fastifyVersion)
+    return
   }
-}
-
-function setupMiddlewareHandlers(shim, fastify, isv3Plus) {
-  const mounterSpec = new MiddlewareMounterSpec({
-    route: shim.FIRST,
-    wrapper: wrapMiddleware
-  })
 
-  if (isv3Plus) {
-    // Fastify v3+ does not ship with traditional Node.js middleware mounting.
-    // This style is accomplished leveraging decorators. Both middie (which was built-in in v2)
-    // and fastify-express mount a 'use' function for mounting middleware.
-    shim.wrap(fastify, 'decorate', function wrapDecorate(shim, fn) {
-      return function wrappedDecorate(...args) {
-        const name = args[0]
-        if (name !== 'use') {
-          return fn.apply(this, args)
-        }
+  // In 3.21.0+ fastify emits events via diagnostics channel.
+  // we are subscribing to one of those events in `lib/subscribers/fastify/index.js`.
+  // This code is for any customers using <3.21.0, which hopefully should be very few.
+  // TODO: Remove <3.21.0 support in 14.0.0 of Node.js agent
+  if (noDiagChannel) {
+    const wrappedExport = shim.wrapExport(fastify, function wrapFastifyModule(shim, fn) {
+      return function wrappedFastifyModule() {
+        // call original function to get the fastify object (which is singleton-ish)
+        const fastifyForWrapping = fn.apply(this, arguments)
 
-        args[1] = shim.wrapMiddlewareMounter(args[1], mounterSpec)
+        setupRouteHandler(shim, fastifyForWrapping)
 
-        return fn.apply(this, args)
+        return fastifyForWrapping
       }
     })
-  } else {
-    shim.wrapMiddlewareMounter(fastify, 'use', mounterSpec)
-  }
-}
 
-function wrapMiddleware(shim, middleware, name, route) {
-  if (shim.isWrapped(middleware)) {
-    return middleware
+    setupExports(fastify, wrappedExport)
   }
-
-  // prefixing the segment name for middleware execution
-  // with the Fastify lifecycle hook
-  const segmentName = `onRequest/${name}`
-  const spec = buildMiddlewareSpecForMiddlewareFunction(shim, segmentName, route)
-
-  return shim.recordMiddleware(middleware, spec)
 }
 
 /**
@@ -155,8 +84,8 @@ function wrapMiddleware(shim, middleware, name, route) {
  * module.exports.fastify = fastify
  * module.exports.default = fastify
  *
- * @param {Object} original original exports
- * @param {Object} wrappedExport wrapped exports
+ * @param {object} original original fastify export
+ * @param {object} wrappedExport wrapped fastify export
  */
 function setupExports(original, wrappedExport) {
   wrappedExport.fastify = original.fastify

package/lib/instrumentation/kafkajs/consumer.js

@@ -87,7 +87,7 @@ function wrapRun(shim, fn) {
  *
  * @param {object} params to function
  * @param {object} params.consumer consumer being instrumented
- * @returns {function} message handler for setting metrics and spec for the consumer transaction
+ * @returns {Function} message handler for setting metrics and spec for the consumer transaction
  */
 function handler({ consumer }) {
   /**

package/lib/instrumentation/koa/instrumentation.js

@@ -79,7 +79,7 @@ function wrapMiddleware(shim, middleware) {
  * See: https://github.com/koajs/koa/blob/master/lib/context.js#L186-L241
  *
  * @param {Shim} shim instance of shim
- * @param {function} _fn createContext function
+ * @param {Function} _fn createContext function
  * @param {string} _fnName name of function
  * @param {object} context koa ctx object
  */

package/lib/instrumentation/langchain/runnable.js

@@ -129,7 +129,7 @@ function instrumentStream({ langchain, shim }) {
  * @param {object} params function params
  * @param {Shim} params.shim shim instance
  * @param {TraceSegment} params.segment active segment
- * @param {function} params.output IterableReadableStream
+ * @param {Function} params.output IterableReadableStream
  * @param {string} params.request the prompt message
  * @param {object} params.metadata metadata for the call
  * @param {Array} params.tags tags for the call

package/lib/instrumentation/memcached.js

@@ -25,7 +25,7 @@ function wrapKeys(metacall) {
  * instrument the memcached driver to intercept calls and keep stats on them.
  *
  * @param {Agent} agent instance
- * @param {Object} memcached library
+ * @param {object} memcached library
  * @param {string} moduleName name of module
  * @param {Shim} shim instance
  */

package/lib/instrumentation/nextjs/next-server.js

@@ -124,12 +124,10 @@ module.exports = function initialize(shim, nextServer) {
 function assignParameters(shim, parameters) {
   const transaction = shim.tracer.getTransaction()
   if (transaction) {
-    const prefixedParameters = shim.prefixRouteParameters(parameters)
-
     // We have to add params because this framework doesn't
     // follow the traditional middleware/middleware mounter pattern
     // where we'd pull these from middleware.
-    transaction.nameState.appendPath('/', prefixedParameters)
+    transaction.nameState.appendPath('/', parameters)
   }
 }
 

package/lib/instrumentation/nextjs/utils.js

@@ -15,9 +15,9 @@ const utils = module.exports
  * with its file structure and function names. We're providing relative paths to Next.js files
  * based on the Next.js page.  The function is also hardcoded to align with the conventions of Next.js.
  *
- * @param {Object} config agent config
+ * @param {object} config agent config
  * @param {TraceSegment} segment active segment to add CLM attrs to
- * @param {Object} attrs list of CLM attrs to add to segment
+ * @param {object} attrs list of CLM attrs to add to segment
  */
 utils.assignCLMAttrs = function assignCLMAttrs(config, segment, attrs) {
   // config is optionally accessed because agent could be older than

package/lib/instrumentation/restify.js

@@ -76,10 +76,10 @@ module.exports = function initialize(_agent, restify, _moduleName, shim) {
  * route is not defined.
  *
  * @param {object} shim instance of shim
- * @param {function} middleware function to record
+ * @param {Function} middleware function to record
  * @param {string} _name name of middleware
  * @param {object|null} route name of route
- * @returns {function} wrapped middleware function
+ * @returns {Function} wrapped middleware function
  */
 function wrapMiddleware(shim, middleware, _name, route) {
   if (shim.isWrapped(middleware)) {

package/lib/instrumentation/when/contextualizer.js

@@ -160,7 +160,7 @@ Contextualizer.prototype.setSegment = function setSegment(segment) {
  * Propagates the segment to the finally function
  *
  * @param {Function} prom current promise
- * @returns {Function} current promise or wrapped finally that will propagate the segment
+ * @returns {Function|undefined} current promise or wrapped finally that will propagate the segment
  */
 Contextualizer.prototype.continue = function continueContext(prom) {
   const self = this

package/lib/instrumentation-descriptor.js

@@ -9,7 +9,7 @@ const IdGen = require('./util/idgen')
 const idGen = new IdGen()
 
 /**
- * @typedef {function} InstrumentationOnRequire
+ * @typedef {Function} InstrumentationOnRequire
  * @param {Shim} shim The shim instance to use for the instrumentation.
  * @param {object} resolvedNodule The module being instrumented as returned by
  * Node's `require` function.
@@ -19,7 +19,7 @@ const idGen = new IdGen()
  */
 
 /**
- * @typedef {function} InstrumentationOnError
+ * @typedef {Function} InstrumentationOnError
  * @param {Error|object} error The error thrown by `onRequire` when there was
  * an issue registering the instrumentation.
  */
@@ -86,14 +86,6 @@ class InstrumentationDescriptor {
    */
   static TYPE_WEB_FRAMEWORK = 'web-framework'
 
-  /**
-   * Used to load supportability metrics on installed versions of packages
-   * that the Node.js agent does not instrument (e.g. OTEL instrumentation or
-   * top logging libraries).
-   * @type {string}
-   */
-  static TYPE_TRACKING = 'tracking'
-
   /**
    * The type of the module being instrumented. See the static `TYPE_` fields.
    * @type {string|null}
@@ -207,7 +199,6 @@ module.exports.TYPES = {
   PROMISE: InstrumentationDescriptor.TYPE_PROMISE,
 
   WEB_FRAMEWORK: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK,
-  TRACKING: InstrumentationDescriptor.TYPE_TRACKING,
   /** @private */
   CONGLOMERATE: InstrumentationDescriptor.TYPE_CONGLOMERATE,
   /** @private */

package/lib/instrumentations.js

@@ -33,28 +33,11 @@ module.exports = function instrumentations() {
     mongodb: { type: InstrumentationDescriptor.TYPE_DATASTORE },
     mysql: { module: './instrumentation/mysql' },
     next: { module: './instrumentation/nextjs' },
-    pg: { type: InstrumentationDescriptor.TYPE_DATASTORE },
     q: { type: null },
     redis: { type: InstrumentationDescriptor.TYPE_DATASTORE },
     restify: { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
     superagent: { type: InstrumentationDescriptor.TYPE_GENERIC },
     when: { module: './instrumentation/when' },
-    winston: { type: InstrumentationDescriptor.TYPE_GENERIC },
-
-    /**
-     * The modules below are listed here purely to take
-     * advantage of the Supportability/Features/onRequire/<module>
-     * metrics for libraries we want to track for some reason or another.
-     * The big uses cases are:
-     *  Logging libraries we want to instrument in the future
-     *  Libraries that have OpenTelemetry instrumentation we want to register
-     *  or have already registered.
-     */
-    '@azure/openai': { type: InstrumentationDescriptor.TYPE_TRACKING },
-    '@langchain/community/llms/bedrock': { type: InstrumentationDescriptor.TYPE_TRACKING },
-    'fancy-log': { type: InstrumentationDescriptor.TYPE_TRACKING },
-    knex: { type: InstrumentationDescriptor.TYPE_TRACKING },
-    loglevel: { type: InstrumentationDescriptor.TYPE_TRACKING },
-    npmlog: { type: InstrumentationDescriptor.TYPE_TRACKING },
+    winston: { type: InstrumentationDescriptor.TYPE_GENERIC }
   }
 }

package/lib/llm-events/aws-bedrock/chat-completion-summary.js

@@ -10,7 +10,8 @@ const LlmEvent = require('./event')
 /**
  * @typedef {object} LlmChatCompletionSummaryParams
  * @augments LlmEventParams
- * @property
+ * @property {string} segment the segment associated with this LlmChatCompletionSummary
+ * @property {boolean} isError whether this event represents an error
  */
 /**
  * @type {LlmChatCompletionSummaryParams}

package/lib/metrics/recorders/database-operation.js

@@ -12,13 +12,12 @@ const metrics = require('../names')
  *
  * - `recordOperationMetrics(segment [, scope])`
  *
+ * This function is an implementation of {@link MetricFunction} (see #agentlib/shim/shim.js)
  * @private
- * @this DatastoreShim
- * @implements {MetricFunction}
  * @param {TraceSegment}  segment - The segment being recorded.
  * @param {string}        [scope] - The scope of the segment.
+ * @param {Transaction}   transaction - The transaction associated with the segment.
  * @see DatastoreShim#recordOperation
- * @see MetricFunction
  */
 function recordOperationMetrics(segment, scope, transaction) {
   const duration = segment.getDurationInMillis()

package/lib/metrics/recorders/middleware.js

@@ -9,11 +9,10 @@
  * Creates a recorder for middleware metrics.
  *
  * @private
- * @param {object} _shim instance of shim
  * @param {string} metricName name of metric
  * @returns {Function} recorder for middleware
  */
-function makeMiddlewareRecorder(_shim, metricName) {
+function makeMiddlewareRecorder(metricName) {
   return function middlewareMetricRecorder(segment, scope, transaction) {
     const duration = segment.getDurationInMillis()
     const exclusive = segment.getExclusiveDurationInMillis(transaction.trace)

package/lib/otel/context-manager.js

@@ -31,9 +31,9 @@ class ContextManager {
    * Runs the callback within the provided context, optionally
    * bound with a provided `this`.
    *
-   * @param {Object} context context
-   * @param {function} callback callback
-   * @param {Object} thisRef `this` reference
+   * @param {object} context context
+   * @param {Function} callback callback
+   * @param {object} thisRef `this` reference
    * @param {...any} args arguments
    */
   with(context, callback, thisRef, ...args) {

package/lib/otel/traces/segments/database.js

@@ -68,7 +68,7 @@ module.exports = function createDbSegment(agent, otelSpan, rule) {
  * @param {ParsedStatement} params.parsed parsed statement of call
  * @param {boolean} params.operation if span is an operation
  * @param {string} params.system `db.system` value of otel span
- * @returns {function} returns a timeslice metrics recorder function based on span
+ * @returns {Function} returns a timeslice metrics recorder function based on span
  */
 function getRecorder({ parsed, operation, system }) {
   if (operation) {

package/lib/otel/traces/utils.js

@@ -12,8 +12,8 @@ const { DESTINATIONS } = require('#agentlib/config/attribute-filter.js')
  * If a key is not found in the data object, it returns 'unknown'.
  * If a key is found in the rules object, it applies the corresponding function to the value.
  * @param {string} template - The template string containing placeholders in the format ${key}.
- * @param {Object} data - An object containing key-value pairs to replace in the template.
- * @param {Object} rules - An optional object containing functions to apply to specific keys.
+ * @param {object} data - An object containing key-value pairs to replace in the template.
+ * @param {object} rules - An optional object containing functions to apply to specific keys.
  * @returns {string} - The transformed string with placeholders replaced by corresponding values.
  */
 function transformTemplate(template, data, rules = {}) {
@@ -35,7 +35,7 @@ function transformTemplate(template, data, rules = {}) {
  * Each mapping should have a key, arguments, and body.
  * The body should be a string that can be evaluated as a function.
  * @param {Array} mappings - Array of mappings with key, arguments, and body.
- * @returns {Object} - An object where each key maps to a function.
+ * @returns {object} - An object where each key maps to a function.
  */
 function buildRuleMappings(mappings = []) {
   return mappings.reduce((acc, attr) => {
@@ -111,11 +111,11 @@ function processRegexGroups({ segment, transaction, groups = [], regexMatch }) {
  * If the attribute has a key, it will be used to get the value from the span's attributes.
  * If the attribute has a value, it will be used directly.
  * If the attribute has a template, it will be transformed using the span's attributes and any provided mappings.
- * @param {Object} params - The parameters for extracting the attribute value.
+ * @param {object} params - The parameters for extracting the attribute value.
  * @param {string} params.accountId - The value of agent.config.cloud.account_id
- * @param {Object} params.attribute - The attribute object containing key, value, or template.
+ * @param {object} params.attribute - The attribute object containing key, value, or template.
  * @param {Set} params.excludeAttributes - A set to keep track of excluded attributes.
- * @param {Object} params.span - The span object containing attributes.
+ * @param {object} params.span - The span object containing attributes.
  * @returns {string} - The extracted value of the attribute.
  */
 function extractAttributeValue({ accountId, attribute, excludeAttributes, span }) {
@@ -137,10 +137,10 @@ function extractAttributeValue({ accountId, attribute, excludeAttributes, span }
 
 /**
  * Assigns a value to a target based on the specified target type.
- * @param {Object} params - The parameters for assigning the value.
- * @param {Object} params.segment - The segment to add the attribute to.
+ * @param {object} params - The parameters for assigning the value.
+ * @param {object} params.segment - The segment to add the attribute to.
  * @param {string} params.target - The target type ('transaction', 'trace', or 'segment').
- * @param {Object} params.transaction - The transaction object.
+ * @param {object} params.transaction - The transaction object.
  * @param {string} params.name - The name of the attribute.
  * @param {string} params.value - The value of the attribute.
  */

package/lib/{adaptive-sampler.js → samplers/adaptive-sampler.js}

@@ -6,6 +6,14 @@
 'use strict'
 
 class AdaptiveSampler {
+  /**
+   *
+   * @param {object} opts Sampler options.
+   * @param {Agent} opts.agent - The New Relic agent instance.
+   * @param {number} opts.period - The time period over which to collect samples (ms).
+   * @param {number} opts.target - The target number of samples (transactions) to collect.
+   * @param {boolean} opts.serverless - Indicates if the environment is serverless.
+   */
   constructor(opts) {
     this._serverless = opts.serverless
     this._seen = 0

package/lib/serverless/aws-lambda.js

@@ -105,8 +105,8 @@ class AwsLambda {
   /**
    * Response-streaming handlers are identified by symbol properties on the function.
    * We propagate any symbols if they're present, so that the handler keeps its signatue for any AWS features that rely on symbols
-   * @param {Object} handler original handler
-   * @param {Object} nrHandler our copy of the handler
+   * @param {object} handler original handler
+   * @param {object} nrHandler our copy of the handler
    */
   propagateSymbols(handler, nrHandler) {
     for (const symbol of Object.getOwnPropertySymbols(handler)) {

package/lib/shim/datastore-shim.js

@@ -584,7 +584,7 @@ function _recordQuery(suffix, nodule, properties, querySpec) {
  * @param {object} params to function
  * @param {QuerySpec|OperationSpec} params.spec spec for the given shim method
  * @param {DatastoreShim} params.shim instance of shim
- * @param {function} params.fn function being instrumented
+ * @param {Function} params.fn function being instrumented
  * @param {string} params.fnName name of function being instrumented
  * @param {Array} params.args arguments to function being instrumented
  * @returns {QuerySpec|OperationSpec} compiled spec

package/lib/shim/message-shim/consume.js

@@ -19,9 +19,9 @@ module.exports = createRecorder
  * @param {Function} params.fn consumer function
  * @param {string} params.fnName name of function
  * @param {Array} params.args arguments passed to original consume function
- * @param {Object} params.ctx this binding of the original function
- * @param {specs.MessageSpec} params.spec spec for the wrapped consume function
- * @returns {specs.MessageSpec} new spec
+ * @param {object} params.ctx this binding of the original function
+ * @param {MessageSpec} params.spec spec for the wrapped consume function
+ * @returns {MessageSpec} new spec
  */
 function updateSpecFromArgs({ shim, fn, fnName, args, spec, ctx }) {
   let msgDesc = null

package/lib/shim/promise-shim.js

@@ -366,7 +366,7 @@ function _wrapExecutorContext(shim, args) {
 
   /**
    *
-   * @param {Object} args contains the `resolve` and `reject` functions of a promise
+   * @param {object} args contains the `resolve` and `reject` functions of a promise
    */
   function contextExporter(...args) {
     const [resolve, reject] = args
@@ -382,7 +382,6 @@ function _wrapExecutorContext(shim, args) {
  * @param {object} context context object
  * @param {Function} fn function that is wrapped
  * @returns {Function} wrapped function
- * @private
  */
 function _wrapResolver(context, fn) {
   return function wrappedResolveReject(val) {