newrelic 11.14.0 → 11.15.0

package/NEWS.md

@@ -1,3 +1,35 @@
+### v11.15.0 (2024-04-09)
+
+#### Bug fixes
+
+* Fixed instrumenting the same module installed in different locations ([#2104](https://github.com/newrelic/node-newrelic/pull/2104)) ([88bdace](https://github.com/newrelic/node-newrelic/commit/88bdace6489c7d258ed3200f1550367f35824bc1))
+
+#### Code refactoring
+
+* **mongodb:** Removed instrumentation that handles connecting via unix domain socket. ([#2129](https://github.com/newrelic/node-newrelic/pull/2129)) ([808323f](https://github.com/newrelic/node-newrelic/commit/808323f0832952870fd1e94474b3fd3e0ab1b8c4))
+* Updated shim classes to no longer construct specs. ([#2096](https://github.com/newrelic/node-newrelic/pull/2096)) ([158c295](https://github.com/newrelic/node-newrelic/commit/158c29566f6a5993ec77f84aeaa266ceab0bf4f0))
+
+#### Miscellaneous chores
+
+* **deps-dev:** Bumped express from 4.18.2 to 4.19.2 ([#2101](https://github.com/newrelic/node-newrelic/pull/2101)) ([639cb78](https://github.com/newrelic/node-newrelic/commit/639cb785dff7568ad227091512013c2dfb81e5f9))
+* **deps:** Updated @newrelic/security-agent to v1.1.1 ([#2092](https://github.com/newrelic/node-newrelic/pull/2092)) ([3272aa3](https://github.com/newrelic/node-newrelic/commit/3272aa3da2260ce18c71c24608ffdda512ca6817))
+* Fixed incorrect pinning of @elastic/transport ([#2120](https://github.com/newrelic/node-newrelic/pull/2120)) ([7b5bdaa](https://github.com/newrelic/node-newrelic/commit/7b5bdaac1b1081636636cd7ca7c6b484f5251f76))
+* Removed scrollbar styling in generated API docs ([#2091](https://github.com/newrelic/node-newrelic/pull/2091)) ([cb0fa11](https://github.com/newrelic/node-newrelic/commit/cb0fa11c81290bb93cb30e974fdb1ece82a1e80e))
+* Removed transaction_id and legacy token count attributes from llm events for openai and langchain ([#2093](https://github.com/newrelic/node-newrelic/pull/2093)) ([df2a0fd](https://github.com/newrelic/node-newrelic/commit/df2a0fd7c99a7bbf024c1e33c7fdff512b45c970))
+
+#### Tests
+
+* Updated test/integration/core/dns reverse test to remove flakiness ([#2121](https://github.com/newrelic/node-newrelic/pull/2121)) ([c32cb27](https://github.com/newrelic/node-newrelic/commit/c32cb2739ece3adcf5bd42e646071b3f59e691ba))
+* Updated elastic tests to skip broken version ([#2119](https://github.com/newrelic/node-newrelic/pull/2119)) ([5d0d1bb](https://github.com/newrelic/node-newrelic/commit/5d0d1bb4994b41d43ab9b4eb110fea036ac307bc))
+
+#### Continuous integration
+
+* Removed usage of `use_new_release` from prepare release workflow ([#2124](https://github.com/newrelic/node-newrelic/pull/2124)) ([007ddb4](https://github.com/newrelic/node-newrelic/commit/007ddb4dce6cf5ab463a1868fe4cfa203d3e9ff2))
+* Updated `prepare-release.js` to not require changelog.json ([#2106](https://github.com/newrelic/node-newrelic/pull/2106)) ([328a570](https://github.com/newrelic/node-newrelic/commit/328a570bbe9f359d23a21317ccd8a8bc52b473b4))
+* Updated prepare release to provide a drop down for release type ([#2133](https://github.com/newrelic/node-newrelic/pull/2133)) ([846269b](https://github.com/newrelic/node-newrelic/commit/846269bb256f287c5fb9be32bdb62e9786e3cfe4))
+* Updated versioned security agent workflow ([#2100](https://github.com/newrelic/node-newrelic/pull/2100)) ([f787b15](https://github.com/newrelic/node-newrelic/commit/f787b15f94c416d547af1ab4b2d7c31665b417b7))
+* Fixed typo in constant name for prepare release script ([#2094](https://github.com/newrelic/node-newrelic/pull/2094)) ([3b887d9](https://github.com/newrelic/node-newrelic/commit/3b887d96c70a2cc5e3833cdc8b65de99b643f7a1))
+
 ### v11.14.0 (2024-03-20)
 
 #### Features

package/THIRD_PARTY_NOTICES.md

@@ -712,7 +712,7 @@ This product includes source derived from [@newrelic/aws-sdk](https://github.com
 
 ### @newrelic/koa
 
-This product includes source derived from [@newrelic/koa](https://github.com/newrelic/node-newrelic-koa) ([v9.0.0](https://github.com/newrelic/node-newrelic-koa/tree/v9.0.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-koa/blob/v9.0.0/LICENSE):
+This product includes source derived from [@newrelic/koa](https://github.com/newrelic/node-newrelic-koa) ([v9.1.0](https://github.com/newrelic/node-newrelic-koa/tree/v9.1.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-koa/blob/v9.1.0/LICENSE):
 
 ```
 Apache License
@@ -951,7 +951,7 @@ SOFTWARE.
 
 ### @newrelic/security-agent
 
-This product includes source derived from [@newrelic/security-agent](https://github.com/newrelic/csec-node-agent) ([v1.0.1](https://github.com/newrelic/csec-node-agent/tree/v1.0.1)), distributed under the [UNKNOWN License](https://github.com/newrelic/csec-node-agent/blob/v1.0.1/LICENSE):
+This product includes source derived from [@newrelic/security-agent](https://github.com/newrelic/csec-node-agent) ([v1.1.1](https://github.com/newrelic/csec-node-agent/tree/v1.1.1)), distributed under the [UNKNOWN License](https://github.com/newrelic/csec-node-agent/blob/v1.1.1/LICENSE):
 
 ```
 ## New Relic Software License v1.0

package/api.js

@@ -26,7 +26,7 @@ const {
 const LlmFeedbackMessage = require('./lib/llm-events/feedback-message')
 
 const ATTR_DEST = require('./lib/config/attribute-filter').DESTINATIONS
-const MODULE_TYPE = require('./lib/shim/constants').MODULE_TYPE
+const MODULE_TYPE = require('./lib/instrumentation-descriptor').TYPES
 const NAMES = require('./lib/metrics/names')
 const obfuscate = require('./lib/util/sql/obfuscate')
 const { DESTINATIONS } = require('./lib/config/attribute-filter')

package/lib/instrumentation/cassandra-driver.js

@@ -28,7 +28,9 @@ module.exports = function initialize(_agent, cassandra, _moduleName, shim) {
   shim.recordOperation(
     ClientProto,
     ['connect', 'shutdown'],
-    new OperationSpec({ callback: shim.LAST })
+    function operationSpec(shim, _fn, name) {
+      return new OperationSpec({ callback: shim.LAST, name })
+    }
   )
 
   if (semver.satisfies(cassandraVersion, '>=4.4.0')) {

package/lib/instrumentation/mongodb/common.js

@@ -11,7 +11,6 @@ const {
 } = require('../../shim/specs')
 const { CURSOR_OPS, COLLECTION_OPS, DB_OPS } = require('./constants')
 const common = module.exports
-common.NR_ATTRS = Symbol('NR_ATTRS')
 
 /**
  * Instruments all methods from constants.CURSOR_OPS on a given
@@ -23,12 +22,9 @@ common.NR_ATTRS = Symbol('NR_ATTRS')
 common.instrumentCursor = function instrumentCursor(shim, Cursor) {
   if (Cursor && Cursor.prototype) {
     const proto = Cursor.prototype
-    for (let i = 0; i < CURSOR_OPS.length; i++) {
-      shim.recordQuery(proto, CURSOR_OPS[i], common.makeQueryDescFunc(shim, CURSOR_OPS[i]))
-    }
-
-    shim.recordQuery(proto, 'each', common.makeQueryDescFunc(shim, 'each'))
-    shim.recordOperation(proto, 'pipe', new OperationSpec({ opaque: true }))
+    shim.recordQuery(proto, CURSOR_OPS, common.makeQueryDescFunc)
+    shim.recordQuery(proto, 'each', common.makeQueryDescFunc)
+    shim.recordOperation(proto, 'pipe', new OperationSpec({ opaque: true, name: 'pipe' }))
   }
 }
 
@@ -42,9 +38,7 @@ common.instrumentCursor = function instrumentCursor(shim, Cursor) {
 common.instrumentCollection = function instrumentCollection(shim, Collection) {
   if (Collection && Collection.prototype) {
     const proto = Collection.prototype
-    for (let i = 0; i < COLLECTION_OPS.length; i++) {
-      shim.recordQuery(proto, COLLECTION_OPS[i], common.makeQueryDescFunc(shim, COLLECTION_OPS[i]))
-    }
+    shim.recordQuery(proto, COLLECTION_OPS, common.makeQueryDescFunc)
   }
 }
 
@@ -72,13 +66,20 @@ common.instrumentBulkOperation = function instrumentBulkOperation(shim, BulkOper
 common.instrumentDb = function instrumentDb(shim, Db) {
   if (Db && Db.prototype) {
     const proto = Db.prototype
+    shim.recordOperation(proto, DB_OPS, function makeOperationDescFunc(shim, _fn, methodName) {
+      return new OperationSpec({
+        callback: shim.LAST,
+        opaque: true,
+        promise: true,
+        name: methodName
+      })
+    })
+    // link to client.connect(removed in v4.0)
     shim.recordOperation(
-      proto,
-      DB_OPS,
-      new OperationSpec({ callback: shim.LAST, opaque: true, promise: true })
+      Db,
+      'connect',
+      new OperationSpec({ callback: shim.LAST, promise: true, name: 'connect' })
     )
-    // link to client.connect(removed in v4.0)
-    shim.recordOperation(Db, 'connect', new OperationSpec({ callback: shim.LAST, promise: true }))
   }
 }
 
@@ -86,29 +87,26 @@ common.instrumentDb = function instrumentDb(shim, Db) {
  * Sets up the desc for all instrumented query methods
  *
  * @param {Shim} shim instance of shim
- * @param {string} methodName name of method getting executed
- * @returns {object} query spec
+ * @param {Function} _fn function getting instrumented
+ * @param {string} methodName name of function
+ * @returns {QuerySpec} query spec
  */
-common.makeQueryDescFunc = function makeQueryDescFunc(shim, methodName) {
+common.makeQueryDescFunc = function makeQueryDescFunc(shim, _fn, methodName) {
   if (methodName === 'each') {
-    return function eachDescFunc() {
-      const parameters = getInstanceAttributeParameters(shim, this)
-      return new QuerySpec({ query: methodName, parameters, rowCallback: shim.LAST, opaque: true })
-    }
-  }
-
-  return function queryDescFunc() {
-    // segment name does not actually use query string
-    // method name is set as query so the query parser has access to the op name
     const parameters = getInstanceAttributeParameters(shim, this)
-    return new QuerySpec({
-      query: methodName,
-      parameters,
-      promise: true,
-      callback: shim.LAST,
-      opaque: true
-    })
+    return new QuerySpec({ query: methodName, parameters, rowCallback: shim.LAST, opaque: true })
   }
+
+  // segment name does not actually use query string
+  // method name is set as query so the query parser has access to the op name
+  const parameters = getInstanceAttributeParameters(shim, this)
+  return new QuerySpec({
+    query: methodName,
+    parameters,
+    promise: true,
+    callback: shim.LAST,
+    opaque: true
+  })
 }
 
 /**
@@ -156,13 +154,10 @@ common.captureAttributesOnStarted = function captureAttributesOnStarted(
     if (connId) {
       // used in v3 when connection is a cluster pool
       if (typeof connId === 'number') {
-        setHostPort(shim, evnt.address, evnt.databaseName, this.$MongoClient)
+        setHostPort(shim, evnt.address, evnt.databaseName)
         // used in v3 when connection is to 1 host
       } else if (typeof connId === 'string') {
         setHostPort(shim, connId, evnt.databaseName)
-        // v2 contains `domainSocket`, get socket connection from `host`
-      } else if (connId.domainSocket) {
-        shim.captureInstanceAttributes('localhost', connId.host, evnt.databaseName)
         // v2 remote connection get `host` `port` from respective properties
       } else {
         shim.captureInstanceAttributes(connId.host, connId.port, evnt.databaseName)
@@ -173,37 +168,14 @@ common.captureAttributesOnStarted = function captureAttributesOnStarted(
 
 /**
  * Extracts the host and port from a connection string
- * This also handles if connection string is a domain socket
- * Mongo sticks the path to the domain socket in the "host" slot, but we
- * want it in the "port", so if we have a domain socket we need to change
- * the order of our parameters.
  *
  * @param {Shim} shim instance of shim
  * @param {string} connStr mongo connection string
  * @param {string} db database name
- * @param {object} client mongo client instance
  */
-function setHostPort(shim, connStr, db, client) {
+function setHostPort(shim, connStr, db) {
   const parts = common.parseAddress(connStr)
-  // in v3 when running with a cluster of socket connections
-  // the address is `undefined:undefined`. we will instead attempt
-  // to get connection details from the client symbol NR_ATTRS
-  // added in `lib/instrumentation/mongodb/v3-mongo` when a client connects
-  // with a URL string
-  if (parts.includes('undefined')) {
-    try {
-      const attrs = client[common.NR_ATTRS]
-      const socket = decodeURIComponent(attrs.split(',')[0].split('mongodb://')[1])
-      shim.captureInstanceAttributes('localhost', socket, db)
-    } catch (err) {
-      shim.logger.debug(err, 'Could not extract host/port from mongo command')
-    }
-    // connected using domain socket but the "host"(e.g: /path/to/mongo-socket-port.sock)
-  } else if (parts.length && parts[0][0] === '/') {
-    shim.captureInstanceAttributes('localhost', parts[0], db)
-  } else {
-    shim.captureInstanceAttributes(parts[0], parts[1], db)
-  }
+  shim.captureInstanceAttributes(parts[0], parts[1], db)
 }
 
 /**
@@ -247,13 +219,8 @@ function getInstanceAttributeParameters(shim, mongo) {
  * @returns {object} db params
  */
 function getParametersFromHosts(hosts, database) {
-  let [{ host, port }] = hosts
-  const [{ socketPath }] = hosts
+  const [{ host, port }] = hosts
 
-  if (socketPath) {
-    port = socketPath
-    host = 'localhost'
-  }
   return new DatastoreParameters({
     host,
     port_path_or_id: port,
@@ -284,13 +251,6 @@ function getParametersFromTopology(conf, database) {
     ;[{ host, port }] = conf.s.options.hosts
   }
 
-  // host is a domain socket. set host as localhost and use the domain
-  // socket host as the port
-  if (host && host.endsWith('.sock')) {
-    port = host
-    host = 'localhost'
-  }
-
   return new DatastoreParameters({
     host,
     port_path_or_id: port,

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

@@ -38,7 +38,7 @@ module.exports = function instrument(shim, mongodb) {
   const recordDesc = {
     Gridstore: {
       isQuery: false,
-      makeDescFunc: function makeGridDesc(opName) {
+      makeDescFunc: function makeGridDesc(shim, fn, opName) {
         return new OperationSpec({ name: 'GridFS-' + opName, callback: shim.LAST })
       }
     },
@@ -50,8 +50,8 @@ module.exports = function instrument(shim, mongodb) {
     Collection: { isQuery: true, makeDescFunc: makeQueryDescFunc },
     Db: {
       isQuery: false,
-      makeDescFunc: function makeDbDesc() {
-        return new OperationSpec({ callback: shim.LAST })
+      makeDescFunc: function makeDbDesc(shim, fn, method) {
+        return new OperationSpec({ callback: shim.LAST, name: method })
       }
     }
   }
@@ -95,10 +95,10 @@ module.exports = function instrument(shim, mongodb) {
         const { isQuery, makeDescFunc } = recordDesc[objectName]
         const proto = object.prototype
         if (isQuery) {
-          shim.recordQuery(proto, method, makeDescFunc(shim, method))
+          shim.recordQuery(proto, method, makeDescFunc)
         } else if (isQuery === false) {
           // could be unset
-          shim.recordOperation(proto, method, makeDescFunc(shim, method))
+          shim.recordOperation(proto, method, makeDescFunc)
         } else {
           shim.logger.trace('No wrapping method found for %s', objectName)
         }
@@ -108,7 +108,11 @@ module.exports = function instrument(shim, mongodb) {
     // the cursor object implements Readable stream and internally calls nextObject on
     // each read, in which case we do not want to record each nextObject() call
     if (/Cursor$/.test(objectName)) {
-      shim.recordOperation(object.prototype, 'pipe', new OperationSpec({ opaque: true }))
+      shim.recordOperation(
+        object.prototype,
+        'pipe',
+        new OperationSpec({ opaque: true, name: 'pipe' })
+      )
     }
   }
 }

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

@@ -11,15 +11,15 @@ const {
   instrumentBulkOperation,
   instrumentCollection,
   instrumentCursor,
-  instrumentDb,
-  NR_ATTRS
+  instrumentDb
 } = require('./common')
 
 /**
  * parser used to grab the collection and operation
  * on every mongo operation
  *
- * @param {object} operation
+ * @param {object} operation mongodb operation
+ * @returns {object} { operation, collection } parsed operation and collection
  */
 function queryParser(operation) {
   let collection = this.collectionName || 'unknown'
@@ -40,15 +40,12 @@ function queryParser(operation) {
  * to a Symbol on the MongoClient to be used later to extract the host/port in cases where the topology
  * is a cluster of domain sockets
  *
- * @param {Shim} shim
+ * @param {Shim} shim instance of shim
  * @param {object} mongodb resolved package
  */
 function instrumentClient(shim, mongodb) {
-  shim.recordOperation(mongodb.MongoClient, 'connect', function wrappedConnect(shim, _, __, args) {
-    // Add the connection url to the MongoClient to retrieve later in the `lib/instrumentation/mongo/common`
-    // captureAttributesOnStarted listener
-    this[NR_ATTRS] = args[0]
-    return new RecorderSpec({ callback: shim.LAST })
+  shim.recordOperation(mongodb.MongoClient, 'connect', function wrappedConnect(shim) {
+    return new RecorderSpec({ callback: shim.LAST, name: 'connect' })
   })
 }
 
@@ -61,7 +58,7 @@ function instrumentClient(shim, mongodb) {
  * as well as sets up a listener for when commands start to properly
  * add necessary attributes to segments
  *
- * @param {Shim} shim
+ * @param {Shim} shim instance of shim
  * @param {object} mongodb resolved package
  */
 module.exports = function instrument(shim, mongodb) {

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

@@ -18,7 +18,8 @@ const {
  * parser used to grab the collection and operation
  * from a running query
  *
- * @param {object} operation
+ * @param {object} operation mongodb operation
+ * @returns {object} { operation, collection } parsed operation and collection
  */
 function queryParser(operation) {
   let collection = this.collectionName || 'unknown'
@@ -39,23 +40,15 @@ function queryParser(operation) {
  * update host, port and database_name
  * on segment attributes
  *
- * @param {Shim} shim
- * @param {CommandStartedEvent} evnt
+ * @param {Shim} shim instance of shim
+ * @param {CommandStartedEvent} evnt mongodb event
  */
 function cmdStartedHandler(shim, evnt) {
   if (evnt.connectionId) {
-    let [host, port] = parseAddress(evnt.address)
-
-    // connection via socket get port from 1st host
-    // socketPath property
-    // which looks like mongodb:///tmp/mongodb-27017.sock"
-    if (['undefined'].includes(host, port)) {
-      host = 'localhost'
-      const hosts = this.s.options.hosts
-      if (hosts && hosts.length && hosts[0].socketPath) {
-        port = hosts[0].socketPath
-      }
-    } else if (['127.0.0.1', '::1', '[::1]'].includes(host)) {
+    const address = parseAddress(evnt.address)
+    let [host] = address
+    const [, port] = address
+    if (['127.0.0.1', '::1', '[::1]'].includes(host)) {
       host = 'localhost'
     }
 
@@ -68,12 +61,13 @@ function cmdStartedHandler(shim, evnt) {
  * enable APM(monitorCommands) and add the
  * `commandStarted` listener
  *
- * @param {Shim} shim
+ * @param {Shim} shim instance of shim
+ * @returns {OperationSpec} spec to capture connect method
  */
 function wrapConnect(shim) {
   this.monitorCommands = true
   this.on('commandStarted', cmdStartedHandler.bind(this, shim))
-  return new OperationSpec({ callback: shim.LAST })
+  return new OperationSpec({ callback: shim.LAST, name: 'connect' })
 }
 
 /**
@@ -82,7 +76,7 @@ function wrapConnect(shim) {
  * so we can properly update the segment attributes with a more accurate
  * host/port/database name
  *
- * @param {Shim} shim
+ * @param {Shim} shim instance of shim
  * @param {MongoClient} MongoClient reference
  */
 function instrumentMongoClient(shim, MongoClient) {

package/lib/instrumentation/pg.js

@@ -6,7 +6,7 @@
 'use strict'
 
 const { nrEsmProxy } = require('../symbols')
-const { RecorderSpec, QuerySpec } = require('../shim/specs')
+const { RecorderSpec, QuerySpec, ClassWrapSpec } = require('../shim/specs')
 const DatastoreParameters = require('../shim/specs/params/datastore')
 
 function getQuery(shim, original, name, args) {
@@ -58,12 +58,12 @@ module.exports = function initialize(agent, pgsql, moduleName, shim) {
   // wrapping for native
   function instrumentPGNative(pg) {
     shim.wrapReturn(pg, 'Client', clientFactoryWrapper)
-    shim.wrapClass(pg, 'Pool', { post: poolPostConstructor, es6: true })
+    shim.wrapClass(pg, 'Pool', new ClassWrapSpec({ post: poolPostConstructor, es6: true }))
   }
 
   function poolPostConstructor(shim) {
     if (!shim.isWrapped(this.Client)) {
-      shim.wrapClass(this, 'Client', clientPostConstructor)
+      shim.wrapClass(this, 'Client', new ClassWrapSpec({ post: clientPostConstructor }))
     }
   }
 

package/lib/instrumentation-descriptor.js

@@ -30,6 +30,7 @@ const idGen = new IdGen()
  * @property {string} absolutePath
  * @property {string} module
  * @property {string} moduleName
+ * @property {string} shimName
  * @property {InstrumentationOnError} onError
  * @property {InstrumentationOnRequire} onRequire
  * @property {string} resolvedName
@@ -117,6 +118,14 @@ class InstrumentationDescriptor {
    */
   moduleName
 
+  /**
+   * Used when instrumenting a module to determine if a module has already
+   * been wrapped by a specific shim instance. It is used in conjunction with
+   * the `shim.id` value.
+   * @type {string}
+   */
+  shimName
+
   /**
    * The absolute path to the module to instrument. This should only be set
    * when the module being instrumented does not reside in a `node_modules`
@@ -163,6 +172,7 @@ class InstrumentationDescriptor {
     this.absolutePath = params.absolutePath
     this.module = params.module
     this.moduleName = params.moduleName
+    this.shimName = params.shimName
     this.onError = params.onError
     this.onRequire = params.onRequire
     this.resolvedName = params.resolvedName
@@ -184,3 +194,22 @@ class InstrumentationDescriptor {
 }
 
 module.exports = InstrumentationDescriptor
+
+// This export is for backward compatibility in the public API. The
+// public API object simply re-exports this object that was originally
+// in a `constants.js` file prior to the creation of the
+// `InstrumentationDescriptor`.
+module.exports.TYPES = {
+  GENERIC: InstrumentationDescriptor.TYPE_GENERIC,
+
+  DATASTORE: InstrumentationDescriptor.TYPE_DATASTORE,
+  MESSAGE: InstrumentationDescriptor.TYPE_MESSAGE,
+  PROMISE: InstrumentationDescriptor.TYPE_PROMISE,
+
+  WEB_FRAMEWORK: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK,
+  TRACKING: InstrumentationDescriptor.TYPE_TRACKING,
+  /** @private */
+  CONGLOMERATE: InstrumentationDescriptor.TYPE_CONGLOMERATE,
+  /** @private */
+  TRANSACTION: InstrumentationDescriptor.TYPE_TRANSACTION
+}

package/lib/instrumentations.js

@@ -5,44 +5,44 @@
 
 'use strict'
 
-const MODULE_TYPE = require('./shim/constants').MODULE_TYPE
+const InstrumentationDescriptor = require('./instrumentation-descriptor')
 
 // Return a new copy of this array every time we're called
 module.exports = function instrumentations() {
   return {
     'aws-sdk': { module: '@newrelic/aws-sdk' },
     'amqplib': { module: './instrumentation/amqplib' },
-    'cassandra-driver': { type: MODULE_TYPE.DATASTORE },
-    'connect': { type: MODULE_TYPE.WEB_FRAMEWORK },
-    'bluebird': { type: MODULE_TYPE.PROMISE },
-    'bunyan': { type: MODULE_TYPE.GENERIC },
-    'director': { type: MODULE_TYPE.WEB_FRAMEWORK },
-    '@elastic/elasticsearch': { type: MODULE_TYPE.DATASTORE },
-    'express': { type: MODULE_TYPE.WEB_FRAMEWORK },
-    'fastify': { type: MODULE_TYPE.WEB_FRAMEWORK },
-    'generic-pool': { type: MODULE_TYPE.GENERIC },
+    'cassandra-driver': { type: InstrumentationDescriptor.TYPE_DATASTORE },
+    'connect': { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
+    'bluebird': { type: InstrumentationDescriptor.TYPE_PROMISE },
+    'bunyan': { type: InstrumentationDescriptor.TYPE_GENERIC },
+    'director': { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
+    '@elastic/elasticsearch': { type: InstrumentationDescriptor.TYPE_DATASTORE },
+    'express': { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
+    'fastify': { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
+    'generic-pool': { type: InstrumentationDescriptor.TYPE_GENERIC },
     '@grpc/grpc-js': { module: './instrumentation/grpc-js' },
-    '@hapi/hapi': { type: MODULE_TYPE.WEB_FRAMEWORK },
-    'ioredis': { type: MODULE_TYPE.DATASTORE },
+    '@hapi/hapi': { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
+    'ioredis': { type: InstrumentationDescriptor.TYPE_DATASTORE },
     'koa': { module: '@newrelic/koa' },
     'langchain': { module: './instrumentation/langchain' },
-    'memcached': { type: MODULE_TYPE.DATASTORE },
-    'mongodb': { type: MODULE_TYPE.DATASTORE },
+    'memcached': { type: InstrumentationDescriptor.TYPE_DATASTORE },
+    'mongodb': { type: InstrumentationDescriptor.TYPE_DATASTORE },
     'mysql': { module: './instrumentation/mysql' },
-    'openai': { type: MODULE_TYPE.GENERIC },
-    '@nestjs/core': { type: MODULE_TYPE.WEB_FRAMEWORK },
-    '@prisma/client': { type: MODULE_TYPE.DATASTORE },
+    'openai': { type: InstrumentationDescriptor.TYPE_GENERIC },
+    '@nestjs/core': { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
+    '@prisma/client': { type: InstrumentationDescriptor.TYPE_DATASTORE },
     'pino': { module: './instrumentation/pino' },
-    'pg': { type: MODULE_TYPE.DATASTORE },
+    'pg': { type: InstrumentationDescriptor.TYPE_DATASTORE },
     'q': { type: null },
-    'redis': { type: MODULE_TYPE.DATASTORE },
-    '@node-redis/client': { type: MODULE_TYPE.DATASTORE },
-    '@redis/client': { type: MODULE_TYPE.DATASTORE },
-    'restify': { type: MODULE_TYPE.WEB_FRAMEWORK },
+    'redis': { type: InstrumentationDescriptor.TYPE_DATASTORE },
+    '@node-redis/client': { type: InstrumentationDescriptor.TYPE_DATASTORE },
+    '@redis/client': { type: InstrumentationDescriptor.TYPE_DATASTORE },
+    'restify': { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
     'superagent': { module: '@newrelic/superagent' },
-    '@hapi/vision': { type: MODULE_TYPE.WEB_FRAMEWORK },
+    '@hapi/vision': { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
     'when': { module: './instrumentation/when' },
-    'winston': { type: MODULE_TYPE.GENERIC },
+    'winston': { type: InstrumentationDescriptor.TYPE_GENERIC },
     /**
      * The modules below are listed here purely to take
      * advantage of the Supportability/Features/onRequire/<module>
@@ -52,11 +52,11 @@ module.exports = function instrumentations() {
      *  Libraries that have OpenTelemetry instrumentation we want to register
      *  or have already registered.
      */
-    'loglevel': { type: MODULE_TYPE.TRACKING },
-    'npmlog': { type: MODULE_TYPE.TRACKING },
-    'fancy-log': { type: MODULE_TYPE.TRACKING },
-    'knex': { type: MODULE_TYPE.TRACKING },
-    '@azure/openai': { type: MODULE_TYPE.TRACKING },
-    '@langchain/community/llms/bedrock': { type: MODULE_TYPE.TRACKING }
+    'loglevel': { type: InstrumentationDescriptor.TYPE_TRACKING },
+    'npmlog': { type: InstrumentationDescriptor.TYPE_TRACKING },
+    'fancy-log': { type: InstrumentationDescriptor.TYPE_TRACKING },
+    'knex': { type: InstrumentationDescriptor.TYPE_TRACKING },
+    '@azure/openai': { type: InstrumentationDescriptor.TYPE_TRACKING },
+    '@langchain/community/llms/bedrock': { type: InstrumentationDescriptor.TYPE_TRACKING }
   }
 }

package/lib/llm-events/langchain/event.js

@@ -46,7 +46,6 @@ class LangChainEvent extends BaseEvent {
   appName
   span_id
   request_id
-  transaction_id
   trace_id
   ingest_source = 'Node'
   vendor = 'langchain'
@@ -60,7 +59,6 @@ class LangChainEvent extends BaseEvent {
     this.appName = agent.config.applications()[0]
     this.span_id = segment?.id
     this.request_id = params.runId
-    this.transaction_id = segment?.transaction?.id
     this.trace_id = segment?.transaction?.traceId
     this.langchainMeta = params.metadata
     this.metadata = agent

package/lib/llm-events/openai/chat-completion-summary.js

@@ -13,7 +13,6 @@ module.exports = class LlmChatCompletionSummary extends LlmEvent {
     this['request.max_tokens'] = request.max_tokens
     this['request.temperature'] = request.temperature
     this['response.number_of_messages'] = request?.messages?.length + response?.choices?.length
-    this['response.usage.completion_tokens'] = response?.usage?.completion_tokens
     this['response.choices.finish_reason'] = response?.choices?.[0]?.finish_reason
   }
 }

package/lib/llm-events/openai/event.js

@@ -17,7 +17,6 @@ module.exports = class LlmEvent extends BaseEvent {
     this.request_id = response?.headers?.['x-request-id']
     this.trace_id = segment?.transaction?.traceId
     this.span_id = segment?.id
-    this.transaction_id = segment?.transaction?.id
     this['response.model'] = response.model
     this.vendor = 'openai'
     this.ingest_source = 'Node'
@@ -38,8 +37,6 @@ module.exports = class LlmEvent extends BaseEvent {
 
   responseAttrs(response) {
     this['response.organization'] = response?.headers?.['openai-organization']
-    this['response.usage.total_tokens'] = response?.usage?.total_tokens
-    this['response.usage.prompt_tokens'] = response?.usage?.prompt_tokens
     this['response.headers.llmVersion'] = response?.headers?.['openai-version']
     this['response.headers.ratelimitLimitRequests'] =
       response?.headers?.['x-ratelimit-limit-requests']