newrelic 11.9.0 → 11.10.1

package/NEWS.md

@@ -1,3 +1,33 @@
+### v11.10.1 (2024-01-25)
+
+#### Bug fixes
+
+* Updated instrumentation registration to allow for instrumenting of a local file that does not exist within node_modules. 
+  * To properly instrument a local file, you must pass in `absolutePath` with the absolute path to the file that is being instrumented along with the `moduleName` which in this case is just the file name without the extension. ([#1974](https://github.com/newrelic/node-newrelic/pull/1974)) ([f545b4e](https://github.com/newrelic/node-newrelic/commit/f545b4ebc3394f0a7179a51e156c6df28896edf0))
+
+### v11.10.0 (2024-01-22)
+
+#### Features
+
+* Added llm attribute to all transactions that contain llm spans for openai ([#1946](https://github.com/newrelic/node-newrelic/pull/1946)) ([6312629](https://github.com/newrelic/node-newrelic/commit/6312629326c02fe3de4db91ee293eb71b7ddd042))
+* Added transaction ID to ErrorTrace event ([#1954](https://github.com/newrelic/node-newrelic/pull/1954)) ([5d0ebcd](https://github.com/newrelic/node-newrelic/commit/5d0ebcd216cb60b3a488b2b5f7c20f71f8d5bbeb))
+
+#### Security improvements
+
+* **remote_method:** Redacted ingest key in trace level logs ([#1948](https://github.com/newrelic/node-newrelic/pull/1948)) ([04fee88](https://github.com/newrelic/node-newrelic/commit/04fee886bd2f479e568830ea03217d7c9aba87d9))
+
+#### Code refactoring
+
+* Updated `lib/shim/shim.js` to remove cognitive complexity violations ([#1950](https://github.com/newrelic/node-newrelic/pull/1950)) ([60e57a1](https://github.com/newrelic/node-newrelic/commit/60e57a10f038c1e70dfef2937592983b2bfd5613))
+* Updated message-shim to remove cognitive complexity violations. ([#1958](https://github.com/newrelic/node-newrelic/pull/1958)) ([3d1caaf](https://github.com/newrelic/node-newrelic/commit/3d1caaf7d7f7de1c2e139eb7943f557b896fc1e2))
+
+#### Miscellaneous chores
+
+* **deps:** Updated @newrelic/aws-sdk to latest and removed aws_bedrock_instrumentation feature flag ([#1956](https://github.com/newrelic/node-newrelic/pull/1956)) ([9eae28c](https://github.com/newrelic/node-newrelic/commit/9eae28c7ca06f9287fe09a2d51ad61534d9e8b1d))
+* **deps:** Updated @newrelic/security-agent to v0.7.0 ([#1955](https://github.com/newrelic/node-newrelic/pull/1955)) ([e156539](https://github.com/newrelic/node-newrelic/commit/e15653916f4614e17501202f6831459a8104e7a7))
+* Migrated non-sensitive CI values to vars ([#1957](https://github.com/newrelic/node-newrelic/pull/1957)) ([1739378](https://github.com/newrelic/node-newrelic/commit/17393782a278fd3c3289332c78a88a5d6819be7c))
+* updated contributors list to include james and svetlana 🎉 ([#1947](https://github.com/newrelic/node-newrelic/pull/1947)) ([33a59fd](https://github.com/newrelic/node-newrelic/commit/33a59fdcdeb3e4074b4611d88e2fe79a65168fe3))
+
 ### v11.9.0 (2024-01-10)
 
 #### Features

package/THIRD_PARTY_NOTICES.md

@@ -509,7 +509,7 @@ This product includes source derived from [@grpc/proto-loader](https://github.co
 
 ### @newrelic/aws-sdk
 
-This product includes source derived from [@newrelic/aws-sdk](https://github.com/newrelic/node-newrelic-aws-sdk) ([v7.0.3](https://github.com/newrelic/node-newrelic-aws-sdk/tree/v7.0.3)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-aws-sdk/blob/v7.0.3/LICENSE):
+This product includes source derived from [@newrelic/aws-sdk](https://github.com/newrelic/node-newrelic-aws-sdk) ([v7.1.0](https://github.com/newrelic/node-newrelic-aws-sdk/tree/v7.1.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-aws-sdk/blob/v7.1.0/LICENSE):
 
 ```
                                  Apache License
@@ -926,7 +926,7 @@ Apache License
 
 ### @newrelic/security-agent
 
-This product includes source derived from [@newrelic/security-agent](https://github.com/newrelic/csec-node-agent) ([v0.6.0](https://github.com/newrelic/csec-node-agent/tree/v0.6.0)), distributed under the [New Relic Pre-Release License](https://github.com/newrelic/csec-node-agent/blob/v0.6.0/LICENSE):
+This product includes source derived from [@newrelic/security-agent](https://github.com/newrelic/csec-node-agent) ([v0.7.0](https://github.com/newrelic/csec-node-agent/tree/v0.7.0)), distributed under the [UNKNOWN License](https://github.com/newrelic/csec-node-agent/blob/v0.7.0/LICENSE):
 
 ```
 ## New Relic Pre-Release Software Notice

package/api.js

@@ -1312,7 +1312,7 @@ API.prototype.recordCustomEvent = function recordCustomEvent(eventType, attribut
  *
  * @param {string|object} moduleName The module name given to require to load the module, or the instrumentation specification
  * @param {string} moduleName.moduleName The module name given to require to load the module
- * @param {Function}  moduleName.onResolved The function to call prior to module load after the filepath has been resolved
+ * @param {string} [moduleName.absolutePath] Must provide absolute path to module if it does not exist within node_modules. This is used to instrument a file within the same application.
  * @param {Function}  moduleName.onRequire The function to call when the module has been loaded
  * @param {Function} [moduleName.onError] If provided, should `onRequire` throw an error, the error will be passed to
  * @param {Function} onRequire The function to call when the module has been loaded
@@ -1343,7 +1343,7 @@ API.prototype.instrument = function instrument(moduleName, onRequire, onError) {
  *
  * @param {string|object} moduleName The module name given to require to load the module, or the instrumentation specification
  * @param {string} moduleName.moduleName The module name given to require to load the module
- * @param {Function}  moduleName.onResolved The function to call prior to module load after the filepath has been resolved
+ * @param {string} [moduleName.absolutePath] Must provide absolute path to module if it does not exist within node_modules. This is used to instrument a file within the same application.
  * @param {Function}  moduleName.onRequire The function to call when the module has been loaded
  * @param {Function} [moduleName.onError] If provided, should `onRequire` throw an error, the error will be passed to
  * @param {Function} onRequire The function to call when the module has been loaded
@@ -1375,7 +1375,7 @@ API.prototype.instrumentConglomerate = function instrumentConglomerate(
  *
  * @param {string|object} moduleName The module name given to require to load the module, or the instrumentation specification
  * @param {string} moduleName.moduleName The module name given to require to load the module
- * @param {Function}  moduleName.onResolved The function to call prior to module load after the filepath has been resolved
+ * @param {string} [moduleName.absolutePath] Must provide absolute path to module if it does not exist within node_modules. This is used to instrument a file within the same application.
  * @param {Function}  moduleName.onRequire The function to call when the module has been loaded
  * @param {Function} [moduleName.onError] If provided, should `onRequire` throw an error, the error will be passed to
  * @param {Function} onRequire The function to call when the module has been loaded
@@ -1408,7 +1408,7 @@ API.prototype.instrumentDatastore = function instrumentDatastore(moduleName, onR
  *
  * @param {string|object} moduleName The module name given to require to load the module, or the instrumentation specification
  * @param {string} moduleName.moduleName The module name given to require to load the module
- * @param {Function}  moduleName.onResolved The function to call prior to module load after the filepath has been resolved
+ * @param {string} [moduleName.absolutePath] Must provide absolute path to module if it does not exist within node_modules. This is used to instrument a file within the same application.
  * @param {Function}  moduleName.onRequire The function to call when the module has been loaded
  * @param {Function} [moduleName.onError] If provided, should `onRequire` throw an error, the error will be passed to
  * @param {Function} onRequire The function to call when the module has been loaded
@@ -1445,7 +1445,7 @@ API.prototype.instrumentWebframework = function instrumentWebframework(
  *
  * @param {string|object} moduleName The module name given to require to load the module, or the instrumentation specification
  * @param {string} moduleName.moduleName The module name given to require to load the module
- * @param {Function}  moduleName.onResolved The function to call prior to module load after the filepath has been resolved
+ * @param {string} [moduleName.absolutePath] Must provide absolute path to module if it does not exist within node_modules. This is used to instrument a file within the same application.
  * @param {Function}  moduleName.onRequire The function to call when the module has been loaded
  * @param {Function} [moduleName.onError] If provided, should `onRequire` throw an error, the error will be passed to
  * @param {Function} onRequire The function to call when the module has been loaded

package/lib/collector/remote-method.js

@@ -259,15 +259,19 @@ RemoteMethod.prototype._safeRequest = function _safeRequest(options) {
     level = 'info'
   }
 
-  const logBody = Buffer.isBuffer(options.body) ? 'Buffer ' + options.body.length : options.body
-  logger[level](
-    { body: logBody },
-    'Posting to %s://%s:%s%s',
-    protocol,
-    options.host,
-    options.port,
-    options.path
-  )
+  // check if trace is enabled or audit log(aka info in this case) before attemping
+  // to get the body length or parse the path with redacted key
+  if (logger.traceEnabled() || level === 'info') {
+    const logBody = Buffer.isBuffer(options.body) ? 'Buffer ' + options.body.length : options.body
+    logger[level](
+      { body: logBody },
+      'Posting to %s://%s:%s%s',
+      protocol,
+      options.host,
+      options.port,
+      this._path({ redactLicenseKey: true })
+    )
+  }
 
   this._request(options)
 }
@@ -336,13 +340,14 @@ RemoteMethod.prototype._userAgent = function _userAgent() {
 /**
  * Generate a URL the collector understands.
  *
+ * @param {boolean} redactLicenseKey flag to redact license key in path
  * @returns {string} The URL path to be POSTed to.
  */
-RemoteMethod.prototype._path = function _path() {
+RemoteMethod.prototype._path = function _path({ redactLicenseKey } = {}) {
   const query = {
     marshal_format: 'json',
     protocol_version: this._protocolVersion,
-    license_key: this._config.license_key,
+    license_key: redactLicenseKey ? 'REDACTED' : this._config.license_key,
     method: this.name
   }
 

package/lib/errors/index.js

@@ -67,7 +67,8 @@ class Exception {
  *                                                 [1] -> name extracted from error info,
  *                                                 [2] -> extracted error message,
  *                                                 [3] -> extracted error type,
- *                                                 [4] -> attributes
+ *                                                 [4] -> attributes,
+ *                                                 [5] -> transaction id
  */
 function createError(transaction, exception, config) {
   const error = exception.error
@@ -111,7 +112,7 @@ function createError(transaction, exception, config) {
 
   maybeAddAgentAttributes(params, exception)
 
-  return [0, name, message, type, params]
+  return [0, name, message, type, params, transaction?.id]
 }
 
 function isValidErrorGroupOutput(output) {

package/lib/feature_flags.js

@@ -12,8 +12,7 @@ exports.prerelease = {
   reverse_naming_rules: false,
   undici_async_tracking: true,
   unresolved_promise_cleanup: true,
-  legacy_context_manager: false,
-  aws_bedrock_instrumentation: false
+  legacy_context_manager: false
 }
 
 // flags that are no longer used for released features
@@ -34,7 +33,8 @@ exports.released = [
   'await_support',
   'certificate_bundle',
   'async_local_context',
-  'undici_instrumentation'
+  'undici_instrumentation',
+  'aws_bedrock_instrumentation'
 ]
 
 // flags that are no longer used for unreleased features

package/lib/instrumentation/openai.js

@@ -19,6 +19,7 @@ const {
   AI: { OPENAI }
 } = require('../../lib/metrics/names')
 const semver = require('semver')
+const { DESTINATIONS } = require('../config/attribute-filter')
 
 let TRACKING_METRIC = OPENAI.TRACKING_PREFIX
 
@@ -282,6 +283,8 @@ module.exports = function initialize(agent, openai, moduleName, shim) {
               err
             })
           }
+
+          segment.transaction.trace.attributes.addAttribute(DESTINATIONS.TRANS_EVENT, 'llm', true)
         }
       }
     }
@@ -301,6 +304,8 @@ module.exports = function initialize(agent, openai, moduleName, shim) {
         promise: true,
         // eslint-disable-next-line max-params
         after(_shim, _fn, _name, err, response, segment) {
+          segment.transaction.trace.attributes.addAttribute(DESTINATIONS.TRANS_EVENT, 'llm', true)
+
           if (!response) {
             // If we get an error, it is possible that `response = null`.
             // In that case, we define it to be an empty object.

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2024 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const common = module.exports
+
+/**
+ * Constructs a message segment name from the given message descriptor.
+ *
+ * @private
+ * @param {MessageShim} shim The shim the segment will be constructed by.
+ * @param {object} msgDesc The message descriptor.
+ * @param {string} action Produce or consume?
+ * @returns {string} The generated name of the message segment.
+ */
+common._nameMessageSegment = function _nameMessageSegment(shim, msgDesc, action) {
+  let name =
+    shim._metrics.PREFIX +
+    shim._metrics.LIBRARY +
+    '/' +
+    (msgDesc.destinationType || shim.EXCHANGE) +
+    '/' +
+    action
+
+  if (msgDesc.destinationName) {
+    name += shim._metrics.NAMED + msgDesc.destinationName
+  } else {
+    name += shim._metrics.TEMP
+  }
+
+  return name
+}

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

@@ -0,0 +1,167 @@
+/*
+ * Copyright 2024 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const TraceSegment = require('../../transaction/trace/segment')
+const genericRecorder = require('../../metrics/recorders/generic')
+const { _nameMessageSegment } = require('./common')
+const specs = require('../specs')
+module.exports = createRecorder
+
+/**
+ * Generates the spec for the consumer
+ *
+ * @private
+ * @param {object} params to function
+ * @param {MessageShim} params.shim instance of shim
+ * @param {Function} params.fn consumer function
+ * @param {string} params.fnName name of function
+ * @param {Array} params.args arguments passed to original consume function
+ * @param {specs.MessageSpec} params.spec spec for the wrapped consume function
+ * @returns {specs.MessageSpec} new spec
+ */
+function updateSpecFromArgs({ shim, fn, fnName, args, spec }) {
+  let msgDesc = null
+  if (shim.isFunction(spec)) {
+    msgDesc = spec.call(this, shim, fn, fnName, args)
+    msgDesc = new specs.MessageSpec(msgDesc)
+  } else {
+    msgDesc = new specs.MessageSpec(spec)
+    const destIdx = shim.normalizeIndex(args.length, spec.destinationName)
+    if (destIdx !== null) {
+      msgDesc.destinationName = args[destIdx]
+    }
+  }
+
+  return msgDesc
+}
+
+/**
+ * Binds the consumer callback to the active segment.
+ *
+ * @private
+ * @param {object} params to function
+ * @param {MessageShim} params.shim instance of shim
+ * @param {Array} params.args arguments passed to original consume function
+ * @param {specs.MessageSpec} params.msgDesc spec for the wrapped consume function
+ * @param {TraceSegment} params.segment active segment to bind callback
+ * @param {boolean} params.getParams flag to copy message parameters to segment
+ * @param {Function} params.resHandler function to handle response from callback to obtain the message parameters
+ */
+function bindCallback({ shim, args, msgDesc, segment, getParams, resHandler }) {
+  const cbIdx = shim.normalizeIndex(args.length, msgDesc.callback)
+  if (cbIdx !== null) {
+    shim.bindCallbackSegment(args, cbIdx, segment)
+
+    // If we have a callback and a results handler, then wrap the callback so
+    // we can call the results handler and get the message properties.
+    if (resHandler) {
+      shim.wrap(args, cbIdx, function wrapCb(shim, cb, cbName) {
+        if (shim.isFunction(cb)) {
+          return function cbWrapper() {
+            const cbArgs = shim.argsToArray.apply(shim, arguments)
+            const msgProps = resHandler.call(this, shim, cb, cbName, cbArgs)
+            if (getParams && msgProps && msgProps.parameters) {
+              shim.copySegmentParameters(segment, msgProps.parameters)
+            }
+
+            return cb.apply(this, arguments)
+          }
+        }
+      })
+    }
+  }
+}
+
+/**
+ * Binds the consumer function to the async context and checks return to possibly
+ * bind the promise
+ *
+ * @private
+ * @param {object} params to function
+ * @param {MessageShim} params.shim instance of shim
+ * @param {Function} params.fn consumer function
+ * @param {string} params.fnName name of function
+ * @param {Array} params.args arguments passed to original consume function
+ * @param {specs.MessageSpec} params.msgDesc spec for the wrapped consume function
+ * @param {TraceSegment} params.segment active segment to bind callback
+ * @param {boolean} params.getParams flag to copy message parameters to segment
+ * @param {Function} params.resHandler function to handle response from callback to obtain the message parameters
+ * @returns {Promise|*} response from consume function
+ */
+function bindConsumer({ shim, fn, fnName, args, msgDesc, segment, getParams, resHandler }) {
+  // Call the method in the context of our segment.
+  let ret = shim.applySegment(fn, segment, true, this, args)
+
+  if (ret && msgDesc.promise && shim.isPromise(ret)) {
+    ret = shim.bindPromise(ret, segment)
+
+    // Intercept the promise to handle the result.
+    if (resHandler) {
+      ret = ret.then(function interceptValue(res) {
+        const msgProps = resHandler.call(this, shim, fn, fnName, res)
+        if (getParams && msgProps && msgProps.parameters) {
+          shim.copySegmentParameters(segment, msgProps.parameters)
+        }
+        return res
+      })
+    }
+  }
+
+  return ret
+}
+
+/**
+ *
+ * @private
+ * @param {object} params to function
+ * @param {MessageShim} params.shim instance of shim
+ * @param {Function} params.fn function that is being wrapped
+ * @param {string} params.fnName name of function
+ * @param {specs.MessageSpec} params.spec spec for the wrapped consume function
+ * @returns {Function} recorder for consume function
+ */
+function createRecorder({ shim, fn, fnName, spec }) {
+  return function consumeRecorder() {
+    const parent = shim.getSegment()
+    if (!parent || !parent.transaction.isActive()) {
+      shim.logger.trace('Not recording consume, no active transaction.')
+      return fn.apply(this, arguments)
+    }
+
+    // Process the message args.
+    const args = shim.argsToArray.apply(shim, arguments)
+    const msgDesc = updateSpecFromArgs.call(this, { shim, fn, fnName, args, spec })
+
+    // Make the segment if we can.
+    if (!msgDesc) {
+      shim.logger.trace('Not recording consume, no message descriptor.')
+      return fn.apply(this, args)
+    }
+
+    const name = _nameMessageSegment(shim, msgDesc, shim._metrics.CONSUME)
+
+    // Adds details needed by createSegment when used with a spec
+    msgDesc.name = name
+    msgDesc.recorder = genericRecorder
+    msgDesc.parent = parent
+
+    const segment = shim.createSegment(msgDesc)
+    const getParams = shim.agent.config.message_tracer.segment_parameters.enabled
+    const resHandler = shim.isFunction(msgDesc.messageHandler) ? msgDesc.messageHandler : null
+
+    bindCallback({ shim, args, msgDesc, segment, getParams, resHandler })
+    return bindConsumer.call(this, {
+      shim,
+      fn,
+      fnName,
+      args,
+      msgDesc,
+      segment,
+      getParams,
+      resHandler
+    })
+  }
+}