newrelic 8.2.0 → 8.5.1

package/lib/instrumentation/mongodb/common.js

@@ -5,9 +5,8 @@
 
 'use strict'
 const { CURSOR_OPS, COLLECTION_OPS, DB_OPS } = require('./constants')
-const { URL } = require('url')
-
 const common = module.exports
+common.NR_ATTRS = Symbol('NR_ATTRS')
 
 /**
  * Instruments all methods from constants.CURSOR_OPS on a given
@@ -24,7 +23,7 @@ common.instrumentCursor = function instrumentCursor(shim, Cursor) {
     }
 
     shim.recordQuery(proto, 'each', common.makeQueryDescFunc(shim, 'each'))
-    shim.recordOperation(proto, 'pipe')
+    shim.recordOperation(proto, 'pipe', { opaque: true })
   }
 }
 
@@ -48,9 +47,11 @@ common.instrumentCollection = function instrumentCollection(shim, Collection) {
  * Instruments all methods from constants.DB_OPS on
  * the Db class.
  *
- * @param {Object} params
+ * @param {object} params
  * @param {Shim} params.shim
  * @param {Db} params.Db
+ * @param shim
+ * @param Db
  */
 common.instrumentDb = function instrumentDb(shim, Db) {
   if (Db && Db.prototype) {
@@ -63,6 +64,7 @@ common.instrumentDb = function instrumentDb(shim, Db) {
 
 /**
  * Sets up the desc for all instrumented query methods
+ *
  * @param {Shim} shim
  * @param {string} methodName
  */
@@ -97,18 +99,16 @@ common.captureAttributesOnStarted = function captureAttributesOnStarted(shim, in
     // out of an excess of caution.
     const connId = evnt.connectionId
     if (connId) {
-      // 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.
-      if (typeof connId === 'string') {
-        const parts = connId.split(':')
-        if (parts.length && parts[0][0] === '/') {
-          shim.captureInstanceAttributes('localhost', parts[0], evnt.databaseName)
-        } else {
-          shim.captureInstanceAttributes(parts[0], parts[1], evnt.databaseName)
-        }
+      // used in v3 when connection is a cluster pool
+      if (typeof connId === 'number') {
+        setHostPort(shim, evnt.address, evnt.databaseName, this.$MongoClient)
+        // 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)
       }
@@ -116,11 +116,49 @@ common.captureAttributesOnStarted = function captureAttributesOnStarted(shim, in
   })
 }
 
+/**
+ * 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
+ * @param {string} connStr
+ * @param {string} db database name
+ * @param {object} client mongo client instance
+ */
+function setHostPort(shim, connStr, db, client) {
+  const parts = connStr.split(':')
+  // 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)
+  }
+}
+
 /**
  * Get the database_name, host, port_path_or_id
  * for the query segment. v4 refactored where the toplogy is stored.
  * You can now get the details via the client obj that's deeply nested
  * See: https://github.com/mongodb/node-mongodb-native/pull/2594/files#diff-1d214e57ddda9095d296e5700ebce701333bfefcf417e234c584d14091b2f50dR168
+ *
+ * @param shim
+ * @param obj
  */
 function getInstanceAttributeParameters(shim, obj) {
   if (obj.s && obj.s.db && obj.s.topology) {
@@ -136,13 +174,18 @@ function getInstanceAttributeParameters(shim, obj) {
     obj.s.db.s &&
     obj.s.db.s.client &&
     obj.s.db.s.client.s &&
-    obj.s.db.s.client.s.url
+    obj.s.db.s.client.s.options &&
+    obj.s.db.s.client.s.options.hosts &&
+    obj.s.db.s.client.s.options.hosts.length
   ) {
-    let { hostname: host, port } = new URL(obj.s.db.s.client.s.url)
-    if (host.endsWith('.sock')) {
-      // socket path is uri encoded
-      // decode it to properly name attrs
-      port = decodeURIComponent(host)
+    // hosts is an array but we will always pull the first for consistency
+    const hosts = obj.s.db.s.client.s.options.hosts
+    let host = hosts[0].host
+    let port = hosts[0].port
+    const socketPath = hosts[0].socketPath
+
+    if (socketPath) {
+      port = socketPath
       host = 'localhost'
     }
     return {
@@ -160,12 +203,19 @@ function getInstanceAttributeParameters(shim, obj) {
   }
 
   function doCapture(conf, database) {
+    // in older versions of 3.x the host/port
+    // lived directly on the topology.s.options
     let host = conf.host
     let port = conf.port
 
-    // If using a domain socket, mongo stores the path as the host name, but we
-    // pass it through the port value.
-    if ((conf.socketOptions && conf.socketOptions.domainSocket) || /\.sock$/.test(host)) {
+    // servers is an array but we will always pull the first for consistency
+    if (conf.servers && conf.servers.length) {
+      ;[{ host, port }] = conf.servers
+    }
+
+    // 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'
     }

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

@@ -9,7 +9,8 @@ const {
   captureAttributesOnStarted,
   instrumentCollection,
   instrumentCursor,
-  instrumentDb
+  instrumentDb,
+  NR_ATTRS
 } = require('./common')
 
 /**
@@ -30,6 +31,23 @@ function queryParser(operation) {
   return { operation, collection }
 }
 
+/**
+ * Records the `mongo.MongoClient.connect` operations. It also adds the first arg of connect(url)
+ * 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 {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 { callback: shim.LAST }
+  })
+}
+
 /**
  * Registers relevant instrumentation for mongo >= 3.0.6
  * In 3.0.6 they refactored their "APM" module which removed
@@ -44,6 +62,7 @@ function queryParser(operation) {
  */
 module.exports = function instrument(shim, mongodb) {
   shim.setParser(queryParser)
+  instrumentClient(shim, mongodb)
   const instrumenter = mongodb.instrument(Object.create(null), () => {})
   captureAttributesOnStarted(shim, instrumenter)
   instrumentCursor(shim, mongodb.Cursor)

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

@@ -36,15 +36,14 @@ function cmdStartedHandler(shim, evnt) {
   if (evnt.connectionId) {
     let [host, port] = evnt.address.split(':')
 
-    // connection via socket get port from client.url
-    // which looks like "mongodb://%2Ftmp%2Fmongodb-27017.sock"
+    // 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'
-      // socket path is uri encoded
-      // decode it to properly name attrs
-      const socketPath = this.s.url.split(':')
-      if (socketPath.length && socketPath[1].startsWith('//')) {
-        port = decodeURIComponent(socketPath[1].substr(2))
+      const hosts = this.s.options.hosts
+      if (hosts && hosts.length && hosts[0].socketPath) {
+        port = hosts[0].socketPath
       }
     } else if (host === '127.0.0.1') {
       host = 'localhost'

package/lib/instrumentation/mysql.js

@@ -5,8 +5,8 @@
 
 'use strict'
 
-var dbutils = require('../db/utils')
-var properties = require('../util/properties')
+const dbutils = require('../db/utils')
+const properties = require('../util/properties')
 
 module.exports = function initialize(agent, mysql, moduleName, shim) {
   shim.setDatastore(shim.MYSQL)
@@ -16,7 +16,7 @@ module.exports = function initialize(agent, mysql, moduleName, shim) {
   function wrapCreateConnection(shim, fn, fnName, connection) {
     shim.logger.debug('Wrapping Connection#query')
     if (wrapQueriable(shim, connection, false)) {
-      var connProto = Object.getPrototypeOf(connection)
+      const connProto = Object.getPrototypeOf(connection)
       shim.setInternalProperty(connProto, '__NR_storeDatabase', true)
       shim.unwrap(mysql, 'createConnection')
     }
@@ -33,7 +33,7 @@ module.exports = function initialize(agent, mysql, moduleName, shim) {
   shim.wrapReturn(mysql, 'createPoolCluster', wrapCreatePoolCluster)
   function wrapCreatePoolCluster(shim, fn, fnName, poolCluster) {
     shim.logger.debug('Wrapping PoolCluster#of')
-    var proto = Object.getPrototypeOf(poolCluster)
+    const proto = Object.getPrototypeOf(poolCluster)
     shim.wrapReturn(proto, 'of', wrapPoolClusterOf)
     function wrapPoolClusterOf(shim, of, _n, poolNamespace) {
       if (wrapGetConnection(shim, poolNamespace)) {
@@ -61,11 +61,11 @@ function wrapGetConnection(shim, connectable) {
     return false
   }
 
-  var proto = Object.getPrototypeOf(connectable)
+  const proto = Object.getPrototypeOf(connectable)
   shim.wrap(proto, 'getConnection', function doWrapGetConnection(shim, fn) {
     return function wrappedGetConnection() {
-      var args = shim.toArray(arguments)
-      var cbIdx = args.length - 1
+      const args = shim.toArray(arguments)
+      const cbIdx = args.length - 1
 
       if (shim.isFunction(args[cbIdx]) && !shim.isWrapped(args[cbIdx])) {
         shim.logger.trace(
@@ -74,7 +74,7 @@ function wrapGetConnection(shim, connectable) {
           },
           'Wrapping callback with segment'
         )
-        var cb = args[cbIdx]
+        let cb = args[cbIdx]
         if (!shim.__wrappedPoolConnection) {
           cb = shim.wrap(cb, wrapGetConnectionCallback)
         }
@@ -119,9 +119,9 @@ function wrapQueriable(shim, queriable, isPoolQuery) {
     return false
   }
 
-  var proto = Object.getPrototypeOf(queriable)
+  const proto = Object.getPrototypeOf(queriable)
 
-  var describe
+  let describe
   if (isPoolQuery) {
     describe = describePoolQuery
   } else {
@@ -139,8 +139,8 @@ function wrapQueriable(shim, queriable, isPoolQuery) {
 }
 
 function extractQueryArgs(shim, args) {
-  var query = ''
-  var callback = null
+  let query = ''
+  let callback = null
 
   // Figure out the query parameter.
   if (shim.isString(args[0])) {
@@ -168,10 +168,10 @@ function extractQueryArgs(shim, args) {
 
 function describeQuery(shim, queryFn, fnName, args) {
   shim.logger.trace('Recording query')
-  var extractedArgs = extractQueryArgs(shim, args)
+  const extractedArgs = extractQueryArgs(shim, args)
 
   // Pull out instance attributes.
-  var parameters = getInstanceParameters(shim, this, extractedArgs.query)
+  const parameters = getInstanceParameters(shim, this, extractedArgs.query)
 
   shim.logger.trace(
     {
@@ -193,7 +193,7 @@ function describeQuery(shim, queryFn, fnName, args) {
 
 function describePoolQuery(shim, queryFn, fnName, args) {
   shim.logger.trace('Recording pool query')
-  var extractedArgs = extractQueryArgs(shim, args)
+  const extractedArgs = extractQueryArgs(shim, args)
   return {
     stream: true,
     query: null,
@@ -204,10 +204,10 @@ function describePoolQuery(shim, queryFn, fnName, args) {
 }
 
 function getInstanceParameters(shim, queryable, query) {
-  var parameters = { host: null, port_path_or_id: null, database_name: null }
-  var conf = queryable.config
+  const parameters = { host: null, port_path_or_id: null, database_name: null }
+  let conf = queryable.config
   conf = (conf && conf.connectionConfig) || conf
-  var databaseName = queryable.__NR_databaseName || null
+  let databaseName = queryable.__NR_databaseName || null
   if (conf) {
     parameters.database_name = databaseName = databaseName || conf.database
 
@@ -229,7 +229,7 @@ function getInstanceParameters(shim, queryable, query) {
 
 function storeDatabaseName(shim, queryable, query) {
   if (queryable.__NR_storeDatabase) {
-    var databaseName = dbutils.extractDatabaseChangeFromUse(query)
+    const databaseName = dbutils.extractDatabaseChangeFromUse(query)
     if (databaseName) {
       shim.setInternalProperty(queryable, '__NR_databaseName', databaseName)
     }

package/lib/instrumentation/oracle.js

@@ -5,14 +5,14 @@
 
 'use strict'
 
-var logger = require('../logger').child({ component: 'oracle' })
-var shimmer = require('../shimmer')
-var parseSql = require('../db/parse-sql')
-var ORACLE = require('../metrics/names').ORACLE
+const logger = require('../logger').child({ component: 'oracle' })
+const shimmer = require('../shimmer')
+const parseSql = require('../db/parse-sql')
+const ORACLE = require('../metrics/names').ORACLE
 
 module.exports = function initialize(agent, oracle) {
-  var tracer = agent.tracer
-  var wrapped = false
+  const tracer = agent.tracer
+  let wrapped = false
 
   logger.trace('wrapping oracle.connect and oracle.connectSync')
 
@@ -31,7 +31,7 @@ module.exports = function initialize(agent, oracle) {
 
   shimmer.wrapMethod(oracle, 'Oracle', 'connectSync', function wrapSyncConnect(connect) {
     return function wrappedSyncConnect() {
-      var connection = connect.apply(this, arguments)
+      const connection = connect.apply(this, arguments)
       ensureConnectionWrapped(connection)
       return connection
     }
@@ -51,13 +51,13 @@ module.exports = function initialize(agent, oracle) {
       return tracer.wrapFunctionNoSegment(connect, 'connect')
     })
 
-    var proto = Object.getPrototypeOf(connection)
+    const proto = Object.getPrototypeOf(connection)
     wrapConnectionExecute(proto, tracer)
     wrapConnectionPrepare(proto, tracer)
 
     shimmer.wrapMethod(proto, 'Oracle', 'reader', function wrapMethod(createReader) {
       return function wrappedConnect(sql) {
-        var reader = createReader.apply(this, arguments)
+        const reader = createReader.apply(this, arguments)
         wrapReader(reader, tracer, sql)
         return reader
       }
@@ -73,9 +73,9 @@ function wrapConnectionExecute(connection, tracer) {
   }
 
   function wrappedExecute(segment, args, bind) {
-    var ps = parseSql(ORACLE.PREFIX, args[0])
-    var collection = ps.collection
-    var operation = ps.operation
+    const ps = parseSql(ORACLE.PREFIX, args[0])
+    const collection = ps.collection
+    const operation = ps.operation
 
     segment.name = ORACLE.STATEMENT + collection + '/Connection.execute/' + operation
     logger.trace('capturing oracle query. collection: %s, Operation: %s', collection, operation)
@@ -87,7 +87,7 @@ function wrapConnectionExecute(connection, tracer) {
 }
 
 function wrapReader(reader, tracer, sql) {
-  var ps = parseSql(ORACLE.PREFIX, sql)
+  const ps = parseSql(ORACLE.PREFIX, sql)
   shimmer.wrapMethod(reader, 'Oracle.Reader', 'nextRow', wrapNextRow)
   shimmer.wrapMethod(reader, 'Oracle.Reader', 'nextRows', wrapNextRows)
 
@@ -113,8 +113,8 @@ function wrapConnectionPrepare(connection, tracer) {
 
   function wrapPrepare(prepare) {
     return function wrappedPrepare(sql) {
-      var ps = parseSql(ORACLE.PREFIX, sql)
-      var prepared = prepare.apply(this, arguments)
+      const ps = parseSql(ORACLE.PREFIX, sql)
+      const prepared = prepare.apply(this, arguments)
       shimmer.wrapMethod(prepared, 'Oracle', 'execute', wrapExecute)
       return prepared
 

package/lib/instrumentation/pg.js

@@ -8,8 +8,8 @@
 const semver = require('semver')
 
 function getQuery(shim, original, name, args) {
-  var config = args[0]
-  var statement
+  const config = args[0]
+  let statement
   if (config && (typeof config === 'string' || config instanceof String)) {
     statement = config
   } else if (config && config.text) {
@@ -98,11 +98,11 @@ module.exports = function initialize(agent, pgsql, moduleName, shim) {
   // client.  The original getter replaces itself with the instance of the native
   // client, so only instrument if the getter exists (otherwise assume already
   // instrumented).
-  var origGetter = pgsql.__lookupGetter__('native')
+  const origGetter = pgsql.__lookupGetter__('native')
   if (origGetter) {
     delete pgsql.native
     pgsql.__defineGetter__('native', function getNative() {
-      var temp = origGetter()
+      const temp = origGetter()
       if (temp != null) {
         instrumentPGNative(temp)
       }